Checkpoint.hpp

// <Checkpoint> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <sstream>
 
#include "sparta/functional/ArchData.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/kernel/Scheduler.hpp"
 
#include "sparta/serialization/checkpoint/CheckpointExceptions.hpp"
 
 
namespace sparta::serialization::checkpoint
{
    class FastCheckpointer;
 
    class Checkpoint
    {
    public:
 
 
        typedef sparta::Scheduler::Tick tick_t;
 
        typedef uint64_t chkpt_id_t;
 
 
        static const chkpt_id_t MIN_CHECKPOINT = 0;
 
        static const chkpt_id_t UNIDENTIFIED_CHECKPOINT = ~(chkpt_id_t)0;
 
 
 
        Checkpoint() = delete;
 
        Checkpoint(const Checkpoint&) = delete;
 
        const Checkpoint& operator=(const Checkpoint&) = delete;
 
    protected:
 
        Checkpoint(chkpt_id_t id,
                   tick_t tick,
                   Checkpoint* prev) :
            tick_(tick),
            chkpt_id_(id),
            prev_(prev)
        { }
 
    public:
 
 
        virtual ~Checkpoint() {
            if(getPrev()){
                getPrev()->removeNext(this);
            }
 
            // Reconnect deltas from this checkpoint to the prev (even if nullptr)
            for(auto& d : getNexts()){
                d->setPrev(getPrev());
                if(getPrev()){
                    getPrev()->addNext(d);
                }
            }
 
        }
 
 
        virtual std::string stringize() const {
            std::stringstream ss;
            ss << "<Checkpoint id=" << chkpt_id_ << " at t=" << tick_;
            ss << ' ' << getTotalMemoryUse()/1000.0f << "kB (" << getContentMemoryUse()/1000.0f << "kB Data)";
            ss << '>';
            return ss.str();
        }
 
        virtual void dumpData(std::ostream& o) const = 0;
 
        virtual uint64_t getTotalMemoryUse() const noexcept = 0;
 
        virtual uint64_t getContentMemoryUse() const noexcept = 0;
 
 
        virtual void load(const std::vector<ArchData*>& dats) = 0;
 
        tick_t getTick() const noexcept { return tick_; }
 
        chkpt_id_t getID() const noexcept { return chkpt_id_; }
 
        virtual std::string getDeletedRepr() const {
            return "*";
        }
 
        Checkpoint* getPrev() const noexcept {
            return prev_;
        }
 
        void setPrev(Checkpoint* prev) noexcept {
            prev_ = prev;
        }
 
        void addNext(Checkpoint* next) {
            if(!next){
                throw CheckpointError("Cannot specify nullptr in addNext");
            }
            if(next->getPrev() != this){
                throw CheckpointError("Attempting to add a next checkpoint whose previous checkpoint pointer is not 'this'");
            }
            if(next->getTick() < getTick()){
                throw CheckpointError("Attempting to add a next checkpoint whose tick number (")
                    << next->getTick() << " is less than this checkpoint's tick: " << getTick();
            }
            if(std::find(nexts_.begin(), nexts_.end(), next) != nexts_.end()){
                throw CheckpointError("Next argument already present in this checkpoint's nexts_ list. Cannot re-add");
            }
            nexts_.push_back(next);
        }
 
        void removeNext(Checkpoint* next) {
            if(!next){
                throw CheckpointError("Cannot specify nullptr in removeNext");
            }
            if(next->getPrev() != this){
                throw CheckpointError("Attempting to remove a next checkpoint whose previous pointer is not 'this'");
            }
            auto itr = std::find(nexts_.begin(), nexts_.end(), next);
            if(itr == nexts_.end()){
                throw CheckpointError("Next argument was not present in this checkpoint's nexts_ list. Cannot remove");
            }
            nexts_.erase(itr);
        }
 
        const std::vector<Checkpoint*>& getNexts() const noexcept { return nexts_; }
 
 
    protected:
 
        void setID_(chkpt_id_t id) {
            chkpt_id_ = id;
        }
 
    private:
 
        const tick_t tick_; 
        chkpt_id_t chkpt_id_; 
 
        std::vector<Checkpoint*> nexts_;
 
        Checkpoint* prev_; 
    };
 
} // namespace sparta::serialization::checkpoint
 
 
inline std::ostream& operator<<(std::ostream& o, const sparta::serialization::checkpoint::Checkpoint& dcp){
    o << dcp.stringize();
    return o;
}
 
inline std::ostream& operator<<(std::ostream& o, const sparta::serialization::checkpoint::Checkpoint* dcp){
    if(dcp == 0){
        o << "null";
    }else{
        o << dcp->stringize();
    }
    return o;
}
 
#define SPARTA_CHECKPOINT_BODY                                            \
    namespace sparta{ namespace serialization { namespace checkpoint {    \
        const Checkpoint::chkpt_id_t Checkpoint::MIN_CHECKPOINT;        \
        const Checkpoint::chkpt_id_t Checkpoint::UNIDENTIFIED_CHECKPOINT; \
    }}}