#include <G4MTRunManager.hh>

Inheritance diagram for G4MTRunManager:

Public Types
enum	WorkerActionRequest { UNDEFINED, NEXTITERATION, ENDWORKER }

typedef std::map< G4int, G4VPhysicalVolume * >	masterWorlds_t

Public Types inherited from G4RunManager
enum	RMType { sequentialRM, masterRM, workerRM }

Public Member Functions
	G4MTRunManager ()

virtual	~G4MTRunManager ()

void	SetNumberOfThreads (G4int n)

G4int	GetNumberOfThreads () const

virtual void	Initialize ()

virtual void	InitializeEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)

virtual void	TerminateOneEvent ()

virtual void	ProcessOneEvent (G4int i_event)

virtual void	TerminateEventLoop ()

virtual void	ConstructScoringWorlds ()

virtual void	InitializePhysics ()

virtual void	RunTermination ()

virtual G4bool	SetUpAnEvent (G4Event *, long &s1, long &s2, long &s3)

virtual G4int	SetUpNEvents (G4Event , G4SeedsQueue seedsQueue)

std::vector< G4String >	GetCommandStack ()

virtual void	ThisWorkerReady ()

virtual void	ThisWorkerEndEventLoop ()

const CLHEP::HepRandomEngine *	getMasterRandomEngine () const

virtual void	SetUserInitialization (G4VUserPhysicsList *userPL)

virtual void	SetUserInitialization (G4VUserDetectorConstruction *userDC)

virtual void	SetUserInitialization (G4UserWorkerInitialization *userInit)

virtual void	SetUserInitialization (G4UserWorkerThreadInitialization *userInit)

virtual void	SetUserInitialization (G4VUserActionInitialization *userInit)

virtual void	SetUserAction (G4UserRunAction *userAction)

virtual void	SetUserAction (G4VUserPrimaryGeneratorAction *userAction)

virtual void	SetUserAction (G4UserEventAction *userAction)

virtual void	SetUserAction (G4UserStackingAction *userAction)

virtual void	SetUserAction (G4UserTrackingAction *userAction)

virtual void	SetUserAction (G4UserSteppingAction *userAction)

void	MergeScores (const G4ScoringManager *localScoringManager)

void	MergeRun (const G4Run *localRun)

virtual WorkerActionRequest	ThisWorkerWaitForNextAction ()

void	SetEventModulo (G4int i=1)

G4int	GetEventModulo () const

virtual void	AbortRun (G4bool softAbort=false)

virtual void	AbortEvent ()

Public Member Functions inherited from G4RunManager
	G4RunManager ()

virtual	~G4RunManager ()

virtual void	BeamOn (G4int n_event, const char *macroFile=0, G4int n_select=-1)

virtual void	DefineWorldVolume (G4VPhysicalVolume *worldVol, G4bool topologyIsChanged=true)

virtual void	InitializeGeometry ()

virtual G4bool	ConfirmBeamOnCondition ()

virtual void	RunInitialization ()

virtual void	DoEventLoop (G4int n_event, const char *macroFile=0, G4int n_select=-1)

virtual G4Event *	GenerateEvent (G4int i_event)

virtual void	AnalyzeEvent (G4Event *anEvent)

void	DumpRegion (const G4String &rname) const

void	DumpRegion (G4Region *region=0) const

virtual void	rndmSaveThisRun ()

virtual void	rndmSaveThisEvent ()

virtual void	RestoreRandomNumberStatus (const G4String &fileN)

const G4VUserDetectorConstruction *	GetUserDetectorConstruction () const

const G4VUserPhysicsList *	GetUserPhysicsList () const

const G4VUserActionInitialization *	GetUserActionInitialization () const

G4VUserActionInitialization *	GetNonConstUserActionInitialization () const

const G4UserWorkerInitialization *	GetUserWorkerInitialization () const

const G4UserWorkerThreadInitialization *	GetUserWorkerThreadInitialization () const

const G4UserRunAction *	GetUserRunAction () const

const G4VUserPrimaryGeneratorAction *	GetUserPrimaryGeneratorAction () const

const G4UserEventAction *	GetUserEventAction () const

const G4UserStackingAction *	GetUserStackingAction () const

const G4UserTrackingAction *	GetUserTrackingAction () const

const G4UserSteppingAction *	GetUserSteppingAction () const

void	SetNumberOfAdditionalWaitingStacks (G4int iAdd)

const G4String &	GetVersionString () const

void	SetPrimaryTransformer (G4PrimaryTransformer *pt)

void	StoreRandomNumberStatusToG4Event (G4int vl)

G4int	GetFlagRandomNumberStatusToG4Event () const

void	SetRandomNumberStore (G4bool flag)

G4bool	GetRandomNumberStore () const

void	SetRandomNumberStoreDir (const G4String &dir)

const G4String &	GetRandomNumberStoreDir () const

const G4String &	GetRandomNumberStatusForThisRun () const

const G4String &	GetRandomNumberStatusForThisEvent () const

void	SetRandomNumberStorePerEvent (G4bool flag)

G4bool	GetRandomNumberStorePerEvent () const

void	GeometryHasBeenModified (G4bool prop=true)

void	ReinitializeGeometry (G4bool destroyFirst=false, G4bool prop=true)

void	PhysicsHasBeenModified ()

void	CutOffHasBeenModified ()

