G4MTRunManager.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// G4MTRunManager implementation
//
// Original authors: X.Dong, A.Dotti - February 2013
// --------------------------------------------------------------------
 
#include "G4MTRunManager.hh"
 
#include "G4AutoLock.hh"
#include "G4CopyRandomState.hh"
#include "G4MTRunManagerKernel.hh"
#include "G4ProductionCutsTable.hh"
#include "G4Run.hh"
#include "G4ScoringManager.hh"
#include "G4StateManager.hh"
#include "G4TiMemory.hh"
#include "G4Timer.hh"
#include "G4TransportationManager.hh"
#include "G4UImanager.hh"
#include "G4UserRunAction.hh"
#include "G4UserWorkerInitialization.hh"
#include "G4UserWorkerThreadInitialization.hh"
#include "G4VUserActionInitialization.hh"
#include "G4WorkerRunManager.hh"
#include "G4WorkerThread.hh"
 
G4ScoringManager* G4MTRunManager::masterScM = nullptr;
G4MTRunManager::masterWorlds_t G4MTRunManager::masterWorlds = G4MTRunManager::masterWorlds_t();
G4MTRunManager* G4MTRunManager::fMasterRM = nullptr;
G4int G4MTRunManager::seedOncePerCommunication = 0;
G4ThreadId G4MTRunManager::masterThreadId = G4ThisThread::get_id();
 
// --------------------------------------------------------------------
namespace
{
G4Mutex cmdHandlingMutex = G4MUTEX_INITIALIZER;
G4Mutex scorerMergerMutex = G4MUTEX_INITIALIZER;
G4Mutex runMergerMutex = G4MUTEX_INITIALIZER;
G4Mutex setUpEventMutex = G4MUTEX_INITIALIZER;
}  // namespace
 
// --------------------------------------------------------------------
G4MTRunManager* G4MTRunManager::GetMasterRunManager()
{
  return fMasterRM;
}
 
// --------------------------------------------------------------------
G4RunManagerKernel* G4MTRunManager::GetMasterRunManagerKernel()
{
  return fMasterRM->kernel;
}
 
// --------------------------------------------------------------------
G4MTRunManagerKernel* G4MTRunManager::GetMTMasterRunManagerKernel()
{
  return fMasterRM->MTkernel;
}
 
// --------------------------------------------------------------------
G4ScoringManager* G4MTRunManager::GetMasterScoringManager()
{
  return masterScM;
}
 
