DatabaseCheckpoint.hpp

// <DatabaseCheckpoint> -*- C++ -*-
 
#pragma once
 
#include "sparta/serialization/checkpoint/CheckpointBase.hpp"
#include "sparta/serialization/checkpoint/CheckpointExceptions.hpp"
#include "sparta/serialization/checkpoint/VectorStorage.hpp"
 
namespace sparta::serialization::checkpoint
{
    class DatabaseCheckpointer;
    class DatabaseCheckpoint;
 
    struct ChkptWindow {
        using chkpt_id_t = CheckpointBase::chkpt_id_t;
        std::vector<std::shared_ptr<DatabaseCheckpoint>> chkpts;
        chkpt_id_t start_chkpt_id = CheckpointBase::UNIDENTIFIED_CHECKPOINT;
        chkpt_id_t end_chkpt_id = CheckpointBase::UNIDENTIFIED_CHECKPOINT;
        uint64_t start_tick = 0;
        uint64_t end_tick = 0;
        bool ignore = false;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned int /*version*/);
    };
 
    struct ChkptWindowBytes {
        using chkpt_id_t = CheckpointBase::chkpt_id_t;
        std::vector<char> chkpt_bytes;
        chkpt_id_t start_chkpt_id = CheckpointBase::UNIDENTIFIED_CHECKPOINT;
        chkpt_id_t end_chkpt_id = CheckpointBase::UNIDENTIFIED_CHECKPOINT;
        uint64_t start_tick = 0;
        uint64_t end_tick = 0;
        bool ignore = false;
    };
 
    class DatabaseCheckpoint final : public CheckpointBase
    {
    public:
 
 
        DatabaseCheckpoint(const DatabaseCheckpoint&) = delete;
 
        DatabaseCheckpoint& operator=(const DatabaseCheckpoint&) = delete;
 
        DatabaseCheckpoint(DatabaseCheckpoint&&) = delete;
 
        DatabaseCheckpoint& operator=(DatabaseCheckpoint&&) = delete;
 
    private:
 
        DatabaseCheckpoint(const std::vector<ArchData*>& dats,          
                           chkpt_id_t id,
                           tick_t tick,
                           DatabaseCheckpoint* prev,
                           bool is_snapshot,
                           DatabaseCheckpointer* checkpointer);
 
        DatabaseCheckpoint() = default;
 
 
        friend struct ChkptWindow;
        friend class DatabaseCheckpointer;
 
    public:
 
        /*
         * \brief Support boost::serialization
         */
        template <typename Archive>
        void serialize(Archive& ar, const unsigned int version) {
            CheckpointBase::serialize(ar, version);
            ar & prev_id_;
            ar & next_ids_;
            ar & is_snapshot_;
            ar & data_;
        }
 
        std::string stringize() const override;
 
        void dumpData(std::ostream& o) const override;
 
        uint64_t getTotalMemoryUse() const noexcept override;
 
        uint64_t getContentMemoryUse() const noexcept override;
 
        std::stack<chkpt_id_t> getHistoryChain() const;
 
        std::stack<chkpt_id_t> getRestoreChain() const;
 
        chkpt_id_t getPrevID() const override;
 
        std::vector<chkpt_id_t> getNextIDs() const override;
 
        void load(const std::vector<ArchData*>& dats) override;
 
        bool isSnapshot() const noexcept;
 
        uint32_t getDistanceToPrevSnapshot() const noexcept;
 
        void loadState(const std::vector<ArchData*>& dats);
 
    private:
 
        void storeSnapshot_(const std::vector<ArchData*>& dats);
 
        void storeDelta_(const std::vector<ArchData*>& dats);
 
        chkpt_id_t prev_id_;
 
        std::vector<chkpt_id_t> next_ids_;
 
        bool is_snapshot_;
 
        storage::VectorStorage data_;
 
        DatabaseCheckpointer* checkpointer_ = nullptr;
    };
 
    template <typename Archive>
    inline void ChkptWindow::serialize(Archive& ar, const unsigned int /*version*/) {
        ar & start_chkpt_id;
        ar & end_chkpt_id;
        ar & start_tick;
        ar & end_tick;
 
        if (chkpts.empty()) {
            // We are loading a checkpoint window from disk
            const auto num_chkpts = end_chkpt_id - start_chkpt_id + 1;
            for (size_t i = 0; i < num_chkpts; ++i) {
                chkpts.emplace_back(new DatabaseCheckpoint);
                ar & *chkpts.back();
            }
        } else {
            // We are saving a checkpoint window to disk
            for (auto& chkpt : chkpts) {
                ar & *chkpt;
            }
        }
    }
 
} // namespace sparta::serialization::checkpoint