void	ReOptimizeMotherOf (G4VPhysicalVolume *)

void	ReOptimize (G4LogicalVolume *)

void	SetVerboseLevel (G4int vl)

G4int	GetVerboseLevel () const

G4int	GetPrintProgress ()

void	SetPrintProgress (G4int i)

void	SetGeometryToBeOptimized (G4bool vl)

G4bool	GetGeometryToBeOptimized ()

void	SetNumberOfEventsToBeStored (G4int val)

const G4Run *	GetCurrentRun () const

G4Run *	GetNonConstCurrentRun () const

const G4Event *	GetCurrentEvent () const

const G4Event *	GetPreviousEvent (G4int i) const

void	SetRunIDCounter (G4int i)

G4int	GetNumberOfParallelWorld () const

void	SetNumberOfEventsToBeProcessed (G4int val)

G4int	GetNumberOfEventsToBeProcessed () const

G4int	GetNumberOfSelectEvents () const

G4String	GetSelectMacro () const

void	SetDCtable (G4DCtable *DCtbl)

RMType	GetRunManagerType () const

Static Public Member Functions
static G4ScoringManager *	GetMasterScoringManager ()

static masterWorlds_t &	GetMasterWorlds ()

static void	addWorld (G4int counter, G4VPhysicalVolume *w)

static G4MTRunManager *	GetMasterRunManager ()

static G4RunManagerKernel *	GetMasterRunManagerKernel ()

static G4MTRunManagerKernel *	GetMTMasterRunManagerKernel ()

Static Public Member Functions inherited from G4RunManager
static G4RunManager *	GetRunManager ()

Protected Member Functions
virtual G4bool	InitializeSeeds (G4int)

virtual void	PrepareCommandsStack ()

virtual void	StoreRNGStatus (const G4String &filenamePrefix)

virtual void	CreateAndStartWorkers ()

virtual void	WaitForReadyWorkers ()

virtual void	WaitForEndEventLoopWorkers ()

virtual void	TerminateWorkers ()

virtual void	NewActionRequest (WorkerActionRequest newRequest)

void	RefillSeeds ()

Protected Member Functions inherited from G4RunManager
void	StackPreviousEvent (G4Event *anEvent)

	G4RunManager (RMType rmType)

void	UpdateScoring ()

virtual void	DeleteUserInitializations ()

Protected Attributes
G4int	numberOfEventToBeProcessed

WorkerActionRequest	nextActionRequest

G4int	eventModuloDef

G4int	eventModulo

G4int	nSeedsUsed

G4int	nSeedsFilled

G4int	nSeedsMax

G4int	nSeedsPerEvent

double *	randDbl

Protected Attributes inherited from G4RunManager
G4RunManagerKernel *	kernel

G4EventManager *	eventManager

G4VUserDetectorConstruction *	userDetector

G4VUserPhysicsList *	physicsList

G4VUserActionInitialization *	userActionInitialization

G4UserWorkerInitialization *	userWorkerInitialization

G4UserWorkerThreadInitialization *	userWorkerThreadInitialization

G4UserRunAction *	userRunAction

G4VUserPrimaryGeneratorAction *	userPrimaryGeneratorAction

G4UserEventAction *	userEventAction

G4UserStackingAction *	userStackingAction

G4UserTrackingAction *	userTrackingAction

G4UserSteppingAction *	userSteppingAction

G4bool	geometryInitialized

G4bool	physicsInitialized

G4bool	runAborted

G4bool	initializedAtLeastOnce

G4bool	geometryToBeOptimized

G4int	runIDCounter

G4int	verboseLevel

G4int	printModulo

G4Timer *	timer

G4DCtable *	DCtable

G4Run *	currentRun

G4Event *	currentEvent

std::vector< G4Event * > *	previousEvents

G4int	n_perviousEventsToBeStored

G4int	numberOfEventToBeProcessed

G4bool	storeRandomNumberStatus

G4int	storeRandomNumberStatusToG4Event

G4String	randomNumberStatusDir

G4String	randomNumberStatusForThisRun

G4String	randomNumberStatusForThisEvent

G4bool	rngStatusEventsFlag

G4VPhysicalVolume *	currentWorld

G4int	nParallelWorlds

G4String	msgText

G4int	n_select_msg

G4int	numberOfEventProcessed

G4String	selectMacro

G4bool	fakeRun

RMType	runManagerType

Detailed Description

Definition at line 50 of file G4MTRunManager.hh.

Member Typedef Documentation

typedef std::map<G4int,G4VPhysicalVolume*> G4MTRunManager::masterWorlds_t

Definition at line 149 of file G4MTRunManager.hh.

Member Enumeration Documentation

enum G4MTRunManager::WorkerActionRequest

Enumerator
UNDEFINED
NEXTITERATION
ENDWORKER

Definition at line 188 of file G4MTRunManager.hh.

                              {
         UNDEFINED ,
         NEXTITERATION ,    // There is another set of UI commands to be executed
         ENDWORKER          // Terminate thread, work finished
     };

Constructor & Destructor Documentation

G4MTRunManager::G4MTRunManager ( )

Definition at line 83 of file G4MTRunManager.cc.

