Method prefetchKeysAsync

src/db.cpp:3282–3399

}

void redisDbPersistentData::prefetchKeysAsync(client *c, parsed_command &command)
{
    if (m_spstorage == nullptr) {
#if defined(__x86_64__) || defined(__i386__)
        // We do a quick 'n dirty check for set & get.  Anything else is too slow.
        //  Should the user do something weird like remap them then the worst that will
        //  happen is we don't prefetch or we prefetch wrong data.  A mild perf hit, but
        //  not dangerous
        if (command.argc >= 2) {
            const char *cmd = szFromObj(command.argv[0]);
            if (!strcasecmp(cmd, "set") || !strcasecmp(cmd, "get")) {
                if (c->db->m_spdbSnapshotHOLDER != nullptr)
                    return; // this is dangerous enough without a snapshot around
                auto h = dictSdsHash(szFromObj(command.argv[1]));
                for (int iht = 0; iht < 2; ++iht) {
                    auto hT = h & c->db->m_pdict->ht[iht].sizemask;
                    dictEntry **table;
                    __atomic_load(&c->db->m_pdict->ht[iht].table, &table, __ATOMIC_RELAXED);
                    if (table != nullptr) {
                        dictEntry *de;
                        __atomic_load(&table[hT], &de, __ATOMIC_ACQUIRE);
                        while (de != nullptr) {
                            _mm_prefetch(dictGetKey(de), _MM_HINT_T2);
                            __atomic_load(&de->next, &de, __ATOMIC_ACQUIRE);
                        }
                    }
                    if (!dictIsRehashing(c->db->m_pdict))
                        break;
                }
            }
        }
#endif
        return;
    }

    AeLocker lock;

    std::vector<robj*> veckeys;
    lock.arm(c);
    getKeysResult result = GETKEYS_RESULT_INIT;
    auto cmd = lookupCommand(szFromObj(command.argv[0]));
    if (cmd == nullptr)
        return; // Bad command? It's not for us to judge, just bail
    
    if (command.argc < std::abs(cmd->arity))
        return; // Invalid number of args
    
    int numkeys = getKeysFromCommand(cmd, command.argv, command.argc, &result);
    for (int ikey = 0; ikey < numkeys; ++ikey)
    {
        robj *objKey = command.argv[result.keys[ikey]];
        if (this->find_cached_threadsafe(szFromObj(objKey)) == nullptr)
            veckeys.push_back(objKey);
    }
    lock.disarm();

    getKeysFreeResult(&result);