The life cycle of key value in redis module programming

RedisModule_OpenKey

This section discusses RedisModule_OpenKey in key-value When to release .

First The data structure is as follows

struct RedisModuleKey {
    ....
    robj *key;
    robj *value;
    ....
}

What we care about is RedisModuleKey And among Of key and value The life cycle of the value

RedisModuleKey In itself adopt RedisModule_OpenKey apply , Module memory management will automatically RedisModuleKey Save in ctx in . After the instruction execution is completed , call moduleFreeContext->autoMemoryCollect->RM_CloseKey->moduleCloseKey Try to release .

You can see A complete command ,RedisModuleKey Itself will be ruthlessly released .

void RM_CloseKey(RedisModuleKey *key) {
    
    if (key == NULL) return;

    moduleCloseKey(key);
    autoMemoryFreed(key->ctx,REDISMODULE_AM_KEY,key);
    zfree(key);// Completely release 
}

therefore ,RedisModule_OpenKey The essence of can be understood as just a Temporary variable ,

Now let's look at RedisModuleKey Among them key value , As you can see below ,key The reference count of minus 1.

/* Destroy a RedisModuleKey struct (freeing is the responsibility of the caller). */
static void moduleCloseKey(RedisModuleKey *key) {
    
    int signal = SHOULD_SIGNAL_MODIFIED_KEYS(key->ctx);
    if ((key->mode & REDISMODULE_WRITE) && signal)
        signalModifiedKey(key->ctx->client,key->db,key->key);
    /* TODO: if (key->iter) RM_KeyIteratorStop(kp); */
    RM_ZsetRangeStop(key);

    decrRefCount(key->key);
}

therefore key Will be ruthlessly released ？ not always , If RedisModuleKey Participating key The reference count is 1 And the mode is write Pattern , So in RM_OpenKey->moduleInitKey in , The reference count will be ++. That is to say RedisModule_OpenKey After the return ,key Add... To the original reference count 1, So in moduleCloseKey in ,key Will not be released .

If If you use this ：RedisModule_OpenKey(ctx, argv[1]..., That is, I like to take the user's input as open Parameters of , although RedisModule_OpenKey After the return argv[1] The reference count for is 2, however arg The parameter itself will be in redis The outermost layer of the frame is released once , therefore argv[1] Will not be kept in memory .
however If you use this ：RedisModule_OpenKey(ctx, RedisModule_CreateString(NULL, s, (size_t)slen)...), that No one will release RedisModule_CreateString Created memory , At this point either RedisModule_CreateString The first input parameter is passed into ctx Then rely on redis Automatic memory management to automatically free memory , Or take the initiative to call free To reduce the reference count .

Look again. value value ,module adopt RedisModule_ModuleTypeSetValue To set up value value , Its essence is genericSetKey, take RedisModuleKey Medium key-value Save to redis Of db in ,

int RM_ModuleTypeSetValue(RedisModuleKey *key, moduleType *mt, void *value) {
    
    if (!(key->mode & REDISMODULE_WRITE) || key->iter) return REDISMODULE_ERR;

    /* old value If there is , For example, you have executed this function before , old value The reference count is decremented 1*/
    RM_DeleteKey(key);
    robj *o = createModuleObject(mt,value);

    genericSetKey(key->ctx->client,key->db,key->key,o,0,0);
    /* Here we are  o The app count for is 2*/
    decrRefCount(o);
    /* Here we are  o The app count for is 1*/
    key->value = o;
    return REDISMODULE_OK;
}

therefore ,value Reference count of value , stay adopt RedisModule_ModuleTypeSetValue There is no increase or decrease after . That is to say value The life cycle of the value does not change .

RedisModule_DeleteKey In fact, that is dbDelete Encapsulation ,RedisModule_ModuleTypeSetValue take key-value Save in db in , Then they didn't increase or decrease their reference count ,RedisModule_DeleteKey Because of the call dbDelete So it's going to go straight to theta key as well as value The reference count of minus 1.

Sum up ：
1、RedisModule_OpenKey Back to RedisModuleKey The pointer , Will be released anyway . among ,RedisModule_OpenKey It will be involved in key, Reference count plus one . Then release RedisModuleKey when , reduce 1, If you need this elsewhere If Enter the reference key The original reference count was 1, Then additional operations are required to release it .
2、 If it does RedisModule_ModuleTypeSetValue, that ,RedisModuleKey The total key and value Be existed db, among ,key It's a copy , All of us don't care .value By db Direct reference （ The pointer points directly to value）.RedisModule_ModuleTypeSetValue Not by itself key and value Add or delete reference count .
3、 adopt DEL command , Delete RedisModule_OpenKey Specified in the key when , Same as standard process , Yes value Quote count minus 1,RedisModule_DeleteKey The same logic .