checkpointAction.h

// Copyright 2009-2025 NTESS. Under the terms
// of Contract DE-NA0003525 with NTESS, the U.S.
// Government retains certain rights in this software.
//
// Copyright (c) 2009-2025, 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 <cstdint>
#include <set>
#include <string>

namespace SST {

class Simulation_impl;
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.
 */
std::string initializeCheckpointInfrastructure(Config* cfg, bool rt_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_impl* 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_impl* sim);

    /** 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_impl* 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