checkpointAction.h

// Copyright 2009-2026 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2026, NTESS
// All rights reserved.
//
// This file is part of the SST software package. For license
// information, see the LICENSE file in the top level directory of the
// distribution.
 
#ifndef SST_CORE_CHECKPOINT_ACTION_H
#define SST_CORE_CHECKPOINT_ACTION_H
 
#include "sst/core/action.h"
#include "sst/core/config.h"
#include "sst/core/cputimer.h"
#include "sst/core/output.h"
#include "sst/core/rankInfo.h"
#include "sst/core/sst_types.h"
#include "sst/core/threadsafe.h"
#include "sst/core/timeConverter.h"
 
#include <cstdint>
#include <set>
#include <string>
 
namespace SST {
 
class Simulation;
class TimeConverter;
 
namespace Checkpointing {
/* Utility functions needed to manage directories */
 
/**
   Creates a directory of the specified basename. If a directory named
   basename already exists, it will append an _N to the end,
   incrementing N from 1 until it finds an unused name.
 */
std::string createUniqueDirectory(const std::string basename);
 
/**
   Removes a directory.  For safety, this will recurse and remove each
   file individually instead of issuing an rm -r.  It will not follow
   links, but will simply remove the link.
 */
void removeDirectory(const std::string name);
 
/**
   Initializes the infrastructure needed for checkpointing.  Uses the createUniqueDirectory() function to create the
   directory, then broadcasts the name to all ranks.
 
   This function is called twice.  Once after graph parititioning and once right after creation of the realtime manager
   in the Simulation object. The first call will create the directory structure if any of the command line options other
   than realtime actions enable checkpointing.  This is needed so that the system can write out the ConfigGraph for
   repartitioned restarts while is still has it in one piece (note, this is not done for parallel loads).  We check
   again after the realtime manager is created in case the only way to trigger a checkpoint is through signals.
 */
std::string initializeCheckpointInfrastructure(Config* cfg, bool can_ckpt, int myRank);
 
} // namespace Checkpointing
 
/**
  \class CheckpointAction
    A recurring event to trigger checkpoint generation
*/
class CheckpointAction : public Action
{
public:
    /**
    Create a new checkpoint object for the simulation core to initiate checkpoints
    */
    CheckpointAction(Config* cfg, RankInfo this_rank, Simulation* sim, TimeConverter period);
    ~CheckpointAction() = default;
 
    /**
       Indicates CheckpointAction should be inserted into the
       TimeVortex. The insertion will only happen for serial runs, as
       CheckpointAction is managed by the SyncManager in parallel
       runs.
     */
    void insertIntoTimeVortex(Simulation* sim);
 
    /** Get checkpoint flag */
    bool getCheckpoint();
 
    /** Generate a checkpoint next time check() is called */
    void setCheckpoint();
 
    /** Called by TimeVortex to trigger checkpoint on simulation clock interval - not used in parallel simulation */
    void execute() override;
 
    /** Called by SyncManager to check whether a checkpoint should be generated */
    SimTime_t check(SimTime_t current_time);
 
    /** Return next checkpoint time */
    SimTime_t getNextCheckpointSimTime();
 
    static Core::ThreadSafe::Barrier barrier;
    static uint32_t                  checkpoint_id;
 
    NotSerializable(SST::CheckpointAction);
 
private:
    CheckpointAction(const CheckpointAction&)            = delete;
    CheckpointAction& operator=(const CheckpointAction&) = delete;
 
    void createCheckpoint(Simulation* sim); // The actual checkpoint operation
 
    RankInfo      rank_;          // RankInfo for this thread/rank
    TimeConverter period_;        // Simulation time interval for scheduling or nullptr if not set
    double        last_cpu_time_; // Last time a checkpoint was triggered
    bool          generate_;      // Whether a checkpoint should be done next time check() is called
    SimTime_t     next_sim_time_; // Next simulationt ime a checkpoint should trigger at or 0 if not applicable
    std::string   dir_format_;    // Format string for checkpoint directory names
    std::string   file_format_;   // Format string for checkpoint file names
};
 
} // namespace SST
 
#endif // SST_CORE_CHECKPOINT_ACTION_H