References FatalException, G4cout, G4endl, G4Exception(), G4Threading::G4GetNumberOfCores(), G4RunManagerKernel::GetNumberOfStaticAllocators(), G4ScoringManager::GetScoringManagerIfExist(), G4UImanager::GetUIpointer(), JustWarning, G4RunManager::kernel, nSeedsMax, nSeedsPerEvent, numberOfEventToBeProcessed, randDbl, and G4UImanager::SetMasterUIManager().

                                : G4RunManager(masterRM),
     nworkers(2),forcedNwokers(-1),
     masterRNGEngine(0),
     nextActionRequest(UNDEFINED),
     eventModuloDef(0),eventModulo(1),
     nSeedsUsed(0),nSeedsFilled(0),
     nSeedsMax(10000),nSeedsPerEvent(2)
 {
     if ( fMasterRM )
     {
         G4Exception("G4MTRunManager::G4MTRunManager", "Run0035",FatalException,
                     "Another instance of a G4MTRunManager already exists.");
     }
     fMasterRM = this;
     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","Run0035",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 dynamicly 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();
 #if defined (WIN32)
     InitializeWindowsConditions();
 #endif
 
     numberOfEventToBeProcessed = 0;
     randDbl = new double[nSeedsPerEvent*nSeedsMax];
 
     char* env = getenv("G4FORCENUMBEROFTHREADS");
     if(env)
     {
       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;
         G4cout << "### Number of threads is forced to " << forcedNwokers 
                << " by Environment variable G4FORCENUMBEROFTHREADS." << G4endl;
       }
     }
 }

G4MTRunManager::~G4MTRunManager ( )

virtual

Definition at line 162 of file G4MTRunManager.cc.

References randDbl, and TerminateWorkers().

 {
     //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;
 }

Member Function Documentation

void G4MTRunManager::AbortEvent ( )

virtual

Reimplemented from G4RunManager.

Definition at line 546 of file G4MTRunManager.cc.

 {
   // nothing to do in the master thread
 }

void G4MTRunManager::AbortRun ( G4bool softAbort = false )

virtual

Reimplemented from G4RunManager.

Definition at line 530 of file G4MTRunManager.cc.

References G4MTRunManagerKernel::BroadcastAbortRun(), G4cerr, G4endl, G4State_EventProc, G4State_GeomClosed, G4StateManager::GetCurrentState(), G4StateManager::GetStateManager(), and G4RunManager::runAborted.

 {
   // 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;
   }
 }

static void G4MTRunManager::addWorld	(	G4int	counter,
		G4VPhysicalVolume *	w
	)

inlinestatic

Definition at line 152 of file G4MTRunManager.hh.

Referenced by ConstructScoringWorlds().

152 { masterWorlds.insert( std::make_pair(counter,w) ); }

void G4MTRunManager::ConstructScoringWorlds ( )

virtual

Reimplemented from G4RunManager.

Definition at line 366 of file G4MTRunManager.cc.

References addWorld(), G4RunManager::ConstructScoringWorlds(), G4TransportationManager::GetNoWorlds(), G4ScoringManager::GetScoringManagerIfExist(), G4TransportationManager::GetTransportationManager(), and G4TransportationManager::GetWorldsIterator().

 {
     masterScM = G4ScoringManager::GetScoringManagerIfExist();
     //Call base class stuff...
     G4RunManager::ConstructScoringWorlds();
     
     masterWorlds.clear();
     size_t nWorlds = G4TransportationManager::GetTransportationManager()->GetNoWorlds();
     std::vector<G4VPhysicalVolume*>::iterator itrW
                    = G4TransportationManager::GetTransportationManager()->GetWorldsIterator();
     for(size_t iWorld=0;iWorld<nWorlds;iWorld++)
     {
       addWorld(iWorld,*itrW); 
       itrW++;
     }
 }

void G4MTRunManager::CreateAndStartWorkers ( )

protectedvirtual

Reimplemented in tbbMasterRunManager.

Definition at line 244 of file G4MTRunManager.cc.

References G4UserWorkerThreadInitialization::CreateAndStartWorker(), NewActionRequest(), NEXTITERATION, G4WorkerThread::SetNumberThreads(), G4WorkerThread::SetThreadId(), and G4RunManager::userWorkerThreadInitialization.

