CheckpointBase.hpp

// <CheckpointBase> -*- 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 CheckpointBase
    {
    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;
 
 
 
        CheckpointBase(const CheckpointBase&) = delete;
 
        CheckpointBase& operator=(const CheckpointBase&) = delete;
 
        CheckpointBase(CheckpointBase&&) = delete;
 
        CheckpointBase& operator=(CheckpointBase&&) = delete;
 
    protected:
 
        CheckpointBase(chkpt_id_t id, tick_t tick) :
            tick_(tick),
            chkpt_id_(id)
        { }
 
        CheckpointBase() = default;
 
    public:
 
        virtual ~CheckpointBase() = default;
 
        template <typename Archive>
        void serialize(Archive& ar, const unsigned int /*version*/) {
            ar & tick_;
            ar & chkpt_id_;
        }
 
        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 chkpt_id_t getPrevID() const = 0;
 
        virtual std::vector<chkpt_id_t> getNextIDs() const = 0;
 
        virtual std::string getDeletedRepr() const {
            return "*";
        }
 
 
    protected:
        void setID_(chkpt_id_t id) {
            chkpt_id_ = id;
        }
 
    private:
        tick_t tick_;         
        chkpt_id_t chkpt_id_; 
    };
 
} // namespace sparta::serialization::checkpoint
 
inline std::ostream& operator<<(std::ostream& o, const sparta::serialization::checkpoint::CheckpointBase& dcp){
    o << dcp.stringize();
    return o;
}
 
inline std::ostream& operator<<(std::ostream& o, const sparta::serialization::checkpoint::CheckpointBase* dcp){
    if(dcp == 0){
        o << "null";
    }else{
        o << dcp->stringize();
    }
    return o;
}
 
#define SPARTA_CHECKPOINT_BODY                                                    \
    namespace sparta{ namespace serialization { namespace checkpoint {            \
        const CheckpointBase::chkpt_id_t CheckpointBase::MIN_CHECKPOINT;          \
        const CheckpointBase::chkpt_id_t CheckpointBase::UNIDENTIFIED_CHECKPOINT; \
    }}}