Checkpointer.hpp

/*
 * Checkpointer.hpp
 *
 *  Created on Sep 28, 2016
 *      Author: Pete Schultz
 */

#ifndef CHECKPOINTER_HPP_
#define CHECKPOINTER_HPP_

#include "checkpointing/CheckpointEntry.hpp"
#include "checkpointing/CheckpointEntryData.hpp"
#include "io/PVParams.hpp"
// #include "io/io.hpp"
#include "observerpattern/Subject.hpp"
// #include "structures/MPIBlock.hpp"
#include "utils/Timer.hpp"
#include <ctime>
// #include <map>
// #include <memory>
// #include <string>

namespace PV {

class Checkpointer : public Subject {
  private:
   virtual void ioParam_verifyWrites(enum ParamsIOFlag ioFlag, PVParams *params);

   virtual void ioParam_outputPath(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWrite(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWriteDir(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWriteTriggerMode(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWriteStepInterval(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWriteTimeInterval(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWriteClockInterval(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointWriteClockUnit(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_checkpointIndexWidth(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_suppressNonplasticCheckpoints(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_deleteOlderCheckpoints(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_numCheckpointsKept(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_initializeFromCheckpointDir(enum ParamsIOFlag ioFlag, PVParams *params);

   void ioParam_lastCheckpointDir(enum ParamsIOFlag ioFlag, PVParams *params);
   enum CheckpointWriteTriggerMode { NONE, STEP, SIMTIME, WALLCLOCK };
   enum WallClockUnit { SECOND, MINUTE, HOUR, DAY };

  public:
   struct TimeInfo {
      double mSimTime                 = 0.0;
      long int mCurrentCheckpointStep = 0L;
   };
   Checkpointer(
         std::string const &name,
         MPIBlock const *globalMPIBlock,
         Arguments const *arguments);
   ~Checkpointer();

   std::string makeOutputPathFilename(std::string const &path);

   void ioParams(enum ParamsIOFlag ioFlag, PVParams *params);
   void provideFinalStep(long int finalStep);

   template <typename T>
   bool registerCheckpointData(
         std::string const &objName,
         std::string const &dataName,
         T *dataPointer,
         size_t numValues,
         bool broadcast,
         bool constantEntireRun);

   bool registerCheckpointEntry(
         std::shared_ptr<CheckpointEntry> checkpointEntry,
         bool constantEntireRun);

   void registerTimer(Timer const *timer);
   virtual void addObserver(Observer *observer) override;

   void readNamedCheckpointEntry(
         std::string const &objName,
         std::string const &dataName,
         bool constantEntireRun);
   void
   readNamedCheckpointEntry(std::string const &checkpointEntryName, bool constantEntireRun = false);
   void readStateFromCheckpoint();
   void checkpointRead(double *simTimePointer, long int *currentStepPointer);
   void checkpointWrite(double simTime);
   void finalCheckpoint(double simTime);
   void writeTimers(PrintStream &stream) const;

   MPIBlock const *getMPIBlock() { return mMPIBlock; }
   bool doesVerifyWrites() { return mVerifyWrites; }
   std::string const &getOutputPath() { return mOutputPath; }
   bool getCheckpointWriteFlag() const { return mCheckpointWriteFlag; }
   char const *getCheckpointWriteDir() const { return mCheckpointWriteDir; }
   enum CheckpointWriteTriggerMode getCheckpointWriteTriggerMode() const {
      return mCheckpointWriteTriggerMode;
   }
   long int getCheckpointWriteStepInterval() const { return mCheckpointWriteStepInterval; }
   double getCheckpointWriteSimtimeInterval() const { return mCheckpointWriteSimtimeInterval; }
   bool getSuppressNonplasticCheckpoints() const { return mSuppressNonplasticCheckpoints; }
   std::string const &getCheckpointReadDirectory() const { return mCheckpointReadDirectory; }
   char const *getLastCheckpointDir() const { return mLastCheckpointDir; }
   char const *getInitializeFromCheckpointDir() const { return mInitializeFromCheckpointDir; }
   std::string const &getBlockDirectoryName() const { return mBlockDirectoryName; }

  private:
   void initMPIBlock(MPIBlock const *globalMPIBlock, Arguments const *arguments);
   void initBlockDirectoryName();
   void ioParamsFillGroup(enum ParamsIOFlag ioFlag, PVParams *params);

   void extractCheckpointReadDirectory();
   void findWarmStartDirectory();
   std::string makeCheckpointDirectoryFromCurrentStep();

   bool receivedSignal();

   bool scheduledCheckpoint();

   bool scheduledStep();

   bool scheduledSimTime();

   bool scheduledWallclock();

   void checkpointWriteSignal();

   void checkpointNow();

   void checkpointToDirectory(std::string const &checkpointDirectory);

   void rotateOldCheckpoints(std::string const &newCheckpointDirectory);
   void writeTimers(std::string const &directory);
   std::string generateBlockPath(std::string const &baseDirectory);
   void verifyDirectory(char const *directory, std::string const &description);

  private:
   std::string mName;
   MPIBlock *mMPIBlock = nullptr;
   std::string mBlockDirectoryName;
   std::vector<std::shared_ptr<CheckpointEntry>> mCheckpointRegistry; // Needs to be a vector so
   // that each MPI process
   // iterates over the entries
   // in the same order.
   ObserverTable mObserverTable;
   TimeInfo mTimeInfo;
   std::shared_ptr<CheckpointEntryData<TimeInfo>> mTimeInfoCheckpointEntry = nullptr;
   bool mWarmStart                                                         = false;
   bool mVerifyWrites                                                      = true;
   std::string mOutputPath                                                 = "";
   bool mCheckpointWriteFlag                                               = false;
   char *mCheckpointWriteDir                                               = nullptr;
   char *mCheckpointWriteTriggerModeString                                 = nullptr;
   enum CheckpointWriteTriggerMode mCheckpointWriteTriggerMode             = NONE;
   long int mCheckpointWriteStepInterval                                   = 1L;
   double mCheckpointWriteSimtimeInterval                                  = 1.0;
   std::time_t mCheckpointWriteWallclockInterval                           = 1L;
   char *mCheckpointWriteWallclockUnit                                     = nullptr;
   std::time_t mCheckpointWriteWallclockIntervalSeconds                    = 1L;
   int mCheckpointIndexWidth                                               = -1;
   bool mSuppressNonplasticCheckpoints                                     = false;
   bool mDeleteOlderCheckpoints                                            = false;
   int mNumCheckpointsKept                                                 = 2;
   char *mLastCheckpointDir                                                = nullptr;
   char *mInitializeFromCheckpointDir                                      = nullptr;
   std::string mCheckpointReadDirectory;
   long int mNextCheckpointStep         = 0L; // kept only for consistency with HyPerCol
   double mNextCheckpointSimtime        = 0.0;
   std::time_t mLastCheckpointWallclock = (std::time_t)0;
   std::time_t mNextCheckpointWallclock = (std::time_t)0;
   int mWidthOfFinalStepNumber          = 0;
   int mOldCheckpointDirectoriesIndex =
         0; // A pointer to the oldest checkpoint in the mOldCheckpointDirectories vector.
   std::vector<std::string> mOldCheckpointDirectories; // A ring buffer of existing checkpoints,
   // used if mDeleteOlderCheckpoints is true.
   std::vector<Timer const *> mTimers;
   Timer *mCheckpointTimer = nullptr;

   static std::string const mDefaultOutputPath;
};

} // namespace PV

#include "Checkpointer.tpp"

#endif // CHECKPOINTER_HPP_