Referenced by InitializeEventLoop().

 {
     //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.size() == 0 ) {
         for ( G4int nw = 0 ; nw<nworkers; ++nw) {
             //Create a new worker and remember it
             G4WorkerThread* 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(NEXTITERATION);
 }

std::vector< G4String > G4MTRunManager::GetCommandStack ( )

Definition at line 238 of file G4MTRunManager.cc.

Referenced by tbbTask::execute(), and G4MTRunManagerKernel::StartThread().

 {
     G4AutoLock l(&cmdHandlingMutex);
     return uiCmdsForWorkers;
 }

G4int G4MTRunManager::GetEventModulo ( ) const

inline

Definition at line 217 of file G4MTRunManager.hh.

References eventModuloDef.

Referenced by G4WorkerRunManager::GenerateEvent().

217 { return eventModuloDef; }

G4MTRunManager::eventModuloDef

G4int eventModuloDef

Definition: G4MTRunManager.hh:205

const CLHEP::HepRandomEngine* G4MTRunManager::getMasterRandomEngine ( ) const

inline

Definition at line 153 of file G4MTRunManager.hh.

Referenced by tbbTask::execute(), and G4MTRunManagerKernel::StartThread().

153 { return masterRNGEngine; }

G4MTRunManager * G4MTRunManager::GetMasterRunManager ( )

static

Definition at line 64 of file G4MTRunManager.cc.

Referenced by G4TheMTRayTracer::CreateBitMap(), tbbTask::execute(), G4WorkerRunManager::GenerateEvent(), G4WorkerRunManager::MergePartialResults(), G4TheMTRayTracer::RestoreUserActions(), G4WorkerRunManager::RunInitialization(), G4WorkerRunManager::RunTermination(), G4MTRunManagerKernel::StartThread(), G4TheMTRayTracer::StoreUserActions(), G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

 {
 ////////#ifdef G4MULTITHREADED
     return fMasterRM;
 ////////#else
 ////////    return G4RunManager::GetRunManager();
 ////////#endif
 }

G4RunManagerKernel * G4MTRunManager::GetMasterRunManagerKernel ( )

static

Definition at line 73 of file G4MTRunManager.cc.

References G4RunManager::kernel.

Referenced by G4WorkerRunManager::InitializeGeometry().

 {
     return fMasterRM->kernel;
 }

static G4ScoringManager* G4MTRunManager::GetMasterScoringManager ( )

inlinestatic

Definition at line 150 of file G4MTRunManager.hh.

Referenced by G4WorkerRunManager::ConstructScoringWorlds(), and G4WorkerRunManager::G4WorkerRunManager().

150 { return masterScM; }

static masterWorlds_t& G4MTRunManager::GetMasterWorlds ( )

inlinestatic

Definition at line 151 of file G4MTRunManager.hh.

Referenced by G4RunManagerKernel::WorkerDefineWorldVolume(), and G4RunManagerKernel::WorkerUpdateWorldVolume().

151 { return masterWorlds; }

G4MTRunManagerKernel * G4MTRunManager::GetMTMasterRunManagerKernel ( )

static

Definition at line 78 of file G4MTRunManager.cc.

 {
     return fMasterRM->MTkernel;
 }

G4int G4MTRunManager::GetNumberOfThreads ( ) const

inline

Definition at line 56 of file G4MTRunManager.hh.

Referenced by main().

56 { return nworkers; }

void G4MTRunManager::Initialize ( void )

virtual

G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);

Reimplemented from G4RunManager.

Definition at line 204 of file G4MTRunManager.cc.

References G4RunManager::BeamOn(), G4RunManager::Initialize(), and G4RunManager::SetRunIDCounter().

Referenced by main().

 {
     G4RunManager::Initialize();
 
     // make sure all worker threads are set up.
     BeamOn(0);
     SetRunIDCounter(0);
     ///G4UImanager::GetUIpointer()->SetIgnoreCmdNotFound(true);
 }

void G4MTRunManager::InitializeEventLoop	(	G4int	n_event,
		const char *	macroFile = `0`,
		G4int	n_select = `-1`
	)

virtual

Reimplemented from G4RunManager.

Definition at line 265 of file G4MTRunManager.cc.

