Function dictRehashAsyncStart

src/dict.cpp:410–447

}

dictAsyncRehashCtl *dictRehashAsyncStart(dict *d, int buckets) {
    assert(d->type->asyncfree != nullptr);
    if (!dictIsRehashing(d) || d->pauserehash != 0) return nullptr;

    d->asyncdata = new dictAsyncRehashCtl(d, d->asyncdata);

    int empty_visits = buckets*10;

    while (d->asyncdata->queue.size() < (size_t)buckets && (size_t)d->rehashidx < d->ht[0].size) {
        dictEntry *de;

        /* Note that rehashidx can't overflow as we are sure there are more
         * elements because ht[0].used != 0 */
        while(d->ht[0].table[d->rehashidx] == NULL) {
            d->rehashidx++;
            if (--empty_visits == 0) goto LDone;
            if ((size_t)d->rehashidx >= d->ht[0].size) goto LDone;
        }

        de = d->ht[0].table[d->rehashidx];
        // We have to queue every node in the bucket, even if we go over our target size
        while (de != nullptr) {
            d->asyncdata->queue.emplace_back(de);
            de = de->next;
        }
        d->rehashidx++;
    }

LDone:
    if (d->asyncdata->queue.empty()) {
        // We didn't find any work to do (can happen if there is a large gap in the hash table)
        auto asyncT = d->asyncdata;
        d->asyncdata = d->asyncdata->next;
        delete asyncT;
        return nullptr;
    }
    return d->asyncdata;
}

void dictRehashAsync(dictAsyncRehashCtl *ctl) {
    if (ctl->abondon.load(std::memory_order_acquire)) {