Gambit::SignalData Class Reference

Variables for use in signal handlers. More...

#include <signal_handling.hpp>

Public Types
typedef void(*	void_func) ()
	Set cleanup function to run during emergency shutdown. More...

Public Attributes
jmp_buf	env
	Saved information on calling environment for longjmp. More...
bool	jumppoint_set
int	havejumped
void_func	cleanup
bool	cleanup_function_set

Private Attributes
int	rank
volatile sig_atomic_t	shutdownBegun
	Flag to warn if early shutdown is already in process. More...
volatile sig_atomic_t	emergency
	Flag to warn if the shutdown that is in progress is an emergency shutdown (use to decided whether to attempt MPI synchronisation) More...
bool	POSIX_signal_noticed
	Flag to indicate if POSIX shutdown signal has been noticed. More...
bool	shutdown_due_to_MPI_message
int	shutdown_attempts
	Number of times synchronisation for soft shutdown has been attempted;. More...
int	attempts_since_ff
int	ff_loop_count
bool	ff_on
int	ff_count
bool	inside_omp_block
	Flag to switch signal handling behavior to multithreaded mode (i.e. More...
int	received_signals [MAX_SIGNALS]
int	N_signals

Static Private Attributes
static const int	MAX_SIGNALS = 10
	Array to record received signals (up to max_signals) More...
	SignalData ()
	SignalData member functions. More...
std::string	myrank ()
	Retrieve MPI rank as a string (for log messages etc.) More...
void	setjump ()
	Set jump point;. More...
void	set_cleanup (void_func f)
	Set cleanup function. More...
void	call_cleanup ()
	Call cleanup function. More...
void	set_shutdown_begun (const sig_atomic_t emergnc=0)
	Register that shutdown has begun. More...
bool	shutdown_begun ()
	Check if (any kind of) shutdown is in progress. More...
EXPORT_SYMBOLS bool	check_if_shutdown_begun ()
	Check for signals that early shutdown is required If an MPI message telling us to perform an emergency shutdown is received (which should only happen in the case of an error on some other process) then a shutdown exception is raised. More...
void	add_signal (int sig)
	Check if emergency shutdown is in progress. More...
std::string	display_received_signals ()
	Print to string a list of the signals received so far by this process. More...
void	entering_multithreaded_region ()
	Check if shutdown is in progress and raise appropriate termination exception if so. More...
void	leaving_multithreaded_region ()
	Exit threadsafe signal handling mode. More...
bool	inside_multithreaded_region ()
	Report 'true' if inside a multithreaded region (according to our own flag) More...
void	update_looptime (double newtime)
	Extra functions needed in MPI mode. More...
void	attempt_soft_shutdown ()
	Perform soft shutdown if processes can be synchronised. More...
bool	all_processes_ready ()
	Attempt to synchronise all processes, but abort if it takes too long. More...

Detailed Description

Variables for use in signal handlers.

Definition at line 74 of file signal_handling.hpp.

Member Typedef Documentation

void_func

typedef void(* Gambit::SignalData::void_func) ()

Set cleanup function to run during emergency shutdown.

Definition at line 91 of file signal_handling.hpp.

Constructor & Destructor Documentation

SignalData()

Gambit::SignalData::SignalData

(

)

SignalData member functions.

Constructor (initialise member variables)

Definition at line 142 of file signal_handling.cpp.

     : jumppoint_set(false)
     , havejumped(1) // set to zero after jump point set
     , cleanup_function_set(false)
     , rank(-1)
     , shutdownBegun(0)
     , emergency(0)
     , POSIX_signal_noticed(false)
     , shutdown_due_to_MPI_message(false)
     , shutdown_attempts(0)
     , attempts_since_ff(0)
     , ff_loop_count(0)
     , ff_on(false)
     , ff_count(0)
     , inside_omp_block(false)
     , N_signals(0)
     #ifdef WITH_MPI
     , MPIsize(1)
     , _comm_rdy(false)
     , shutdown_broadcast_done(false)
     , looptimes(1000)
     , timeout(500)
     , msgs()
     #endif
   {
     #ifdef WITH_MPI
     msgs[SOFT_SHUTDOWN]      = ShutdownMsg(SOFT_SHUTDOWN,shutdown_name(SOFT_SHUTDOWN));
     msgs[EMERGENCY_SHUTDOWN] = ShutdownMsg(EMERGENCY_SHUTDOWN,shutdown_name(EMERGENCY_SHUTDOWN));
     msgs[NO_MORE_MESSAGES]   = ShutdownMsg(NO_MORE_MESSAGES,shutdown_name(NO_MORE_MESSAGES));
     #endif
   }

Member Function Documentation

add_signal()

void Gambit::SignalData::add_signal

(

int

sig

)

Check if emergency shutdown is in progress.

Add signal to record.

Add signal to record

Definition at line 209 of file signal_handling.cpp.

References MAX_SIGNALS, N_signals, and received_signals.

Referenced by Gambit::sighandler_soft().

   {
     //std::cerr << " Adding signal " << sig << std::endl; // debugging
     if(N_signals<MAX_SIGNALS) {
        received_signals[N_signals] = sig;
        N_signals+=1;
     }
     else
     {
        // no more space to record signals.
        N_signals+=1;
     }
   }

Here is the caller graph for this function:

all_processes_ready()

bool Gambit::SignalData::all_processes_ready ( )

private

Attempt to synchronise all processes, but abort if it takes too long.

Definition at line 265 of file signal_handling.cpp.

References Gambit::EOM, and Gambit::logger().

Referenced by attempt_soft_shutdown().

   {
     #ifdef WITH_MPI
       logger() << "Waiting up to "<<timeout/1000<<" seconds for all processes to sync..." << EOM;
       // sleep setup
       bool timedout = false;
       std::chrono::milliseconds bar_timeout(std::lround(timeout));
       if( signalComm->BarrierWithTimeout(bar_timeout, 9999) )
       {
         timedout = true; // Barrier timed out waiting for some process to enter
       }
       // else the barrier succeed in synchronising all processes
       logger() << "Synchronised? " << !timedout << EOM;
       return !timedout;
     #else
       return true; // Always ready if no MPI
     #endif
   }

Here is the call graph for this function:

Here is the caller graph for this function:

attempt_soft_shutdown()

void Gambit::SignalData::attempt_soft_shutdown

(

)

Perform soft shutdown if processes can be synchronised.

Start counting...

First time we see the shutdown signal, we will allow control to return to the scanner at least once, so that it can get its own affairs in order.

Definition at line 284 of file signal_handling.cpp.

References all_processes_ready(), attempts_since_ff, call_cleanup(), Gambit::EOM, ff_count, ff_loop_count, ff_on, Gambit::logger(), myrank(), and shutdown_attempts.

Referenced by Gambit::Scanner::Scanner_Plugin_Function< ret(args...)>::main(), Gambit::Scanner::Multi_Scanner_Plugin_Function< ret(args...)>::main(), and Gambit::Likelihood_Container::main().

   {
     const int max_attempts=-1; // Number of extra likelihood evaluations allowed for sync attempts before we declare failure. -1 means "unlimited"
     const int attempts_before_ff=10; // Number of times to attempt synchronisation before entering a "fast forward" period
     const int ff_loops=1000; // Number of "fast-forward" loops to perform in a fast-forward period

     static std::chrono::time_point<std::chrono::system_clock> start(std::chrono::system_clock::now());

     if(shutdown_attempts==0)
     {
        logger() << "Beginning GAMBIT soft shutdown procedure. Control will be returned to the scanner plugin so "
                 << "that it can get its affairs in order in preparation for shutdown (it may cease iterating if "
                 << "it has that capability), and next iteration we will attempt to synchronise all processes and "
                 << "shut them down. If sync fails, we will loop up to "<<max_attempts<<" times (-1 means infinite), attempting to "
                 << "synchronise each time. If sync fails, an emergency shutdown will be attempted." << EOM;
        ++shutdown_attempts;
     }
     else if(ff_on)
     {
        logger() << "Fast-forward active (loop "<<ff_loop_count<<"); no synchronisation attempted." << EOM;
        // Fast-forward active; just increment counters and return
        ++ff_loop_count;
        if(ff_loop_count>=ff_loops)
        {
          logger() << "Fast-forward period finished (performed "<<ff_loop_count<<" fast loops)." << EOM;
          ff_on = false;
          ff_loop_count=0;
        }
     }
     else if(attempts_since_ff>=attempts_before_ff)
     {
        // Enter "fast-forward" period
        ff_on = true;
        ++ff_count;
        std::ostringstream msg;
        msg << "rank "<<myrank()<<": Tried to synchronise for shutdown (attempt "<<shutdown_attempts<<") but failed. Will now fast-forward through "<<ff_loops<<" iterations in an attempt to 'unlock' possible MPI deadlocks with the scanner.";
        std::cerr << msg.str() << std::endl;
        logger() << msg.str() << EOM;
        // Reset counters
        attempts_since_ff=0;
     }
     else
     {
        // Normal sync attempt (no fast forward)
        if(shutdown_attempts==1)
        {
           logger() << "Scanner did not shut down when given the chance; we will therefore assume responsibility for terminating the scan." << EOM;
        }
        logger() << "Attempting to synchronise for soft shutdown (attempt "<<shutdown_attempts<<")" << EOM;
        if (all_processes_ready())
        {
          logger() << "Calling cleanup routines" << EOM;
          call_cleanup();
          std::ostringstream msg;
          logger() << "Throwing soft shutdown exception" << EOM;
          throw SoftShutdownException(msg.str());
        }

        // Compute elapsed time since shutdown began
        std::chrono::time_point<std::chrono::system_clock> current = std::chrono::system_clock::now();
        std::chrono::duration<double> time_waited = current - start;

        if(max_attempts!=-1 and shutdown_attempts>=max_attempts)
        {
          logger() << "Failed to synchronise for soft shutdown! Attempting cleanup anyway, but cannot guarantee safety of the scan output." << EOM;
          call_cleanup();
          std::ostringstream msg;
          #ifdef WITH_MPI
          msg << "rank "<<myrank()<<": ";
          #endif
          msg << "Soft shutdown failed, emergency shutdown performed instead! (could not synchronise all processes after "<<shutdown_attempts
              <<" attempts, and after waiting "<<std::chrono::duration_cast<std::chrono::seconds>(time_waited).count()
              <<" seconds; fast-forward periods of "<<ff_loops<<" iterations were performed "<<ff_count
              <<" times). Data handled by external scanner codes may have been left in an inconsistent state." << std::endl;
          throw HardShutdownException(msg.str());
        }
        else
        {
          logger() << "Attempt to sync for soft shutdown failed (this was attempt "<<shutdown_attempts<<" of "<<max_attempts<<" (-1 means infinite)); "
                   <<std::chrono::duration_cast<std::chrono::seconds>(time_waited).count() <<" seconds have elapsed since "
                   <<"shutdown attempts began). Will allow evaluation to continue and attempt to sync again next iteration." << EOM;
        }
        ++shutdown_attempts;
        ++attempts_since_ff;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

call_cleanup()

void Gambit::SignalData::call_cleanup

(

)

Call cleanup function.

Definition at line 202 of file signal_handling.cpp.

References cleanup, and cleanup_function_set.

Referenced by attempt_soft_shutdown().

   {
      if(cleanup_function_set) cleanup();
      // Do nothing if no function has been set;
   }

Here is the caller graph for this function:

check_if_shutdown_begun()

bool Gambit::SignalData::check_if_shutdown_begun

(

)

Check for signals that early shutdown is required If an MPI message telling us to perform an emergency shutdown is received (which should only happen in the case of an error on some other process) then a shutdown exception is raised.

Otherwise, we just return a bool indicating the shutdown status

Definition at line 379 of file signal_handling.cpp.

References Gambit::LogTags::core, display_received_signals(), emergency, Gambit::EOM, Gambit::LogTags::info, Gambit::logger(), POSIX_signal_noticed, rank, set_shutdown_begun(), shutdown_begun(), and shutdown_due_to_MPI_message.

Referenced by Gambit::Printers::check_for_error_messages().

   {
     if(not shutdown_begun())
     {
        // If shutdown is not known to be in progress, check for MPI messages telling us to initiate shutdown
        #ifdef WITH_MPI
        #ifdef SIGNAL_DEBUG
        logger() << LogTags::core << LogTags::info << "Doing Iprobe to check for shutdown messages from other processes (with MPI tag "<<signalComm->mytag<<")" << EOM;
        #endif
        if(signalComm->Iprobe(MPI_ANY_SOURCE, signalComm->mytag))
        {
          #ifdef SIGNAL_DEBUG
          logger() << LogTags::core << LogTags::info << "Shutdown message detected; doing Recv" << EOM;
          #endif
          int code;
          MPI_Status msg_status;
          signalComm->Recv(&code, 1, MPI_ANY_SOURCE, signalComm->mytag, &msg_status);

          // Check what code was received and use it to determined what kind of shutdown to do
          if(code==SOFT_SHUTDOWN)
          {
            set_shutdown_begun();
            logger() << LogTags::core << LogTags::info << "Received SOFT shutdown message from process with rank " << msg_status.MPI_SOURCE << EOM;
          }
          else if(code==EMERGENCY_SHUTDOWN)
          {
            set_shutdown_begun(1); // '1' argument means emergency set also.
            logger() << LogTags::core << LogTags::info << "Received EMERGENCY shutdown message from process with rank " << msg_status.MPI_SOURCE << EOM;
          }
          else
          {
            std::ostringstream ss;
            ss << "Received UNRECOGNISED shutdown message from process with rank " << msg_status.MPI_SOURCE<<". Performing emergency shutdown, but please note that this indicates a ***BUG*** somewhere in the signal handling code!!!";
            std::cout << ss.str() << std::endl;
            logger() << LogTags::core << LogTags::info << ss.str() << EOM;
            set_shutdown_begun(1); // '1' argument means emergency set also.
          }

          shutdown_due_to_MPI_message = true;
        }
        #ifdef SIGNAL_DEBUG
        else
        {
           logger() << LogTags::core << LogTags::info << "No shutdown message detected; continuing as normal" << EOM;
        }
        #endif
        #endif
     }

     // Check shutdown status again (might have changed due to MPI message receipt)
     if(shutdown_begun())
     {
       if(not POSIX_signal_noticed and not shutdown_due_to_MPI_message)
       {
         std::ostringstream ss;
         ss << "Process "<<rank<<": Shutdown signal detected!"<< std::endl;
         // std::cerr << ss.str();
         logger() << ss.str() << display_received_signals() << EOM;
         POSIX_signal_noticed = true;
       }

       std::ostringstream ss;
       static int loopi(0);
       logger() << "Shutdown is in progress; emergency="<< emergency <<" (loop="<<loopi<<")"<< EOM;
       ++loopi;
       logger() << ss.str() << EOM;

       #ifdef WITH_MPI
       if(not shutdown_due_to_MPI_message) // Don't broadcast another shutdown message if we are shutting down due to an MPI message we received. Assume that all processes will get the first message (otherwise for 1000 process job we will end up with 1000*1000 shutdown messages clogging up the network)
       {
         // Broadcast shutdown message to all processes
         int shutdown_code;
         if(emergency)
         {
           shutdown_code = EMERGENCY_SHUTDOWN;
         }
         else
         {
           shutdown_code = SOFT_SHUTDOWN;
         }
         broadcast_shutdown_signal(shutdown_code);
       }
       else if(emergency)
       {
         throw MPIShutdownException("Received emergency shutdown command via MPI! Terminating run.");
       }
       #endif

     }
     return shutdown_begun();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

display_received_signals()

std::string Gambit::SignalData::display_received_signals

(

)

Print to string a list of the signals received so far by this process.

Definition at line 224 of file signal_handling.cpp.

References MAX_SIGNALS, N_signals, received_signals, and Gambit::signal_name().

Referenced by check_if_shutdown_begun(), and main().

   {
     std::ostringstream myout;
     if(N_signals > 0 )
     {
       myout << "Caught the following signals (in order):" << std::endl;
       for(int i=0; i<N_signals; i++)
       {
         if(i<MAX_SIGNALS)
         {
           myout <<"#"<<i+1<<": Signal "<<received_signals[i]<<" ("<<signal_name(received_signals[i])<<")"<<std::endl;
         }
       }
       if( (N_signals - MAX_SIGNALS) > 0)
       {
         myout << "Another " << (N_signals - MAX_SIGNALS) <<" signals were caught but their values were not recorded (buffer exceeded)"<<std::endl;
       }
     }
     return myout.str();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

entering_multithreaded_region()

void Gambit::SignalData::entering_multithreaded_region

(

)

Check if shutdown is in progress and raise appropriate termination exception if so.

Absorb any extra shutdown messages that may be unreceived (since every process broadcasts to every other process that it should shut down, so with lots of processess there will be lots of unreceived messages floating around)

(to be called by Gambit once it is safe to trigger termination) Only check for emergency shutdown signals (i.e. do not attempt synchronisation) Switch to threadsafe signal handling mode

TODO: Thread checking routines are no longer needed due to simplified shutdown method. Can be deleted when functors are updated to no longer call these routines. Switch to threadsafe signal handling mode

Definition at line 550 of file signal_handling.cpp.

References inside_omp_block.

Referenced by Gambit::FunctorHelp::entering_multithreaded_region().

   {
      inside_omp_block = 1;
      // Debugging
      //std::cerr << "rank " << rank <<": ENTERING_MULTITHREADED_REGION" << std::endl;
      //std::cerr << "rank " << rank <<": signaldata().inside_omp_block=1 " << std::endl;
   }

Here is the caller graph for this function:

inside_multithreaded_region()

bool Gambit::SignalData::inside_multithreaded_region

(

)

Report 'true' if inside a multithreaded region (according to our own flag)

Definition at line 568 of file signal_handling.cpp.

References Gambit::LogTags::core, Gambit::EOM, Gambit::LogTags::info, inside_omp_block, LOCAL_INFO, Gambit::logger(), rank, and Gambit::utils_error().

   {
      return inside_omp_block;
   }

Here is the call graph for this function:

leaving_multithreaded_region()

void Gambit::SignalData::leaving_multithreaded_region

(

)

Exit threadsafe signal handling mode.

Definition at line 559 of file signal_handling.cpp.

References inside_omp_block.

Referenced by Gambit::FunctorHelp::leaving_multithreaded_region().

   {
      inside_omp_block = 0;
      // Debugging
      //std::cerr << "rank " << rank <<": LEAVING_MULTITHREADED_REGION" << std::endl;
      //std::cerr << "rank " << rank <<": signaldata().inside_omp_block=0 " << std::endl;
   }

Here is the caller graph for this function:

myrank()

std::string Gambit::SignalData::myrank

(

)

Retrieve MPI rank as a string (for log messages etc.)

Definition at line 175 of file signal_handling.cpp.

References rank.

Referenced by attempt_soft_shutdown(), Gambit::FunctorHelp::entering_multithreaded_region(), and Gambit::FunctorHelp::leaving_multithreaded_region().

   {
     std::ostringstream tmp;
     #ifdef WITH_MPI
     if(rank==-1) { tmp << "UNKNOWN"; }
     else         { tmp << rank; }
     #else
     tmp << "(MPI DISABLED)";
     #endif
     return tmp.str();
   }

Here is the caller graph for this function:

set_cleanup()

void Gambit::SignalData::set_cleanup

(

void_func

f

)

Set cleanup function.

Definition at line 195 of file signal_handling.cpp.

References cleanup, cleanup_function_set, and f.

Referenced by main().

   {
      cleanup = f;
      cleanup_function_set = true;
   }

Here is the caller graph for this function:

set_shutdown_begun()

void Gambit::SignalData::set_shutdown_begun

(

const sig_atomic_t

emergnc = 0

)

Register that shutdown has begun.

Definition at line 246 of file signal_handling.cpp.

References emergency, and shutdownBegun.

Referenced by check_if_shutdown_begun(), main(), and Gambit::sighandler_soft().

   {
     shutdownBegun = 1;
     emergency = emergnc;
     // // if(ignore_signals_during_shutdown)
     // {
     //    /// Redirect all future signals (except of course kill etc.) to the null handlers
     //    signal(SIGTERM, sighandler_null);
     //    signal(SIGINT,  sighandler_null);
     //    signal(SIGUSR1, sighandler_null);
     //    signal(SIGUSR2, sighandler_null);
     // }
   }

Here is the caller graph for this function:

setjump()

void Gambit::SignalData::setjump

(

)

Set jump point;.

Definition at line 188 of file signal_handling.cpp.

References env, havejumped, and jumppoint_set.

   {
      havejumped = setjmp(env);
      jumppoint_set = true;
   }

shutdown_begun()

bool Gambit::SignalData::shutdown_begun

(

)

Check if (any kind of) shutdown is in progress.

Check if shutdown is in progress.

Definition at line 261 of file signal_handling.cpp.

References shutdownBegun.

Referenced by check_if_shutdown_begun().

{ return shutdownBegun; }

Here is the caller graph for this function:

update_looptime()

void Gambit::SignalData::update_looptime

(

double

newtime

)

Extra functions needed in MPI mode.

Add a new loop time to internal array used to decide barrier timeout.

Add a new loop time to internal array used to decide barrier timeout

Definition at line 474 of file signal_handling.cpp.

References Gambit::LogTags::core, Gambit::LogTags::debug, Gambit::EOM, Gambit::LogTags::info, LOCAL_INFO, Gambit::logger(), cyclic_include_check::loop, rank, and Gambit::utils_error().

   {
     // Leave this as 1 second now that likelihood calculation is disabled during shutdown
   }

Here is the call graph for this function:

Member Data Documentation

attempts_since_ff

int Gambit::SignalData::attempts_since_ff

private

Definition at line 192 of file signal_handling.hpp.

Referenced by attempt_soft_shutdown().

cleanup

void_func Gambit::SignalData::cleanup

Definition at line 92 of file signal_handling.hpp.

Referenced by call_cleanup(), and set_cleanup().

cleanup_function_set

bool Gambit::SignalData::cleanup_function_set

Definition at line 93 of file signal_handling.hpp.

Referenced by call_cleanup(), and set_cleanup().

emergency

volatile sig_atomic_t Gambit::SignalData::emergency

private

Flag to warn if the shutdown that is in progress is an emergency shutdown (use to decided whether to attempt MPI synchronisation)

Definition at line 183 of file signal_handling.hpp.

Referenced by check_if_shutdown_begun(), and set_shutdown_begun().

env

jmp_buf Gambit::SignalData::env

Saved information on calling environment for longjmp.

Definition at line 82 of file signal_handling.hpp.

Referenced by setjump().

ff_count

int Gambit::SignalData::ff_count

private

Definition at line 195 of file signal_handling.hpp.

Referenced by attempt_soft_shutdown().

ff_loop_count

int Gambit::SignalData::ff_loop_count

private

Definition at line 193 of file signal_handling.hpp.

Referenced by attempt_soft_shutdown().

ff_on

bool Gambit::SignalData::ff_on

private

Definition at line 194 of file signal_handling.hpp.

Referenced by attempt_soft_shutdown().

havejumped

int Gambit::SignalData::havejumped

Definition at line 84 of file signal_handling.hpp.

Referenced by setjump().

inside_omp_block

bool Gambit::SignalData::inside_omp_block

private

Flag to switch signal handling behavior to multithreaded mode (i.e.

triggers switch to threadsafe emergency shutdown behaviour)

Definition at line 199 of file signal_handling.hpp.

Referenced by entering_multithreaded_region(), inside_multithreaded_region(), and leaving_multithreaded_region().

jumppoint_set

bool Gambit::SignalData::jumppoint_set

Definition at line 83 of file signal_handling.hpp.

Referenced by setjump().

MAX_SIGNALS

const int Gambit::SignalData::MAX_SIGNALS = 10

staticprivate

Array to record received signals (up to max_signals)

Definition at line 202 of file signal_handling.hpp.

Referenced by add_signal(), and display_received_signals().

N_signals

int Gambit::SignalData::N_signals

private

Definition at line 204 of file signal_handling.hpp.

Referenced by add_signal(), and display_received_signals().

POSIX_signal_noticed

bool Gambit::SignalData::POSIX_signal_noticed

private

Flag to indicate if POSIX shutdown signal has been noticed.

Definition at line 185 of file signal_handling.hpp.

Referenced by check_if_shutdown_begun().

rank

int Gambit::SignalData::rank

private

Definition at line 177 of file signal_handling.hpp.

Referenced by check_if_shutdown_begun(), inside_multithreaded_region(), myrank(), and update_looptime().

received_signals

int Gambit::SignalData::received_signals[MAX_SIGNALS]

private

Definition at line 203 of file signal_handling.hpp.

Referenced by add_signal(), and display_received_signals().

shutdown_attempts

int Gambit::SignalData::shutdown_attempts

private

Number of times synchronisation for soft shutdown has been attempted;.

Definition at line 191 of file signal_handling.hpp.

Referenced by attempt_soft_shutdown().

shutdown_due_to_MPI_message

bool Gambit::SignalData::shutdown_due_to_MPI_message

private

Definition at line 188 of file signal_handling.hpp.

Referenced by check_if_shutdown_begun().

shutdownBegun

volatile sig_atomic_t Gambit::SignalData::shutdownBegun

private

Flag to warn if early shutdown is already in process.

Definition at line 180 of file signal_handling.hpp.

Referenced by set_shutdown_begun(), and shutdown_begun().

---

The documentation for this class was generated from the following files:

• Utils/include/gambit/Utils/signal_handling.hpp
• Utils/src/signal_handling.cpp