References CreateAndStartWorkers(), eventModulo, eventModuloDef, G4RunManager::fakeRun, G4TemplateRNGHelper< T >::Fill(), CLHEP::HepRandomEngine::flatArray(), G4Exception(), G4TemplateRNGHelper< T >::GetInstance(), InitializeSeeds(), int(), JustWarning, G4RunManager::msgText, G4RunManager::n_select_msg, nSeedsFilled, nSeedsMax, nSeedsPerEvent, nSeedsUsed, G4RunManager::numberOfEventProcessed, numberOfEventToBeProcessed, PrepareCommandsStack(), randDbl, G4RunManager::selectMacro, G4MTRunManagerKernel::SetUpDecayChannels(), G4Timer::Start(), G4RunManager::timer, G4RunManager::userWorkerThreadInitialization, G4RunManager::verboseLevel, and WaitForReadyWorkers().

 {
   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!=0)
     {
         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 = int(std::sqrt(double(numberOfEventToBeProcessed/nworkers)));
       if(eventModulo<1) eventModulo =1;
     }
     if ( InitializeSeeds(n_event) == false && n_event>0 )
     {
         G4RNGHelper* helper = G4RNGHelper::GetInstance();
         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 == 0 )
   { 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::InitializePhysics ( )

virtual

Reimplemented from G4RunManager.

Definition at line 523 of file G4MTRunManager.cc.

References G4CascadeInterface::Initialize(), and G4RunManager::InitializePhysics().

 {
     G4RunManager::InitializePhysics();
     //BERTINI, this is needed to create pseudo-particles, to be removed
     G4CascadeInterface::Initialize();
 }

virtual G4bool G4MTRunManager::InitializeSeeds ( G4int )

inlineprotectedvirtual

Definition at line 90 of file G4MTRunManager.hh.

Referenced by InitializeEventLoop().

90 { return false; };

void G4MTRunManager::MergeRun ( const G4Run * localRun )

Definition at line 452 of file G4MTRunManager.cc.

References G4RunManager::currentRun, and G4Run::Merge().

Referenced by G4WorkerRunManager::MergePartialResults().

 {
   G4AutoLock l(&runMergerMutex);
   if(currentRun) currentRun->Merge(localRun); 
 }

void G4MTRunManager::MergeScores ( const G4ScoringManager * localScoringManager )

Definition at line 446 of file G4MTRunManager.cc.

References G4ScoringManager::Merge().

Referenced by G4WorkerRunManager::MergePartialResults().

 {
   G4AutoLock l(&scorerMergerMutex);
   if(masterScM) masterScM->Merge(localScoringManager); 
 }

void G4MTRunManager::NewActionRequest ( G4MTRunManager::WorkerActionRequest newRequest )

protectedvirtual

Reimplemented in tbbMasterRunManager.

Definition at line 800 of file G4MTRunManager.cc.

References G4CONDITIONWAIT, G4CONDTIONBROADCAST, nextActionRequest, and G4TemplateAutoLock< M, L, U >::unlock().

Referenced by CreateAndStartWorkers(), and TerminateWorkers().

 {
   //Wait for all workers to be ready to accept a new action request
   while (true)
   {
 #ifndef WIN32
     G4AutoLock l(&numberOfReadyWorkersForNewActionMutex);
 #else
     EnterCriticalSection( &cs3 );
 #endif
     //Check the number of workers that are ready for next action
     G4int activethreads = threads.size();
     if ( numberOfReadyWorkersForNewAction == activethreads )
     {
     //Ok, exit the loop
     break;
     }
     //Wait for the number of workers ready for new action to change
 #ifdef WIN32
     G4CONDITIONWAIT(&numberOfReadyWorkersForNewActionChangedCondition,
             &cs3);
     LeaveCriticalSection( &cs3 );
 #else
     G4CONDITIONWAIT(&numberOfReadyWorkersForNewActionChangedCondition,
             &numberOfReadyWorkersForNewActionMutex);
 #endif 
   }
   //Now set the new action to the shared resource
   G4AutoLock l(&nextActionRequestMutex);
   nextActionRequest = newRequest;
   l.unlock();
   //Reset counter of workers ready-for-new-action in preparation of next call
   G4AutoLock l2(&numberOfReadyWorkersForNewActionMutex);
   numberOfReadyWorkersForNewAction = 0;
   //l2.unlock(); //<----- This thread needs to have control on mutex associated
   //to condition variable (report from valgrind --tool=drd)
   //see: http://pic.dhe.ibm.com/infocenter/iseries/v7r1m0/index.jsp?topic=%2Fapis%2Fusers_73.htm
   //Now signal all workers that there is a new action to be performed
   G4CONDTIONBROADCAST(&requestChangeActionForWorker);
 }

void G4MTRunManager::PrepareCommandsStack ( )

protectedvirtual

Definition at line 227 of file G4MTRunManager.cc.

References G4UImanager::GetCommandStack(), and G4UImanager::GetUIpointer().

Referenced by InitializeEventLoop().

                                           {
     G4AutoLock l(&cmdHandlingMutex);
     uiCmdsForWorkers.clear();
     std::vector<G4String>* cmdCopy = G4UImanager::GetUIpointer()->GetCommandStack();
     for ( std::vector<G4String>::const_iterator it = cmdCopy->begin() ;
          it != cmdCopy->end(); ++it )
         uiCmdsForWorkers.push_back(*it);
     cmdCopy->clear();
     delete cmdCopy;
 }

void G4MTRunManager::ProcessOneEvent ( G4int i_event )

virtual

Reimplemented from G4RunManager.

Definition at line 218 of file G4MTRunManager.cc.

 {
     //Nothing to do
 }

void G4MTRunManager::RefillSeeds ( )

protected

Definition at line 341 of file G4MTRunManager.cc.

References CLHEP::HepRandomEngine::flatArray(), G4TemplateRNGHelper< T >::GetInstance(), nSeedsFilled, nSeedsMax, nSeedsPerEvent, numberOfEventToBeProcessed, randDbl, and G4TemplateRNGHelper< T >::Refill().

Referenced by SetUpAnEvent(), and SetUpNEvents().

 {
   G4RNGHelper* helper = G4RNGHelper::GetInstance();
   G4int nFill = numberOfEventToBeProcessed - nSeedsFilled;
   // Generates up to nSeedsMax seed pairs only.
   if(nFill>nSeedsMax) nFill=nSeedsMax;
   masterRNGEngine->flatArray(nSeedsPerEvent*nFill,randDbl); 
   helper->Refill(randDbl,nFill);
   nSeedsFilled += nFill;
 //G4cout<<"helper->Refill() for "<<nFill<<" events."<<G4endl;
 }

void G4MTRunManager::RunTermination ( )

virtual

Reimplemented from G4RunManager.

Reimplemented in tbbMasterRunManager.

Definition at line 353 of file G4MTRunManager.cc.

References G4RunManager::RunTermination(), and WaitForEndEventLoopWorkers().

Referenced by tbbMasterRunManager::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::RunTermination();
 }

void G4MTRunManager::SetEventModulo ( G4int i = 1 )

inline

Definition at line 216 of file G4MTRunManager.hh.

References eventModuloDef.

216 { eventModuloDef = i; }

G4MTRunManager::eventModuloDef

G4int eventModuloDef

Definition: G4MTRunManager.hh:205

void G4MTRunManager::SetNumberOfThreads ( G4int n )

Definition at line 179 of file G4MTRunManager.cc.

References G4Exception(), JustWarning, and n.

