Example #1
0
void __exit destroyDM()
{
	destroyCFSThread();
	dictRelease(g_dataModel.cfsHashTable);
	dictRelease(g_cfmDict);
	return ;
}
Example #2
0
int initDbEngine(void)
{
    objectIndexLength = 256;
    objectIndexFreeId = 0;
    objectIndexCount = 0;
    if (NULL == (objectIndex = (const dbObject **) calloc(objectIndexLength, (sizeof(const dbObject *)))))
        return -1;

    if (NULL == (sets = dictCreate(&dictSetType, NULL)))
    {
        free((void *) objectIndex);
        return -1;
    }

    if (0 != registerSyncObject(sets))
    {
        free((void *) objectIndex);
        dictRelease(sets);
        return -1;
    }

    if (0 != registerSyncObject(objectIndex))
    {
        unregisterSyncObject(sets);
        free((void *) objectIndex);
        dictRelease(sets);
        return -1;
    }

    return 0;
}
Example #3
0
/* release memory allocated for copy on write during background save */
void cowBkgdSaveReset() {
    int j;
    listNode *ln;

    if (server.cowDictCopied != NULL) {
        for (j = 0; j < server.dbnum; j++) {
            if (server.cowSaveDb[j].dict != NULL) {
                /* restore normal dictionary destructors */
                restore_dictobj(server.db[j].dict, &server.cowSaveDbExt[j]);
                server.cowSaveDb[j].dict = NULL;
            }

            if (server.cowSaveDbExt[j].dictArray != NULL) {
                cowReleaseDictArray(server.cowSaveDbExt[j].dictArray);
                server.cowSaveDbExt[j].dictArray = NULL;
            }

            if (server.cowSaveDb[j].expires != NULL &&
                server.cowSaveDb[j].expires != server.db[j].expires) {
                dictRelease(server.cowSaveDb[j].expires);
                server.cowSaveDb[j].expires = NULL;
            }
        }
    }

    server.cowCurIters.curDbDictIter = NULL;
    server.cowCurIters.curObjDictIter = NULL;
    server.cowCurIters.curObjZDictIter = NULL;
    server.cowCurIters.curObjListIter = NULL;

    /* cleanup table of copied items */
    if (server.cowDictCopied != NULL) {
        dictRelease(server.cowDictCopied);
        server.cowDictCopied = NULL;
    }

    if (server.cowDictConverted != NULL) {
        dictRelease(server.cowDictConverted);
        server.cowDictConverted = NULL;
    }

    /* delete all deferred items */
    redisLog(REDIS_NOTICE, "cowBkgdSaveReset deleting %d SDS and %d obj items",
                listLength(deferSdsDelete), listLength(deferObjDelete));
    while ( (ln = listFirst(deferSdsDelete)) != NULL) {
        sdsfree((sds)(ln->value));
        listDelNode(deferSdsDelete, ln);
    }
    while ( (ln = listFirst(deferObjDelete)) != NULL) {
        if (ln->value != NULL) {
            decrRefCount(ln->value);
        }
        listDelNode(deferObjDelete, ln);
    }
}
Example #4
0
/* Helper function to free the context. */
static void __redisAsyncFree(redisAsyncContext *ac) {
    redisContext *c = &(ac->c);
    redisCallback cb;
    dictIterator *it;
    dictEntry *de;

    // 执行所有等待队列中回调函数,将空回复传进去
    /* Execute pending callbacks with NULL reply. */
    while (__redisShiftCallback(&ac->replies,&cb) == REDIS_OK)
        __redisRunCallback(ac,&cb,NULL);

    // 执行所有等待队列中回调函数,将空回复传进去
    // 这里是无效命令的回调函数
    /* Execute callbacks for invalid commands */
    while (__redisShiftCallback(&ac->sub.invalid,&cb) == REDIS_OK)
        __redisRunCallback(ac,&cb,NULL);

    // 执行所有等待队列中回调函数,将空回复传进去
    // 这里是订阅发布的回调函数
    /* Run subscription callbacks callbacks with NULL reply */
    it = dictGetIterator(ac->sub.channels);
    while ((de = dictNext(it)) != NULL)
        __redisRunCallback(ac,dictGetEntryVal(de),NULL);
    dictReleaseIterator(it);
    dictRelease(ac->sub.channels);

    // 执行所有等待队列中回调函数,将空回复传进去
    // 这里是订阅发布的回调函数
    it = dictGetIterator(ac->sub.patterns);
    while ((de = dictNext(it)) != NULL)
        __redisRunCallback(ac,dictGetEntryVal(de),NULL);
    dictReleaseIterator(it);
    dictRelease(ac->sub.patterns);

    // 注销连接上的读写事件
    /* Signal event lib to clean up */
    _EL_CLEANUP(ac);

    // 执行连接关闭回调函数,可做一些清理工作
    /* Execute disconnect callback. When redisAsyncFree() initiated destroying
     * this context, the status will always be REDIS_OK. */
    if (ac->onDisconnect && (c->flags & REDIS_CONNECTED)) {
        if (c->flags & REDIS_FREEING) {
            ac->onDisconnect(ac,REDIS_OK);
        } else {
            ac->onDisconnect(ac,(ac->err == 0) ? REDIS_OK : REDIS_ERR);
        }
    }

    // 释放 redisContext 中的内存
    /* Cleanup self */
    redisFree(c);
}
Example #5
0
/* Release resources related to Lua scripting.
 * 释放 Lua 脚本的相关资源
 * This function is used in order to reset the scripting environment.
 * 用于初始化脚本环境
 */
