Method asyncDelete

src/lazyfree.cpp:144–197

 * will be reclaimed in a different bio.c thread. */
#define LAZYFREE_THRESHOLD 64
bool redisDbPersistentData::asyncDelete(robj *key) {
    /* If the value is composed of a few allocations, to free in a lazy way
     * is actually just slower... So under a certain limit we just free
     * the object synchronously. */

    if (m_spstorage != nullptr)
        return syncDelete(key); // async delte never makes sense with a storage provider

    dictEntry *de = dictUnlink(m_pdict,ptrFromObj(key));
    if (de) {
        if (m_pdbSnapshot != nullptr && m_pdbSnapshot->find_cached_threadsafe(szFromObj(key)) != nullptr)
        {
            uint64_t hash = dictGetHash(m_pdict, szFromObj(key));
            dictAdd(m_pdictTombstone, sdsdup((sds)dictGetKey(de)), (void*)hash);
        }

        robj *val = (robj*)dictGetVal(de);
        if (val->FExpires())
        {
            /* Deleting an entry from the expires dict will not free the sds of
             * the key, because it is shared with the main dictionary. */
            removeExpire(key,dict_iter(m_pdict, de));
        }

        /* Tells the module that the key has been unlinked from the database. */
        moduleNotifyKeyUnlink(key,val);

        size_t free_effort = lazyfreeGetFreeEffort(key,val);

        /* If releasing the object is too much work, do it in the background
         * by adding the object to the lazy free list.
         * Note that if the object is shared, to reclaim it now it is not
         * possible. This rarely happens, however sometimes the implementation
         * of parts of the Redis core may call incrRefCount() to protect
         * objects, and then call dbDelete(). In this case we'll fall
         * through and reach the dictFreeUnlinkedEntry() call, that will be
         * equivalent to just calling decrRefCount(). */
        if (free_effort > LAZYFREE_THRESHOLD && val->getrefcount(std::memory_order_relaxed) == 1) {
            atomicIncr(lazyfree_objects,1);
            bioCreateLazyFreeJob(lazyfreeFreeObject,1, val);
            dictSetVal(m_pdict,de,NULL);
        }
    }

    /* Release the key-val pair, or just the key if we set the val
     * field to NULL in order to lazy free it later. */
    if (de) {
        dictFreeUnlinkedEntry(m_pdict,de);
        if (g_pserver->cluster_enabled) slotToKeyDel(szFromObj(key));
        return true;
    } else {
        return false;
    }
}

int dbAsyncDelete(redisDb *db, robj *key) {
    return db->asyncDelete(key);