lbug 0.22.0

An in-process property graph database management system built for query speed and scalability
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#pragma once

#include <memory>
#include <vector>

#include "storage/page_range.h"

namespace lbug::storage {
class PageAllocator;
struct SegmentState;

// Pages a CSR scan already started reading. A checkpoint that rewrites those
// pages queues the free here instead of releasing them, and skips in-place
// updates that would overwrite the same pages. The free runs when the last
// scan drops the pin.
class PageReclaimDeferral {
public:
    static std::shared_ptr<PageReclaimDeferral> create();

    void defer(PageRange range, PageAllocator& pageAllocator);
    void defer(const SegmentState& state, PageAllocator& pageAllocator);
    // Drop queued frees without releasing the pages. Used when a checkpoint
    // throws and the old pages are still the live ones.
    void discard();
    // The checkpoint that queued these frees succeeded. `next` is the deferral of the group
    // it wrote, which can still share pages with the one the scans pinned (unchanged columns
    // are not rewritten). Holding it keeps later checkpoints deferring those pages for as
    // long as a scan holds this one.
    void commit(std::shared_ptr<PageReclaimDeferral> next) {
        committed = true;
        successor = std::move(next);
    }

    ~PageReclaimDeferral();

    static PageReclaimDeferral*& current();

private:
    struct Free {
        PageRange range;
        PageAllocator* pageAllocator;
    };

    std::vector<Free> frees;
    bool committed = false;
    std::shared_ptr<PageReclaimDeferral> successor;
};

class PageReclaimDeferralScope {
public:
    explicit PageReclaimDeferralScope(PageReclaimDeferral* deferral)
        : previous{PageReclaimDeferral::current()} {
        PageReclaimDeferral::current() = deferral;
    }
    ~PageReclaimDeferralScope() { PageReclaimDeferral::current() = previous; }

    PageReclaimDeferralScope(const PageReclaimDeferralScope&) = delete;
    PageReclaimDeferralScope& operator=(const PageReclaimDeferralScope&) = delete;

private:
    PageReclaimDeferral* previous;
};

} // namespace lbug::storage