// --------------------------------------------------------------------
G4MTRunManager::masterWorlds_t& G4MTRunManager::GetMasterWorlds()
{
  return masterWorlds;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::addWorld(G4int counter, G4VPhysicalVolume* w)
{
  masterWorlds.insert(std::make_pair(counter, w));
}
 
// --------------------------------------------------------------------
G4ThreadId G4MTRunManager::GetMasterThreadId()
{
  return masterThreadId;
}
 
// --------------------------------------------------------------------
G4int G4MTRunManager::SeedOncePerCommunication()
{
  return seedOncePerCommunication;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetSeedOncePerCommunication(G4int val)
{
  seedOncePerCommunication = val;
}
 
// --------------------------------------------------------------------
G4MTRunManager::G4MTRunManager() : G4RunManager(masterRM)
{
  if (fMasterRM != nullptr) {
    G4Exception("G4MTRunManager::G4MTRunManager", "Run0110", FatalException,
                "Another instance of a G4MTRunManager already exists.");
  }
  fMasterRM = this;
  masterThreadId = G4ThisThread::get_id();
  MTkernel = static_cast<G4MTRunManagerKernel*>(kernel);
#ifndef G4MULTITHREADED
  G4ExceptionDescription msg;
  msg << "Geant4 code is compiled without multi-threading support"
      << "(-DG4MULTITHREADED is set to off).\n";
  msg << "G4MTRunManager can only be used in multi-threaded applications.";
  G4Exception("G4MTRunManager::G4MTRunManager", "Run0111", FatalException, msg);
#endif
 
  G4int numberOfStaticAllocators = kernel->GetNumberOfStaticAllocators();
  if (numberOfStaticAllocators > 0) {
    G4ExceptionDescription msg1;
    msg1 << "There are " << numberOfStaticAllocators << " static G4Allocator objects detected.\n"
         << "In multi-threaded mode, all G4Allocator objects must be dynamically "
            "instantiated.";
    G4Exception("G4MTRunManager::G4MTRunManager", "Run1035", FatalException, msg1);
  }
  G4UImanager::GetUIpointer()->SetMasterUIManager(true);
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
 
  // Check if a default RandomNumberGenerator has been created by user,
  // if not create default one
  // Note this call forces creation of defaults if not already there
  // G4Random::getTheEngine(); //User did not specify RNG, create defaults
  // Now remember the master instance of the RNG Engine
  masterRNGEngine = G4Random::getTheEngine();
 
  randDbl = new G4double[nSeedsPerEvent * nSeedsMax];
 
  char* env = std::getenv("G4FORCENUMBEROFTHREADS");
  if (env != nullptr) {
    G4String envS = env;
    if (envS == "MAX" || envS == "max") {
      forcedNwokers = G4Threading::G4GetNumberOfCores();
    }
    else {
      std::istringstream is(env);
      G4int val = -1;
      is >> val;
      if (val > 0) {
        forcedNwokers = val;
      }
      else {
        G4ExceptionDescription msg2;
        msg2 << "Environment variable G4FORCENUMBEROFTHREADS has an invalid "
                "value <"
             << envS << ">. It has to be an integer or a word \"max\".\n"
             << "G4FORCENUMBEROFTHREADS is ignored.";
        G4Exception("G4MTRunManager::G4MTRunManager", "Run1039", JustWarning, msg2);
      }
    }
    if (forcedNwokers > 0) {
      nworkers = forcedNwokers;
      if (verboseLevel > 0) {
        G4cout << "### Number of threads is forced to " << forcedNwokers
               << " by Environment variable G4FORCENUMBEROFTHREADS." << G4endl;
      }
    }
  }
}
 
// --------------------------------------------------------------------
G4MTRunManager::~G4MTRunManager()
{
  // TODO: Currently does not work due to concurrent deletion of something
  //      that is shared:
  // G4ProcessTable::DeleteMessenger from ~G4RunManager
  // G4cout<<"Destroy MTRunManager"<<G4endl;//ANDREA
  TerminateWorkers();
  delete[] randDbl;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::StoreRNGStatus(const G4String& fn)
{
  std::ostringstream os;
  os << randomNumberStatusDir << "G4Master_" << fn << ".rndm";
  G4Random::saveEngineStatus(os.str().c_str());
}
 
// --------------------------------------------------------------------
void G4MTRunManager::rndmSaveThisRun()
{
  G4int runNumber = 0;
  if (currentRun != nullptr) runNumber = currentRun->GetRunID();
  if (!storeRandomNumberStatus) {
    G4cerr << "Warning from G4RunManager::rndmSaveThisRun():"
           << " Random number status was not stored prior to this run." << G4endl
           << "/random/setSavingFlag command must be issued. "
           << "Command ignored." << G4endl;
    return;
  }
 
  G4fs::path fileIn = randomNumberStatusDir + "G4Worker_currentRun.rndm";
 
  std::ostringstream os;
  os << "run" << runNumber << ".rndm" << '\0';
  G4fs::path fileOut = randomNumberStatusDir + os.str();
 
  if (G4CopyRandomState(fileIn, fileOut, "G4MTRunManager::rndmSaveThisRun()") && verboseLevel > 0)
  {
    G4cout << fileIn << " is copied to " << fileOut << G4endl;
  } 
}
 
// --------------------------------------------------------------------
void G4MTRunManager::rndmSaveThisEvent()
{
  G4Exception("G4MTRunManager::rndmSaveThisEvent", "RUN_RNDM001", FatalException,
              "This method shall not be invoked !!");
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetNumberOfThreads(G4int n)
{
  if (!threads.empty()) {
    G4ExceptionDescription msg;
    msg << "Number of threads cannot be changed at this moment \n"
        << "(old threads are still alive). Method ignored.";
    G4Exception("G4MTRunManager::SetNumberOfThreads(G4int)", "Run0112", JustWarning, msg);
  }
  else if (forcedNwokers > 0) {
    G4ExceptionDescription msg;
    msg << "Number of threads is forced to " << forcedNwokers
        << " by G4FORCENUMBEROFTHREADS shell variable.\n"
        << "Method ignored.";
    G4Exception("G4MTRunManager::SetNumberOfThreads(G4int)", "Run0113", JustWarning, msg);
  }
  else {
    nworkers = n;
  }
}
 
// --------------------------------------------------------------------
void G4MTRunManager::Initialize()
{
  G4RunManager::Initialize();
 
  // make sure all worker threads are set up.
  BeamOn(0);
  SetRunIDCounter(0);
}
 
// --------------------------------------------------------------------
void G4MTRunManager::ProcessOneEvent(G4int)
{
  // Nothing to do
}
 
// --------------------------------------------------------------------
void G4MTRunManager::TerminateOneEvent()
{
  // Nothing to do
}
 
// --------------------------------------------------------------------
void G4MTRunManager::PrepareCommandsStack()
{
  G4AutoLock l(&cmdHandlingMutex);
  uiCmdsForWorkers.clear();
  std::vector<G4String>* cmdCopy = G4UImanager::GetUIpointer()->GetCommandStack();
  for (const auto& it : *cmdCopy)
    uiCmdsForWorkers.push_back(it);
  cmdCopy->clear();
  delete cmdCopy;
}
 
// --------------------------------------------------------------------
std::vector<G4String> G4MTRunManager::GetCommandStack()
{
  G4AutoLock l(&cmdHandlingMutex);
  return uiCmdsForWorkers;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::CreateAndStartWorkers()
{
  // Now loop on requested number of workers
  // This will also start the workers
  // Currently we do not allow to change the
  // number of threads: threads area created once
  if (threads.empty()) {
    if (verboseLevel > 0) {
      // for consistency with G4TaskRunManager
      std::stringstream msg;
      msg << "--> G4MTRunManager::CreateAndStartWorkers() --> "
          << "Initializing workers...";
 
      std::stringstream ss;
      ss.fill('=');
      ss << std::setw(G4int(msg.str().length())) << "";
      G4cout << "\n" << ss.str() << "\n" << msg.str() << "\n" << ss.str() << "\n" << G4endl;
    }
 
    for (G4int nw = 0; nw < nworkers; ++nw) {
      // Create a new worker and remember it
      auto context = new G4WorkerThread;
      context->SetNumberThreads(nworkers);
      context->SetThreadId(nw);
      G4Thread* thread = userWorkerThreadInitialization->CreateAndStartWorker(context);
      threads.push_back(thread);
    }
  }
  // Signal to threads they can start a new run
  NewActionRequest(WorkerActionRequest::NEXTITERATION);
}
 
// --------------------------------------------------------------------
void G4MTRunManager::InitializeEventLoop(G4int n_event, const char* macroFile, G4int n_select)
{
  MTkernel->SetUpDecayChannels();
  numberOfEventToBeProcessed = n_event;
  numberOfEventProcessed = 0;
 
  if (!fakeRun) {
    nSeedsUsed = 0;
    nSeedsFilled = 0;
 
    if (verboseLevel > 0) {
      timer->Start();
    }
 
    n_select_msg = n_select;
    if (macroFile != nullptr) {
      if (n_select_msg < 0) n_select_msg = n_event;
      msgText = "/control/execute ";
      msgText += macroFile;
      selectMacro = macroFile;
    }
    else {
      n_select_msg = -1;
      selectMacro = "";
    }
 
    // initialize seeds
    // If user did not implement InitializeSeeds,
    // use default: nSeedsPerEvent seeds per event
    if (eventModuloDef > 0) {
      eventModulo = eventModuloDef;
      if (eventModulo > numberOfEventToBeProcessed / nworkers) {
        eventModulo = numberOfEventToBeProcessed / nworkers;
        if (eventModulo < 1) eventModulo = 1;
        G4ExceptionDescription msgd;
        msgd << "Event modulo is reduced to " << eventModulo
             << " to distribute events to all threads.";
        G4Exception("G4MTRunManager::InitializeEventLoop()", "Run10035", JustWarning, msgd);
      }
    }
    else {
      eventModulo = G4int(std::sqrt(G4double(numberOfEventToBeProcessed / nworkers)));
      if (eventModulo < 1) eventModulo = 1;
    }
    if (!InitializeSeeds(n_event) && n_event > 0) {
      G4RNGHelper* helper = G4RNGHelper::GetInstance();
      switch (seedOncePerCommunication) {
        case 0:
          nSeedsFilled = n_event;
          break;
        case 1:
          nSeedsFilled = nworkers;
          break;
        case 2:
          nSeedsFilled = n_event / eventModulo + 1;
          break;
        default:
          G4ExceptionDescription msgd;
          msgd << "Parameter value <" << seedOncePerCommunication
               << "> of seedOncePerCommunication is invalid. It is reset to 0.";
          G4Exception("G4MTRunManager::InitializeEventLoop()", "Run10036", JustWarning, msgd);
          seedOncePerCommunication = 0;
          nSeedsFilled = n_event;
      }
 
      // Generates up to nSeedsMax seed pairs only.
      if (nSeedsFilled > nSeedsMax) nSeedsFilled = nSeedsMax;
      masterRNGEngine->flatArray(nSeedsPerEvent * nSeedsFilled, randDbl);
      helper->Fill(randDbl, nSeedsFilled, n_event, nSeedsPerEvent);
    }
  }
 
  // Now initialize workers. Check if user defined a WorkerThreadInitialization
  if (userWorkerThreadInitialization == nullptr) {
    userWorkerThreadInitialization = new G4UserWorkerThreadInitialization();
  }
 
  // Prepare UI commands for threads
  PrepareCommandsStack();
 
  // Start worker threads
  CreateAndStartWorkers();
 
  // We need a barrier here. Wait for workers to start event loop.
  // This will return only when all workers have started processing events.
  WaitForReadyWorkers();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::RefillSeeds()
{
  G4RNGHelper* helper = G4RNGHelper::GetInstance();
  G4int nFill = 0;
  switch (seedOncePerCommunication) {
    case 0:
      nFill = numberOfEventToBeProcessed - nSeedsFilled;
      break;
    case 1:
      nFill = nworkers - nSeedsFilled;
      break;
    case 2:
    default:
      nFill = (numberOfEventToBeProcessed - nSeedsFilled * eventModulo) / eventModulo + 1;
  }
  // Generates up to nSeedsMax seed pairs only.
  if (nFill > nSeedsMax) nFill = nSeedsMax;
  masterRNGEngine->flatArray(nSeedsPerEvent * nFill, randDbl);
  helper->Refill(randDbl, nFill);
  nSeedsFilled += nFill;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::RunTermination()
{
  // Wait for all worker threads to have finished the run
  // i.e. wait for them to return from RunTermination()
  // This guarantee that userrunaction for workers has been called
 
  // Wait now for all threads to finish event-loop
  WaitForEndEventLoopWorkers();
  // Now call base-class methof
  G4RunManager::TerminateEventLoop();
  G4RunManager::RunTermination();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::ConstructScoringWorlds()
{
  masterScM = G4ScoringManager::GetScoringManagerIfExist();
  // Call base class stuff...
  G4RunManager::ConstructScoringWorlds();
 
  masterWorlds.clear();
  auto nWorlds = (G4int)G4TransportationManager::GetTransportationManager()->GetNoWorlds();
  auto itrW = G4TransportationManager::GetTransportationManager()->GetWorldsIterator();
  for (G4int iWorld = 0; iWorld < nWorlds; ++iWorld) {
    addWorld(iWorld, *itrW);
    ++itrW;
  }
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserInitialization(G4UserWorkerInitialization* userInit)
{
  userWorkerInitialization = userInit;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserInitialization(G4UserWorkerThreadInitialization* userInit)
{
  userWorkerThreadInitialization = userInit;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserInitialization(G4VUserActionInitialization* userInit)
{
  userActionInitialization = userInit;
  userActionInitialization->BuildForMaster();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserInitialization(G4VUserPhysicsList* userPL)
{
  G4RunManager::SetUserInitialization(userPL);
  // Needed for MT, to be moved in kernel
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserInitialization(G4VUserDetectorConstruction* userDC)
{
  G4RunManager::SetUserInitialization(userDC);
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserAction(G4UserRunAction* userAction)
{
  G4RunManager::SetUserAction(userAction);
  if (userAction != nullptr) userAction->SetMaster();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserAction(G4VUserPrimaryGeneratorAction* /*userAction*/)
{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0123", FatalException,
              "For multi-threaded version, define G4VUserPrimaryGeneratorAction in "
              "G4VUserActionInitialization.");
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserAction(G4UserEventAction* /*userAction*/)
{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0124", FatalException,
              "For multi-threaded version, define G4UserEventAction in "
              "G4VUserActionInitialization.");
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserAction(G4UserStackingAction* /*userAction*/)
{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0125", FatalException,
              "For multi-threaded version, define G4UserStackingAction in "
              "G4VUserActionInitialization.");
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserAction(G4UserTrackingAction* /*userAction*/)
{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0126", FatalException,
              "For multi-threaded version, define G4UserTrackingAction in "
              "G4VUserActionInitialization.");
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetUserAction(G4UserSteppingAction* /*userAction*/)
{
  G4Exception("G4MTRunManager::SetUserAction()", "Run0127", FatalException,
              "For multi-threaded version, define G4UserSteppingAction in "
              "G4VUserActionInitialization.");
}
 
// --------------------------------------------------------------------
void G4MTRunManager::MergeScores(const G4ScoringManager* localScoringManager)
{
  G4AutoLock l(&scorerMergerMutex);
  if (masterScM != nullptr && localScoringManager != nullptr) masterScM->Merge(localScoringManager);
}
 
// --------------------------------------------------------------------
void G4MTRunManager::MergeRun(const G4Run* localRun)
{
  G4AutoLock l(&runMergerMutex);
  if (currentRun != nullptr && localRun != nullptr) currentRun->Merge(localRun);
}
 
// --------------------------------------------------------------------
G4bool G4MTRunManager::SetUpAnEvent(G4Event* evt, G4long& s1, G4long& s2, G4long& s3,
                                    G4bool reseedRequired)
{
  G4AutoLock l(&setUpEventMutex);
  if (numberOfEventProcessed < numberOfEventToBeProcessed) {
    evt->SetEventID(numberOfEventProcessed);
    if (reseedRequired) {
      G4RNGHelper* helper = G4RNGHelper::GetInstance();
      G4int idx_rndm = nSeedsPerEvent * nSeedsUsed;
      s1 = helper->GetSeed(idx_rndm);
      s2 = helper->GetSeed(idx_rndm + 1);
      if (nSeedsPerEvent == 3) s3 = helper->GetSeed(idx_rndm + 2);
      ++nSeedsUsed;
      if (nSeedsUsed == nSeedsFilled) RefillSeeds();
    }
    ++numberOfEventProcessed;
    return true;
  }
  return false;
}
 
// --------------------------------------------------------------------
G4int G4MTRunManager::SetUpNEvents(G4Event* evt, G4SeedsQueue* seedsQueue, G4bool reseedRequired)
{
  G4AutoLock l(&setUpEventMutex);
  if (numberOfEventProcessed < numberOfEventToBeProcessed && !runAborted) {
    G4int nev = eventModulo;
    if (numberOfEventProcessed + nev > numberOfEventToBeProcessed) {
      nev = numberOfEventToBeProcessed - numberOfEventProcessed;
    }
    evt->SetEventID(numberOfEventProcessed);
    if (reseedRequired) {
      G4RNGHelper* helper = G4RNGHelper::GetInstance();
      G4int nevRnd = nev;
      if (seedOncePerCommunication > 0) nevRnd = 1;
      for (G4int i = 0; i < nevRnd; ++i) {
        seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed));
        seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed + 1));
        if (nSeedsPerEvent == 3) seedsQueue->push(helper->GetSeed(nSeedsPerEvent * nSeedsUsed + 2));
        ++nSeedsUsed;
        if (nSeedsUsed == nSeedsFilled) RefillSeeds();
      }
    }
    numberOfEventProcessed += nev;
    return nev;
  }
  return 0;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::TerminateWorkers()
{
  // Force workers to execute (if any) all UI commands left in the stack
  RequestWorkersProcessCommandsStack();
  // Ask workers to exit
  NewActionRequest(WorkerActionRequest::ENDWORKER);
  // finalize profiler before shutting down the threads
  G4Profiler::Finalize();
  // Now join threads.
#ifdef G4MULTITHREADED  // protect here to prevent warning in compilation
  while (!threads.empty()) {
    G4Thread* t = *(threads.begin());
    threads.pop_front();
    userWorkerThreadInitialization->JoinWorker(t);
    delete t;
  }
#endif
  threads.clear();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::AbortRun(G4bool softAbort)
{
  // This method is valid only for GeomClosed or EventProc state
  G4ApplicationState currentState = G4StateManager::GetStateManager()->GetCurrentState();
  if (currentState == G4State_GeomClosed || currentState == G4State_EventProc) {
    runAborted = true;
    MTkernel->BroadcastAbortRun(softAbort);
  }
  else {
    G4cerr << "Run is not in progress. AbortRun() ignored." << G4endl;
  }
}
 
// --------------------------------------------------------------------
void G4MTRunManager::AbortEvent()
{
  // nothing to do in the master thread
}
 
// --------------------------------------------------------------------
void G4MTRunManager::WaitForReadyWorkers()
{
  beginOfEventLoopBarrier.Wait((G4int)GetNumberActiveThreads());
  endOfEventLoopBarrier.ResetCounter();
  beginOfEventLoopBarrier.ReleaseBarrier();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::ThisWorkerReady()
{
  beginOfEventLoopBarrier.ThisWorkerReady();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::WaitForEndEventLoopWorkers()
{
  endOfEventLoopBarrier.Wait((G4int)GetNumberActiveThreads());
  beginOfEventLoopBarrier.ResetCounter();
  endOfEventLoopBarrier.ReleaseBarrier();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::ThisWorkerEndEventLoop()
{
  endOfEventLoopBarrier.ThisWorkerReady();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::NewActionRequest(G4MTRunManager::WorkerActionRequest newRequest)
{
  nextActionRequestBarrier.Wait((G4int)GetNumberActiveThreads());
  // nextActionRequest is a shared resource, but there is no
  // data-race thanks to the barrier: all threads are waiting
  nextActionRequest = newRequest;
  nextActionRequestBarrier.ReleaseBarrier();
}
 
// --------------------------------------------------------------------
G4MTRunManager::WorkerActionRequest G4MTRunManager::ThisWorkerWaitForNextAction()
{
  nextActionRequestBarrier.ThisWorkerReady();
  return nextActionRequest;
}
 
// --------------------------------------------------------------------
void G4MTRunManager::RequestWorkersProcessCommandsStack()
{
  PrepareCommandsStack();
  NewActionRequest(WorkerActionRequest::PROCESSUI);
  processUIBarrier.SetActiveThreads((G4int)GetNumberActiveThreads());
  processUIBarrier.WaitForReadyWorkers();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::ThisWorkerProcessCommandsStackDone()
{
  processUIBarrier.ThisWorkerReady();
}
 
// --------------------------------------------------------------------
void G4MTRunManager::SetPinAffinity(G4int n)
{
  if (n == 0) {
    G4Exception("G4MTRunManager::SetPinAffinity", "Run0114", FatalException,
                "Pin affinity must be >0 or <0.");
  }
  pinAffinity = n;
  return;
}