Method endSnapshotAsync

src/snapshot.cpp:179–246

This function is all about minimizing the amount of work done under global lock when there has been lots of changes since snapshot creation a naive endSnapshot() will block for a very long time and will cause latency spikes. Note that this function uses a lot more CPU time than a simple endSnapshot(), we have some internal heuristics to do a synchronous endSnapshot if it makes sense

// Note that this function uses a lot more CPU time than a simple endSnapshot(), we
//  have some internal heuristics to do a synchronous endSnapshot if it makes sense
void redisDbPersistentData::endSnapshotAsync(const redisDbPersistentDataSnapshot *psnapshot)
{
    mstime_t latency;

    aeAcquireLock();
    while (dictIsRehashing(m_pdict) || dictIsRehashing(m_pdictTombstone)) {
        dictRehashMilliseconds(m_pdict, 1);
        dictRehashMilliseconds(m_pdictTombstone, 1);
        // Give someone else a chance
        aeReleaseLock();
        usleep(300);
        aeAcquireLock();
    }
    
    latencyStartMonitor(latency);
        if (m_pdbSnapshotASYNC && m_pdbSnapshotASYNC->m_mvccCheckpoint <= psnapshot->m_mvccCheckpoint)
        {
            // Free a stale async snapshot so consolidate_children can clean it up later
            endSnapshot(m_pdbSnapshotASYNC);    // FAST: just a ref decrement
            m_pdbSnapshotASYNC = nullptr;
        }

        size_t elements = dictSize(m_pdictTombstone);
        // if neither dict is rehashing then the merge is O(1) so don't count the size
        if (dictIsRehashing(psnapshot->m_pdict) || dictIsRehashing(m_pdict))
            elements += dictSize(m_pdict);
        if (elements < c_elementsSmallLimit || psnapshot != m_spdbSnapshotHOLDER.get())  // heuristic
        {
            // For small snapshots it makes more sense just to merge it directly
            endSnapshot(psnapshot);
            latencyEndMonitor(latency);
            latencyAddSampleIfNeeded("end-snapshot-async-synchronous-path", latency);
            aeReleaseLock();
            return;
        }

        // OK this is a big snapshot so lets do the merge work outside the lock
        auto psnapshotT = createSnapshot(LLONG_MAX, false);
        endSnapshot(psnapshot); // this will just dec the ref count since our new snapshot has a ref 
        psnapshot = nullptr;

    latencyEndMonitor(latency);
    latencyAddSampleIfNeeded("end-snapshot-async-phase-1", latency);
    aeReleaseLock();

    // do the expensive work of merging snapshots outside the ref
    if (const_cast<redisDbPersistentDataSnapshot*>(psnapshotT)->freeTombstoneObjects(1))    // depth is one because we just creted it
    {
        aeAcquireLock();
        if (m_pdbSnapshotASYNC != nullptr)
            endSnapshot(m_pdbSnapshotASYNC);
        m_pdbSnapshotASYNC = nullptr;
        endSnapshot(psnapshotT);
        aeReleaseLock();
        return;
    }
    
    // Final Cleanup