void scriptingRelease(void)
{
    // 释放记录脚本的字典
    dictRelease(server.lua_scripts);
    // 关闭 Lua 环境
    lua_close(server.lua);
}
Example #6
0
void dictCounterDestructor(void *privdata, void *val) {
    DICT_NOTUSED(privdata);
    listNode *ln;
    listIter li;
    counter *cntr = val;
    pubsub *p;

    /* Unsubscribe everyone */
    if (cntr->subscribers != NULL) {
        while (listLength(cntr->subscribers)) {
            ln = listFirst(cntr->subscribers);
            p  = listNodeValue(ln);
            pubsubUnsubscribeCounter(p->c,cntr->name,1);
        }
    }

    /* Free all shards */
    listRewind(cntr->shards,&li);
    while ((ln = listNext(&li)) != NULL) {
        shard *shrd = listNodeValue(ln);
        zfree(shrd);
    }

    listRelease(cntr->shards);
    if (cntr->want_acks) dictRelease(cntr->want_acks);

    /* cntr->name will be freed by the dict code. */

    zfree(cntr);
}
Example #7
0
int main(int argc, char *argv[]) 
{
    int ret;
    dict *d = dictCreate(&testDictType, NULL);
    assert(d);
    Key_t *k = (Key_t*)malloc(sizeof(*k)); 
    k->laddr = 112;
    k->raddr = 112;
    k->lport = 1123;
    k->rport = 3306;

    Val_t *v = (Val_t*)malloc(sizeof(*v)); 
    v->v = malloc(100);
    snprintf(v->v, 100, "%s", "abcdefg");
    
    ret = dictAdd(d, k, v);
    assert(ret == DICT_OK);

    Val_t *v2 = dictFetchValue(d, k);

    assert(0 == strcmp(v2->v, v->v));

    printf("%d-%s-%s\n", ret, v->v, v2->v);

    dictPrintStats(d);

    dictDelete(d, k);

    dictPrintStats(d);

    dictRelease(d);

    return 0;
}
Example #8
0
void freeZsetObject(robj *o) {
    zset *zs = o->ptr;

    dictRelease(zs->dict);
    zslFree(zs->zsl);
    zfree(zs);
}
Example #9
0
File: engine.c Project: fizx/sit
void
engine_free(Engine *engine) {
  dictRelease(engine->queries);
  if(engine->data_dir) {
    pstring_free(engine->data_dir);
  }
  parser_free(engine->parser);
  ring_buffer_free(engine->stream);
  if(engine->auth) pstring_free(engine->auth);
  lrw_dict_free(engine->term_dictionary);
  plist_pool_free(engine->postings);
  if(engine->docs->on_evict)callback_free(engine->docs->on_evict);
  ring_buffer_free(engine->docs);
  dictRelease(engine->ints);
  if(engine->doc_set) dictRelease(engine->doc_set);
  free(engine);
}
Example #10
0
void
cmd_mgr_destroy (command_manager * mgr)
{
  aeDeleteTimeEvent (mgr->el, mgr->cron_teid);
  dictRelease (mgr->commands);
  index_helper_destroy (mgr->idx_helper);
  mempool_destroy (mgr->mp_cmdctx);
  zfree (mgr);
}
Example #11
0
void deallocStaticFile()
{
    if (AllowExtensions)
        dictRelease(AllowExtensions);
    if (DirectoryIndex)
        freeList(DirectoryIndex);
    MaxFileSize = 0;
    wstrFree(IfModifiedSince);
}
Example #12
0
int main(int argc, const char *argv[])
{
    struct timeval start, end;
    double elapsed;
    dict *d;
    struct bftree *tree;
    const int times = 500;

    struct bftree_opts opt = {
        NULL, NULL, bftreeSdsKeyCompare, (void (*)(void*))sdsfree, (void (*)(void*))sdsfree
    };
    tree = bftree_create(&opt);

    d = dictCreate(&sdsdict_type, NULL);

    gettimeofday(&start, NULL);
    redis_add(d, times);
    gettimeofday(&end, NULL);
    elapsed = get_seconds(start, end);
    printf("redis add %d elements seconds: %f\n", times, elapsed);

    gettimeofday(&start, NULL);
    tree = bftree_add(tree, times);
    gettimeofday(&end, NULL);
    elapsed = get_seconds(start, end);
    printf("bftree add %d elements seconds: %f\n", times, elapsed);

    gettimeofday(&start, NULL);
    redis_fetch(d, times);
    gettimeofday(&end, NULL);
    elapsed = get_seconds(start, end);
    printf("redis get %d elements seconds: %f\n", times, elapsed);

    gettimeofday(&start, NULL);
    bftree_fetch(tree, times);
    gettimeofday(&end, NULL);
    elapsed = get_seconds(start, end);
    printf("bftree get %d elements seconds: %f\n", times, elapsed);

    gettimeofday(&start, NULL);
    redis_del(d, times);
    gettimeofday(&end, NULL);
    elapsed = get_seconds(start, end);
    printf("redis delete %d elements seconds: %f\n", times, elapsed);

    gettimeofday(&start, NULL);
    bftree_delele(tree, times);
    gettimeofday(&end, NULL);
    elapsed = get_seconds(start, end);
    printf("bftree delete %d elements seconds: %f\n", times, elapsed);

    bftree_free(tree);
    dictRelease(d);

    return 0;
}
Example #13
0
File: ae.c Project: naver/nbase-arc
void aeDeleteEventLoop(aeEventLoop *eventLoop) {
    aeApiFree(eventLoop);
#ifdef _WIN32
    dictRelease(eventLoop->fdiMap->map);
    listRelease(eventLoop->fdiMap->recycle_pool);
    zfree(eventLoop->fdiMap);
#endif
    zfree(eventLoop->events);
    zfree(eventLoop->fired);
    zfree(eventLoop);
}
Example #14
0
File: engine.c Project: fizx/sit
void
result_iterator_free(ResultIterator *iter) {
  dictRelease(iter->cursors);
  for(int i = 0; i < iter->count; i++) {
    free(iter->subs[i]->cursors);
    free(iter->subs[i]->negateds);
    free(iter->subs[i]->state);
    free(iter->subs[i]);
  }
  free(iter->subs);
  free(iter);
}
Example #15
0
void freeSetObject(robj *o) {
    switch (o->encoding) {
    case OBJ_ENCODING_HT:
        dictRelease((dict*) o->ptr);
        break;
    case OBJ_ENCODING_INTSET:
        zfree(o->ptr);
        break;
    default:
        serverPanic("Unknown set encoding type");
    }
}
Example #16
0
void execShutdownCommand(dict *db) {
    writeLog(1, "start to clear db...");
    dictRelease(db);
    writeLog(1, "db cleared...");

/*
*  TODO
*  Implement all connections free here.
*/
    sleep(5);
    writeLog(1, "start to shutdown...");
    exit(1);
}
Example #17
0
static void freeHashObject(robj *o) {
    switch (o->encoding) {
    case REDIS_ENCODING_HT:
        dictRelease((dict*) o->ptr);
        break;
    case REDIS_ENCODING_ZIPMAP:
        zfree(o->ptr);
        break;
    default:
        redisAssert(0);
        break;
    }
}
Example #18
0
void  destroyTaskMap(dict* p) 
{
    if (p) {
        dictIterator* di = dictGetIterator(p);
        dictEntry* de;
        while ((de = dictNext(di)) != NULL) {
            ugTaskType* ptask = dictGetEntryVal(de); 
            luaworkUnrefFunction(server.ls, ptask->handle, NULL);            
        }
        dictReleaseIterator(di);
        dictRelease(p);
    }
}
Example #19
0
static void init_DXDB_PersistentStorageItems(uint32 ntbl, uint32 nindx) {
    if (Tbl) free(Tbl);
    Num_tbls = 0;
    Tbl      = malloc(sizeof(r_tbl_t) * ntbl);
    bzero(Tbl,        sizeof(r_tbl_t) * ntbl);
    Tbl_HW   = ntbl;
    if (TblD) dictRelease(TblD);
    TblD     = dictCreate(&sdsDictType, NULL);
    if (DropT) { listRelease(DropT); DropT = NULL; }

    if (Index) free(Index);
    Num_indx = 0;
    Index    = malloc(sizeof(r_ind_t) * nindx);
    bzero(Index,      sizeof(r_ind_t) * nindx);
    Ind_HW   = nindx;
    if (IndD) dictRelease(IndD);
    IndD     = dictCreate(&sdsDictType, NULL);
    if (DropI) { listRelease(DropI); DropI = NULL; }

    if (StmtD) dictRelease(StmtD);
    StmtD    = dictCreate(&dbDictType,  NULL);
}
Example #20
0
void freeHashObject(robj *o) {
    switch (o->encoding) {
    case REDIS_ENCODING_HT:
        dictRelease((dict*) o->ptr);
        break;
    case REDIS_ENCODING_ZIPMAP:
        zfree(o->ptr);
        break;
    default:
        redisPanic("Unknown hash encoding type");
        break;
    }
}
Example #21
0
void freeHashObject(robj *o) {
    switch (o->encoding) {
    case OBJ_ENCODING_HT:
        dictRelease((dict*) o->ptr);
        break;
    case OBJ_ENCODING_ZIPLIST:
        zfree(o->ptr);
        break;
    default:
        serverPanic("Unknown hash encoding type");
        break;
    }
}
Example #22
0
static void _conn_destroy(void * ptr)
{
    http_connection_t * conn = (http_connection_t *) ptr;
    zfree(conn->timeout);

    if (conn->request->data) {
        conn->request->free_data(conn);
    }

    if (conn->request) {
        dictRelease(conn->request->headers);
        zfree(conn->request->url);
        zfree(conn->request->uri);
        dictRelease(conn->request->args);
        zfree(conn->request);
    }
    if (conn->response) {
        dictRelease(conn->response->headers);
        zfree(conn->response->ptr);
        zfree(conn->response);
    }
    zfree(conn);
}
Example #23
0
static int
conf_post_validate(rmt_conf *cf)
{
    if(cf == NULL){
        return RMT_ERROR;
    }

    if(cf->organizations != NULL){
        dictRelease(cf->organizations);
        cf->organizations = NULL;
    }
    
    return RMT_OK;
}
Example #24
0
File: engine.c Project: fizx/sit
void 
query_node_free(QueryNode *node) {
  if(node->children) {
    dictRelease(node->children);
  }
  Callback *cb = node->callback;
  while(cb) {
    Callback *tmp = cb;
    cb = cb->next;
    callback_free(tmp);
  }
	
  free(node); 
}
Example #25
0
/* Change job state as acknowledged. If it is already in that state, the
 * function does nothing. */
