Method bulkInsert

src/StorageCache.cpp:132–178

long _dictKeyIndex(dict *d, const void *key, uint64_t hash, dictEntry **existing);
void StorageCache::bulkInsert(char **rgkeys, size_t *rgcbkeys, char **rgvals, size_t *rgcbvals, size_t celem)
{
    std::vector<dictEntry*> vechashes;
    if (m_pdict != nullptr) {
        vechashes.reserve(celem);
    }

    for (size_t ielem = 0; ielem < celem; ++ielem) {
        if (m_pdict != nullptr) {
            dictEntry *de = (dictEntry*)zmalloc(sizeof(dictEntry));
            de->key = (void*)dictGenHashFunction(rgkeys[ielem], (int)rgcbkeys[ielem]);
            de->v.u64 = 1;
            vechashes.push_back(de);
        }
        auto e = deserializeExpire(rgvals[ielem], rgcbvals[ielem], nullptr);
        if (e != nullptr)
            m_spstorage->setExpire(rgkeys[ielem], rgcbkeys[ielem], e->when());
    }

    std::unique_lock<fastlock> ul(m_lock);
    bulkInsertsInProgress++;
    if (m_pdict != nullptr) {
        for (dictEntry *de : vechashes) {
            if (dictIsRehashing(m_pdict)) dictRehash(m_pdict,1);
            /* Get the index of the new element, or -1 if
                * the element already exists. */
            long index;
            if ((index = _dictKeyIndex(m_pdict, de->key, (uint64_t)de->key, nullptr)) == -1) {
                dictEntry *deLocal = dictFind(m_pdict, de->key);
                serverAssert(deLocal != nullptr);
                deLocal->v.s64++;
                m_collisionCount++;
                zfree(de);
            } else {
                int iht = dictIsRehashing(m_pdict) ? 1 : 0;
                de->next = m_pdict->ht[iht].table[index];
                m_pdict->ht[iht].table[index] = de;
                m_pdict->ht[iht].used++;
            }
        }
    }
    ul.unlock();

    m_spstorage->bulkInsert(rgkeys, rgcbkeys, rgvals, rgcbvals, celem);

    bulkInsertsInProgress--;
}

const StorageCache *StorageCache::clone()
{