exit.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_CORE_EXIT_H
#define SST_CORE_CORE_EXIT_H
 
#include "sst/core/action.h"
#include "sst/core/sst_types.h"
#include "sst/core/threadsafe.h"
 
#include <cinttypes>
#include <cstdint>
#include <string>
#include <unordered_set>
 
namespace SST {
 
class Simulation;
 
/**
   Exit Action
 
   Tracks the number of components that have requested DoNotEndSim.
   Once that count reaches 0, the Exit object will end the simulation.
 */
class Exit : public Action
{
public:
    /**
       Create a new ExitEvent
 
       @param num_threads number of threads on the rank
       @param single_rank True if there are no other ranks
    */
    Exit(int num_threads, bool single_rank);
 
    ~Exit();
 
    /**
       Increment reference count on a given thread
 
       @param thread number of Component making call
    */
    void refInc(uint32_t thread);
 
    /**
       Decrement reference count on a given thread
 
       @param thread number of Component making call
    */
    void refDec(uint32_t thread);
 
    /**
       Get the current local reference count
 
       @return current local reference count
     */
    unsigned int getRefCount();
 
    /**
       Gets the end time of the simulation
 
       @return Time when simulation ends
    */
    SimTime_t getEndTime() { return end_time_; }
 
    /**
       Stores the time the simulation has ended
 
       @param time Current simulation time
    */
    void setEndTime(SimTime_t time) { end_time_ = time; }
 
    /**
       Computes the end time of the simulation.  This call
       synchronizes across ranks.
 
       @return End time of the simulation
    */
    SimTime_t computeEndTime();
 
    /**
       Function called when Exit fires in the TimeVortex
    */
    void execute() override;
 
    /**
       Function called by SyncManager to check to see if it's time to
       exit.  This call synchronizes across ranks.
    */
    void check();
 
    /**
       Creates a string representation of the Exit object
 
       @return string representation of Exit object
    */
    std::string toString() const override;
 
    /**
       Get the global ref_count.  This is only valid after check() is
       called
 
       @return global ref_count
    */
    unsigned int getGlobalCount() { return global_count_; }
 
    // Exit should not be serialized. It will be created new on
    // restart and Components store there primary component state and
    // reregister with Exit on restart.
    NotSerializable(SST::Exit)
 
private:
    Exit()                       = delete;
    Exit(const Exit&)            = delete;
    Exit& operator=(const Exit&) = delete;
 
    int           num_threads_   = 0;
    unsigned int  ref_count_     = 0;
    unsigned int* thread_counts_ = nullptr;
    unsigned int  global_count_  = 0;
    SimTime_t     end_time_      = 0;
    bool          single_rank_   = true;
 
    Core::ThreadSafe::Spinlock slock_;
};
 
} // namespace SST
 
#endif // SST_CORE_EXIT_H