RestartManager.h

Go to the documentation of this file.

#ifndef included_AMP_RestartManager
#define included_AMP_RestartManager
 
#include "AMP/IO/HDF.h"
#include "AMP/utils/TypeTraits.h"
 
#include <map>
#include <string>
 
 
namespace AMP::IO {
 
 
class RestartManager final
{
public: // User functions
    RestartManager();
 
    RestartManager( const std::string &filename );
 
    RestartManager( const RestartManager & ) = delete;
 
    RestartManager &operator=( const RestartManager & ) = delete;
 
    RestartManager( RestartManager && );
 
    RestartManager &operator=( RestartManager && );
 
    ~RestartManager();
 
    void reset();
 
    void write( const std::string &filename, Compression compress = Compression::None );
 
    void load( const std::string &filename );
 
    template<class TYPE>
    void registerData( const TYPE &data, const std::string &name );
 
    template<class TYPE>
    std::shared_ptr<TYPE> getData( const std::string &name );
 
 
public: // Developer functions
    template<class TYPE>
    uint64_t registerObject( const TYPE &data );
 
    uint64_t registerComm( const AMP::AMP_MPI &comm );
 
    template<class TYPE>
    std::shared_ptr<TYPE> getData( uint64_t hash );
 
 
    AMP_MPI getComm( uint64_t hash );
 
 
    template<class TYPE>
    uint64_t registerSAMRAIData( std::shared_ptr<const TYPE &> data );
 
    template<class TYPE>
    std::shared_ptr<TYPE> getSAMRAIData( uint64_t hash );
 
 
    bool isRegistered( uint64_t hash );
 
 
public:
    class DataStore
    {
    public:
        virtual ~DataStore() = default;
        inline uint64_t getHash() const { return d_hash; }
        virtual void write( hid_t fid, const std::string &name ) const = 0;
 
    protected:
        uint64_t d_hash = 0;
    };
 
    template<class TYPE>
    class DataStoreType : public DataStore
    {
    public:
        DataStoreType( hid_t fid, uint64_t hash, RestartManager *manager );
        DataStoreType( std::shared_ptr<const TYPE>, RestartManager * );
        virtual ~DataStoreType() = default;
        void write( hid_t fid, const std::string &name ) const override;
        virtual std::shared_ptr<TYPE>
        read( hid_t fid, const std::string &name, RestartManager * ) const;
        auto getData() { return std::const_pointer_cast<TYPE>( d_data ); }
 
    protected:
        DataStoreType() = default;
        std::shared_ptr<const TYPE> d_data;
    };
 
    // Specialization for SAMRAI data object
    template<class TYPE>
    class SAMRAIDataStore : public DataStoreType<TYPE>
    {
    public:
        SAMRAIDataStore( hid_t fid, uint64_t hash, RestartManager *manager );
        SAMRAIDataStore( std::shared_ptr<const TYPE>, RestartManager * );
        virtual ~SAMRAIDataStore() = default;
        void write( hid_t fid, const std::string &name ) const override;
        std::shared_ptr<TYPE>
        read( hid_t fid, const std::string &name, RestartManager * ) const override;
    };
    using DataStorePtr = std::shared_ptr<DataStore>;
 
 
private: // Private functions
    template<class TYPE>
    RestartManager::DataStorePtr create( std::shared_ptr<const TYPE> );
 
    void writeCommData( const std::string &file, Compression compress );
    void readCommData( const std::string &file );
    static std::string hash2String( uint64_t );
 
private:                                     // Data members
    hid_t d_fid;                             // fid for reading
    std::map<uint64_t, DataStorePtr> d_data; // Object data
    std::map<std::string, uint64_t> d_names; // Names to associate with the hashes
    std::map<uint64_t, AMP_MPI> d_comms;     // Registered communicators
};
 
 
} // namespace AMP::IO
 
 
#include "AMP/IO/RestartManager.hpp"
 
 
#endif