Referenced by main().

 {
     if ( threads.size() != 0 )
     {
       G4ExceptionDescription msg;
       msg << "Number of threads cannot be changed at this moment \n"
           << "(old threads are still alive). Method ignored.";
       G4Exception("G4MTRunManager::SetNumberOfThreads(G4int)",
                   "Run0035", JustWarning, msg);
     }
     else if ( forcedNwokers > 0 )
     {
       G4ExceptionDescription msg;
       msg << "Number of threads is forced to " << forcedNwokers
           << " by G4FORCENUMBEROFWORKERS shell variable.\n"
           << "Method ignored.";
       G4Exception("G4MTRunManager::SetNumberOfThreads(G4int)",
                   "Run0035", JustWarning, msg);
     }
     else  
     {
       nworkers = n;
     }
 }

G4bool G4MTRunManager::SetUpAnEvent	(	G4Event *	evt,
		long &	s1,
		long &	s2,
		long &	s3
	)

virtual

Definition at line 458 of file G4MTRunManager.cc.

References G4TemplateRNGHelper< T >::GetInstance(), G4TemplateRNGHelper< T >::GetSeed(), nSeedsFilled, nSeedsPerEvent, nSeedsUsed, G4RunManager::numberOfEventProcessed, numberOfEventToBeProcessed, RefillSeeds(), and G4Event::SetEventID().

Referenced by G4WorkerRunManager::GenerateEvent().

 {
   G4AutoLock l(&setUpEventMutex);
   if( numberOfEventProcessed < numberOfEventToBeProcessed )
   {
     evt->SetEventID(numberOfEventProcessed);
     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);
     numberOfEventProcessed++;
     nSeedsUsed++;
     if(nSeedsUsed==nSeedsFilled) RefillSeeds();
     return true;
   }
   return false;
 }

G4int G4MTRunManager::SetUpNEvents	(	G4Event *	evt,
		G4SeedsQueue *	seedsQueue
	)

virtual

Definition at line 477 of file G4MTRunManager.cc.

References eventModulo, G4TemplateRNGHelper< T >::GetInstance(), G4TemplateRNGHelper< T >::GetSeed(), nSeedsFilled, nSeedsPerEvent, nSeedsUsed, G4RunManager::numberOfEventProcessed, numberOfEventToBeProcessed, RefillSeeds(), G4RunManager::runAborted, and G4Event::SetEventID().

