dur_commitjob.h

Go to the documentation of this file.

#pragma once


#include "mongo/db/storage/mmap_v1/durop.h"
#include "mongo/util/concurrency/mutex.h"

namespace mongo {
namespace dur {

typedef std::vector<std::shared_ptr<DurOp>> DurOpsVector;

struct WriteIntent {
    WriteIntent() : p(0) {}
    WriteIntent(void* a, unsigned b) : p((char*)a + b), len(b) {}

    void* start() const {
        return (char*)p - len;
    }
    void* end() const {
        return p;
    }
    unsigned length() const {
        return len;
    }
    bool operator<(const WriteIntent& rhs) const {
        return end() < rhs.end();
    }

    bool overlaps(const WriteIntent& rhs) const {
        return (start() <= rhs.end() && end() >= rhs.start());
    }

    bool contains(const WriteIntent& rhs) const {
        return (start() <= rhs.start() && end() >= rhs.end());
    }

    // merge into me:
    void absorb(const WriteIntent& other);

    friend std::ostream& operator<<(std::ostream& out, const WriteIntent& wi) {
        return (out << "p: " << wi.p << " end: " << wi.end() << " len: " << wi.len);
    }

private:
    void* p;       // intent to write up to p
    unsigned len;  // up to this len
};

typedef std::vector<WriteIntent> WriteIntentsVector;


template <int Prime>
class Already {
    MONGO_DISALLOW_COPYING(Already);

public:
    Already() {
        clear();
    }

    void clear() {
        memset(this, 0, sizeof(*this));
    }

    bool checkAndSet(void* p, int len) {
        const unsigned x = hashPointer(p);
        std::pair<void*, int>& nd = nodes[x % Prime];

        if (nd.first == p) {
            if (nd.second < len) {
                nd.second = len;
                return false;  // haven't indicated this len yet
            }
            return true;  // already indicated
        }

        nd.first = p;
        nd.second = len;
        return false;  // a new set
    }

private:
    static unsigned hashPointer(void* v) {
        unsigned x = 0;
        unsigned char* p = (unsigned char*)&v;
        for (unsigned i = 0; i < sizeof(void*); i++) {
            x = x * 131 + p[i];
        }
        return x;
    }

    std::pair<void*, int> nodes[Prime];
};


class CommitJob {
    MONGO_DISALLOW_COPYING(CommitJob);

public:
    CommitJob();
    ~CommitJob();

    void noteOp(std::shared_ptr<DurOp> p);

    void note(void* p, int len);

    bool hasWritten() const {
        return _hasWritten;
    }

    void committingReset();

    size_t bytes() const {
        return _bytes;
    }

    const WriteIntentsVector& getIntentsSorted() {
        sort(_intents.begin(), _intents.end());
        return _intents;
    }

    const DurOpsVector& ops() const {
        return _durOps;
    }

    SimpleMutex groupCommitMutex;

private:
    void _insertWriteIntent(void* p, int len) {
        _intents.push_back(WriteIntent(p, len));
    }


    // Whether we put write intents or durops
    bool _hasWritten;

    // Write intents along with a bitmask for whether we have already noted them
    Already<127> _alreadyNoted;
    WriteIntentsVector _intents;

    // All the ops other than basic writes
    DurOpsVector _durOps;

    // Used to count the private map used bytes. Note that _lastNotedPos doesn't reset with
    // each commit, but that is ok we aren't being that precise.
    size_t _lastNotedPos;
    size_t _bytes;

    // Warning logging for large commits
    uint64_t _lastComplainMs;
    unsigned _complains;
};

}  // namespace "dur"
}  // namespace "mongo"