dur_recovery_unit.h

Go to the documentation of this file.

#include <set>
#include <string>
#include <utility>
#include <vector>

#include "mongo/base/owned_pointer_vector.h"
#include "mongo/db/storage/recovery_unit.h"
#include "mongo/platform/compiler.h"

#pragma once

namespace mongo {

class DurRecoveryUnit : public RecoveryUnit {
public:
    DurRecoveryUnit();

    void beginUnitOfWork(OperationContext* opCtx) final;
    void commitUnitOfWork() final;
    void abortUnitOfWork() final;

    virtual bool waitUntilDurable();

    virtual void abandonSnapshot();

    //  The recovery unit takes ownership of change.
    virtual void registerChange(Change* change);

    virtual void* writingPtr(void* addr, size_t len);

    virtual void setRollbackWritesDisabled();

    virtual SnapshotId getSnapshotId() const {
        return SnapshotId();
    }

    virtual void setOrderedCommit(bool orderedCommit) {}

private:
    void commitChanges();

    void markWritesForJournaling();

    void rollbackChanges();


    void mergingWritingPtr(char* data, size_t len);

    void resetChanges();

    // Changes are ordered from oldest to newest.
    typedef OwnedPointerVector<Change> Changes;
    Changes _changes;


    // Number of pending uncommitted writes. Incremented even if new write is fully covered by
    // existing writes.
    size_t _writeCount;
    // Total size of the pending uncommitted writes.
    size_t _writeBytes;

    struct Write {
        Write(char* addr, int len, int offset) : addr(addr), len(len), offset(offset) {}
        Write(const Write& rhs) : addr(rhs.addr), len(rhs.len), offset(rhs.offset) {}
        Write() : addr(0), len(0), offset(0) {}
        bool operator<(const Write& rhs) const {
            return addr < rhs.addr;
        }

        struct compareEnd {
            bool operator()(const Write& lhs, const Write& rhs) const {
                return lhs.addr + lhs.len < rhs.addr + rhs.len;
            }
        };

        char* end() const {
            return addr + len;
        }

        char* addr;
        int len;
        int offset;  // index into _preimageBuffer
    };

    typedef std::set<Write, Write::compareEnd> MergedWrites;
    MergedWrites _mergedWrites;

    // Generally it's more efficient to just store pre-images unconditionally and then
    // sort/eliminate duplicates at commit time. However, this can lead to excessive memory
    // use in cases involving large indexes arrays, where the same memory is written many
    // times. To keep the speed for the general case and bound memory use, the first few MB of
    // pre-images are stored unconditionally, but once the threshold has been exceeded, the
    // remainder is stored in a more space-efficient datastructure.
    typedef std::vector<Write> InitialWrites;
    InitialWrites _initialWrites;

    std::string _preimageBuffer;

    bool _inUnitOfWork;


    // Default is false.
    // If true, no preimages are tracked.  If rollback is subsequently attempted, the process
    // will abort.
    bool _rollbackWritesDisabled;
};

}  // namespace mongo