Referenced by G4WorkerRunManager::GenerateEvent().

 {
   G4AutoLock l(&setUpEventMutex);
   if( numberOfEventProcessed < numberOfEventToBeProcessed && !runAborted )
   {
     G4int nev = eventModulo;
     if(numberOfEventProcessed + nev > numberOfEventToBeProcessed)
     { nev = numberOfEventToBeProcessed - numberOfEventProcessed; }
     evt->SetEventID(numberOfEventProcessed);
     G4RNGHelper* helper = G4RNGHelper::GetInstance();
     for(int i=0;i<nev;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::SetUserAction ( G4UserRunAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 410 of file G4MTRunManager.cc.

References G4UserRunAction::SetMaster(), and G4RunManager::SetUserAction().

Referenced by G4TheMTRayTracer::RestoreUserActions(), and G4TheMTRayTracer::StoreUserActions().

 {
     G4RunManager::SetUserAction(userAction); 
     userAction->SetMaster();
 }

void G4MTRunManager::SetUserAction ( G4VUserPrimaryGeneratorAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 416 of file G4MTRunManager.cc.

References FatalException, and G4Exception().

 {
   G4Exception("G4MTRunManager::SetUserAction()", "Run3011", FatalException,
     "For multi-threaded version, define G4VUserPrimaryGeneratorAction in G4VUserActionInitialization.");
 }

void G4MTRunManager::SetUserAction ( G4UserEventAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 422 of file G4MTRunManager.cc.

References FatalException, and G4Exception().

 {
   G4Exception("G4MTRunManager::SetUserAction()", "Run3011", FatalException,
     "For multi-threaded version, define G4UserEventAction in G4VUserActionInitialization.");
 }

void G4MTRunManager::SetUserAction ( G4UserStackingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 428 of file G4MTRunManager.cc.

References FatalException, and G4Exception().

 {
   G4Exception("G4MTRunManager::SetUserAction()", "Run3011", FatalException,
     "For multi-threaded version, define G4UserStackingAction in G4VUserActionInitialization.");
 }

void G4MTRunManager::SetUserAction ( G4UserTrackingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 434 of file G4MTRunManager.cc.

References FatalException, and G4Exception().

 {
   G4Exception("G4MTRunManager::SetUserAction()", "Run3011", FatalException,
     "For multi-threaded version, define G4UserTrackingAction in G4VUserActionInitialization.");
 }

void G4MTRunManager::SetUserAction ( G4UserSteppingAction * userAction )

virtual

Reimplemented from G4RunManager.

Definition at line 440 of file G4MTRunManager.cc.

References FatalException, and G4Exception().

 {
   G4Exception("G4MTRunManager::SetUserAction()", "Run3011", FatalException,
     "For multi-threaded version, define G4UserSteppingAction in G4VUserActionInitialization.");
 }

void G4MTRunManager::SetUserInitialization ( G4VUserPhysicsList * userPL )

virtual

Reimplemented from G4RunManager.

Definition at line 399 of file G4MTRunManager.cc.

References G4RunManager::SetUserInitialization().

Referenced by main(), G4TheMTRayTracer::RestoreUserActions(), and G4TheMTRayTracer::StoreUserActions().

 {
     G4RunManager::SetUserInitialization(userPL);
     //Needed for MT, to be moved in kernel 
 }

void G4MTRunManager::SetUserInitialization ( G4VUserDetectorConstruction * userDC )

virtual

Reimplemented from G4RunManager.

Definition at line 405 of file G4MTRunManager.cc.

References G4RunManager::SetUserInitialization().

 {
     G4RunManager::SetUserInitialization(userDC);
 }

void G4MTRunManager::SetUserInitialization ( G4UserWorkerInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 383 of file G4MTRunManager.cc.

References G4RunManager::userWorkerInitialization.

 {
   userWorkerInitialization = userInit;
 }

void G4MTRunManager::SetUserInitialization ( G4UserWorkerThreadInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 388 of file G4MTRunManager.cc.

References G4RunManager::userWorkerThreadInitialization.

 {
   userWorkerThreadInitialization = userInit;
 }

void G4MTRunManager::SetUserInitialization ( G4VUserActionInitialization * userInit )

virtual

Reimplemented from G4RunManager.

Definition at line 393 of file G4MTRunManager.cc.

References G4VUserActionInitialization::BuildForMaster(), and G4RunManager::userActionInitialization.

 {
   userActionInitialization = userInit;
   userActionInitialization->BuildForMaster();
 }

void G4MTRunManager::StoreRNGStatus ( const G4String & filenamePrefix )

protectedvirtual

Reimplemented from G4RunManager.

Definition at line 172 of file G4MTRunManager.cc.

References G4RunManager::randomNumberStatusDir.

 {
     std::ostringstream os;
     os << randomNumberStatusDir << "G4Master_"<<fn <<".rndm";
     G4Random::saveEngineStatus(os.str().c_str());
 }

void G4MTRunManager::TerminateEventLoop ( )

virtual

Reimplemented from G4RunManager.

Definition at line 214 of file G4MTRunManager.cc.

 {
     //Nothing to do
 }

void G4MTRunManager::TerminateOneEvent ( )

virtual

Reimplemented from G4RunManager.

Definition at line 222 of file G4MTRunManager.cc.

 {
     //Nothing to do
 }

void G4MTRunManager::TerminateWorkers ( )

protectedvirtual

Reimplemented in tbbMasterRunManager.

Definition at line 502 of file G4MTRunManager.cc.

References ENDWORKER, G4UserWorkerThreadInitialization::JoinWorker(), NewActionRequest(), and G4RunManager::userWorkerThreadInitialization.

Referenced by ~G4MTRunManager().

 {
     NewActionRequest( ENDWORKER );
     //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);
         //G4THREADJOIN(*t);
         delete t;
     }
 #endif
     threads.clear();
 }

void G4MTRunManager::ThisWorkerEndEventLoop ( )

virtual

Reimplemented in tbbMasterRunManager.

Definition at line 780 of file G4MTRunManager.cc.

References G4CONDITIONWAIT, and G4CONDTIONBROADCAST.

Referenced by G4WorkerRunManager::RunTermination().

 {
     //Increament number of workers in end of evnet loop by 1
 #ifndef WIN32
     G4AutoLock l(&numberOfEndOfEventLoopWorkersMutex);
 #else
     EnterCriticalSection( &cs2 );
 #endif
     ++numberOfEndOfEventLoopWorkers;
     //Signale this number has changed
     G4CONDTIONBROADCAST(&numWorkersEndEventLoopChangedCondition);
     //Wait for condition to exit eventloop
 #ifdef WIN32
     G4CONDITIONWAIT(&endEventLoopCondition,&cs2);
     LeaveCriticalSection( &cs2 );
 #else
     G4CONDITIONWAIT(&endEventLoopCondition,&numberOfEndOfEventLoopWorkersMutex);
 #endif
 }

void G4MTRunManager::ThisWorkerReady ( )

virtual

Reimplemented in tbbMasterRunManager.

Definition at line 718 of file G4MTRunManager.cc.

References G4CONDITIONWAIT, and G4CONDTIONBROADCAST.

Referenced by G4WorkerRunManager::RunInitialization().

 {
     //Increament number of active worker by 1
 #ifndef WIN32
     G4AutoLock lockLoop(&numberOfReadyWorkersMutex);
 #else
     EnterCriticalSection( &cs1 );
 #endif
     ++numberOfReadyWorkers;
     //Signal the number of workers has changed
     G4CONDTIONBROADCAST(&numWorkersBeginEventLoopChangeCondition);
     //Wait for condition to start eventloop
 #ifdef WIN32
     G4CONDITIONWAIT(&beginEventLoopCondition,&cs1);
     LeaveCriticalSection( &cs1 );
 #else
     G4CONDITIONWAIT(&beginEventLoopCondition,&numberOfReadyWorkersMutex);
 #endif
     //Protects access to shared resource, guarantees we do not call this method
     //while someone else is modifying its content (e.g. creating a new particle)
     //G4PDefManager& pdm = const_cast<G4PDefManager&>(G4ParticleDefinition::GetSubInstanceManager());
     //pdm.Lock();
     //pdm.NewSubInstances();
     //pdm.UnLock();
     //const_cast<G4PDefManager&>(G4ParticleDefinition::GetSubInstanceManager()).NewSubInstances();
     // I believe this is not necessary and safe to remove (Makoto)
     //G4ParticleTable::GetParticleTable()->WorkerG4ParticleTable();
 }

G4MTRunManager::WorkerActionRequest G4MTRunManager::ThisWorkerWaitForNextAction ( )

virtual

Reimplemented in tbbMasterRunManager.

Definition at line 841 of file G4MTRunManager.cc.

References G4CONDITIONWAIT, G4CONDTIONBROADCAST, and nextActionRequest.

Referenced by G4MTRunManagerKernel::StartThread().

 {
   //This worker is ready to receive a new action request, 
   //increment counter by 1
  #ifndef WIN32
   G4AutoLock l(&numberOfReadyWorkersForNewActionMutex);
 #else
   EnterCriticalSection( &cs3 );
 #endif
   ++numberOfReadyWorkersForNewAction;
   //Singal the sahred resource has changed to the master
   G4CONDTIONBROADCAST(&numberOfReadyWorkersForNewActionChangedCondition);
   //Wait for condition that a new aciton is ready
 #ifdef WIN32
   G4CONDITIONWAIT(&requestChangeActionForWorker,&cs3);
   LeaveCriticalSection( &cs3 );
 #else
   G4CONDITIONWAIT(&requestChangeActionForWorker,&numberOfReadyWorkersForNewActionMutex);
 #endif 
   //Ok, if I am here it means that a new action has been requested by the master
   //reads it value that is now read-only, so no mutex is needed, but you never know...
   G4AutoLock l2(&nextActionRequestMutex);
   WorkerActionRequest result = nextActionRequest;
   return result;
 }

void G4MTRunManager::WaitForEndEventLoopWorkers ( )

protectedvirtual

Reimplemented in tbbMasterRunManager.

Definition at line 748 of file G4MTRunManager.cc.

References G4CONDITIONWAIT, and G4CONDTIONBROADCAST.

Referenced by RunTermination().

 {
     while (true)
     {
 #ifndef WIN32
         G4AutoLock l(&numberOfEndOfEventLoopWorkersMutex);
 #else
         EnterCriticalSection( &cs2 );
 #endif
     G4int activethreads = threads.size();
         if ( numberOfEndOfEventLoopWorkers == activethreads )
         {
             break;
         }
 #ifdef WIN32
         G4CONDITIONWAIT(&numWorkersEndEventLoopChangedCondition,
                         &cs2);
         LeaveCriticalSection( &cs2 );
 #else
         G4CONDITIONWAIT(&numWorkersEndEventLoopChangedCondition,
                         &numberOfEndOfEventLoopWorkersMutex);
 #endif
     }
     //Now number of workers that reached end of event loop is as expected
     //Reset number of workers in ready for work state so a new run can start
     G4AutoLock l(&numberOfReadyWorkersMutex);
     numberOfReadyWorkers = 0;
     //Signal workers they can end event-loop
     G4AutoLock l2(&numberOfEndOfEventLoopWorkersMutex);
     G4CONDTIONBROADCAST(&endEventLoopCondition);
 }

void G4MTRunManager::WaitForReadyWorkers ( )

protectedvirtual

Reimplemented in tbbMasterRunManager.

Definition at line 662 of file G4MTRunManager.cc.

References G4CONDITIONWAIT, and G4CONDTIONBROADCAST.

Referenced by InitializeEventLoop().

 {
     while (true) //begin barrier
     {
 #ifndef WIN32
         G4AutoLock lockLoop(&numberOfReadyWorkersMutex);
 #else
         EnterCriticalSection( &cs1 );
 #endif
         //Check number of workers ready to begin
     G4int activethreads = threads.size();
         if (numberOfReadyWorkers == activethreads )
         {
             //Ok, interrupt the loop
             break;
         }
         //Wait for the number of workers to be changed
 #ifdef WIN32
         G4CONDITIONWAIT(&numWorkersBeginEventLoopChangeCondition,
                         &cs1);
         LeaveCriticalSection( &cs1 );
 #else
         G4CONDITIONWAIT(&numWorkersBeginEventLoopChangeCondition,
                         &numberOfReadyWorkersMutex);
 #endif
     }
     //Now number of workers is as expected.
 //////    static G4bool createIsomerOnlyOnce = false;
 //////    if(!createIsomerOnlyOnce)
 //////    {
 //////      createIsomerOnlyOnce = true;
 //////      G4ParticleDefinition* gion = G4ParticleTable::GetParticleTable()->GetGenericIon();
 //////      if(gion)
 //////      {
 //////        ////G4ParticleTable::GetParticleTable()->GetIonTable()->CreateAllIsomer();
 //////        G4int gionId = gion->GetParticleDefinitionID();
 //////        G4ParticleTable::G4PTblDicIterator* pItr = G4ParticleTable::GetParticleTable()->GetIterator();
 //////        pItr->reset(false);
 //////        while( (*pItr)() )
 //////        {
 //////          G4ParticleDefinition* particle = pItr->value();
 //////          if(particle->IsGeneralIon()) particle->SetParticleDefinitionID(gionId);
 //////        }
 //////      }
 //////    }
 
     //Prepare to wait for workers to end eventloop
     //Reset number of workers in "EndOfEventLoop"
     G4AutoLock l(&numberOfEndOfEventLoopWorkersMutex);
     numberOfEndOfEventLoopWorkers = 0;
     
     //signal workers they can start the event-loop
     G4AutoLock l2(&numberOfReadyWorkersMutex);
     G4CONDTIONBROADCAST(&beginEventLoopCondition);
 }