void acknowledgeJob(job *job) {
    if (job->state == JOB_STATE_ACKED) return;

    dequeueJob(job);
    job->state = JOB_STATE_ACKED;
    /* Remove the nodes_confirmed hash table if it exists.
     * tryJobGC() will take care to create a new one used for the GC
     * process. */
    if (job->nodes_confirmed) {
        dictRelease(job->nodes_confirmed);
        job->nodes_confirmed = NULL;
    }
    updateJobAwakeTime(job,0); /* Make sure we'll schedule a job GC. */
    AOFAckJob(job); /* Change job state in AOF. */
}
Example #26
0
void freeZsetObject(robj *o) {
    zset *zs;
    switch (o->encoding) {
    case OBJ_ENCODING_SKIPLIST:
        zs = o->ptr;
        dictRelease(zs->dict);
        zslFree(zs->zsl);
        zfree(zs);
        break;
    case OBJ_ENCODING_ZIPLIST:
        zfree(o->ptr);
        break;
    default:
        serverPanic("Unknown sorted set encoding");
    }
}
Example #27
0
int main(int argc, char *argv[]) 
{
    int ret;
    dict *d = dictCreate(&testDictType, NULL);
    assert(d);

    create(d, 123);
    create(d, 124);
    create(d, 125);
    create(d, 126);

    dictPrintStats(d);

    dictRelease(d);

    return 0;
}
Example #28
0
File: ae.c Project: naver/nbase-arc
aeEventLoop *aeCreateEventLoop(int setsize) {
    aeEventLoop *eventLoop;
    int i;

    if ((eventLoop = zmalloc(sizeof(*eventLoop))) == NULL) goto err;
    eventLoop->events = zmalloc(sizeof(aeFileEvent)*setsize);
    eventLoop->fired = zmalloc(sizeof(aeFiredEvent)*setsize);
    if (eventLoop->events == NULL || eventLoop->fired == NULL) goto err;
    eventLoop->setsize = setsize;
    eventLoop->lastTime = time(NULL);
    eventLoop->timeEventHead = NULL;
    eventLoop->timeEventNextId = 0;
    eventLoop->stop = 0;
    eventLoop->maxfd = EVENTLOOP_MAXFD_INITIAL_VALUE;
    eventLoop->beforesleep = NULL;
    if (aeApiCreate(eventLoop) == -1) goto err;
    /* Events with mask == AE_NONE are not set. So let's initialize the
     * vector with it. */
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;
#ifdef _WIN32
    if ((eventLoop->fdiMap = zmalloc(sizeof(fd_index_map_t))) == NULL) goto err;
    eventLoop->fdiMap->map = dictCreate(&fdiDictType, NULL);
    eventLoop->fdiMap->recycle_pool = listCreate();
    if (eventLoop->fdiMap->map == NULL || eventLoop->fdiMap->recycle_pool == NULL) goto err;
    eventLoop->fdiMap->next_available = 3;	// stdin(0), stdout(1) and stderr(2)
#endif
    return eventLoop;

err:
#ifdef _WIN32
    if (eventLoop->fdiMap) {
        if (eventLoop->fdiMap->map != NULL) dictRelease(eventLoop->fdiMap->map);
        if (eventLoop->fdiMap->recycle_pool != NULL) listRelease(eventLoop->fdiMap->recycle_pool);
        zfree(eventLoop->fdiMap);
    }
#endif
    if (eventLoop) {
        zfree(eventLoop->events);
        zfree(eventLoop->fired);
        zfree(eventLoop);
    }
    return NULL;
}
Example #29
0
static void
client_unref_internal_try_put(struct conn *conn)
{
    ASSERT(conn->waiting_to_unref);
    unsigned long msgs = dictSize(conn->outstanding_msgs_dict);
    if (msgs != 0) {
        log_warn("conn %p Waiting for %lu outstanding messages", conn, msgs);
        return;
    }
    struct server_pool *pool;
    ASSERT(conn->owner != NULL);
    pool = conn->owner;
    conn->owner = NULL;
    dictRelease(conn->outstanding_msgs_dict);
    conn->waiting_to_unref = 0;
    log_warn("unref conn %p owner %p from pool '%.*s'", conn,
             pool, pool->name.len, pool->name.data);
    conn_put(conn);
}
Example #30
0
static void conf_deinit(rmt_conf *cf)
{
    if(cf == NULL){
        return;
    }

    if (cf->fname != NULL) {
        sdsfree(cf->fname);
        cf->fname = NULL;
    }

    if(cf->fh != NULL){
        fclose(cf->fh);
        cf->fh = NULL;
    }

    if(cf->organizations != NULL){
        dictRelease(cf->organizations);
        cf->organizations = NULL;
    }

    conf_pool_deinit(&cf->source_pool);
    conf_pool_deinit(&cf->target_pool);

    if(cf->listen != NULL){
        sdsfree(cf->listen);
        cf->listen = CONF_UNSET_PTR;
    }

    if(cf->dir != NULL){
        sdsfree(cf->dir);
        cf->dir = CONF_UNSET_PTR;
    }
    
    cf->maxmemory = CONF_UNSET_NUM;
    cf->threads = CONF_UNSET_NUM;
    cf->step = CONF_UNSET_NUM;
    cf->mbuf_size = CONF_UNSET_NUM;
    cf->noreply = CONF_UNSET_NUM;
    cf->rdb_diskless = CONF_UNSET_NUM;
    cf->source_safe = CONF_UNSET_NUM;
}