Import Geant4 10.7.0.beta source tree
This commit is contained in:
Gabriele Cosmo
@@ -1,86 +0,0 @@
|
||||
//
|
||||
// ********************************************************************
|
||||
// * 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. *
|
||||
// ********************************************************************
|
||||
//
|
||||
//
|
||||
// Class description:
|
||||
//
|
||||
// This class implements the worker model run manager for TBB based
|
||||
// application.
|
||||
// It is instantiated by tbbUserWorkerInitialization and used by
|
||||
// SimpleTbbMasterRunManager.
|
||||
// See G4WorkerRunManager for documentation of methods relative to
|
||||
// base class. Only class specific methods are documented here.
|
||||
//
|
||||
// Equivalent in traditional MT:
|
||||
// G4WorkerRunManager
|
||||
//
|
||||
// History:
|
||||
// Oct 31st, 2013 A. Dotti - First Implementation
|
||||
|
||||
#include "SimpleTbbMasterRunManager.hh"
|
||||
#include "tbbTask.hh"
|
||||
|
||||
SimpleTbbMasterRunManager::SimpleTbbMasterRunManager() :
|
||||
G4MTRunManager(),
|
||||
theTasks(static_cast<tbb::task_list*>(nullptr)),
|
||||
nEvtsPerTask(1)
|
||||
{
|
||||
}
|
||||
|
||||
SimpleTbbMasterRunManager::~SimpleTbbMasterRunManager()
|
||||
{
|
||||
}
|
||||
|
||||
void SimpleTbbMasterRunManager::TerminateWorkers()
|
||||
{
|
||||
//For TBB based example this should be empty
|
||||
}
|
||||
|
||||
void SimpleTbbMasterRunManager::CreateAndStartWorkers()
|
||||
{
|
||||
//Instead of pthread based workers, create tbbTask
|
||||
G4int ntasks = numberOfEventToBeProcessed/nEvtsPerTask;
|
||||
G4int remn = numberOfEventToBeProcessed % nEvtsPerTask;
|
||||
for ( G4int nt = 0 ; nt < ntasks ; ++nt )
|
||||
{
|
||||
G4int evts= nEvtsPerTask;
|
||||
if ( nt == ntasks - 1 ) evts+=remn;
|
||||
CreateTask(nt,evts);
|
||||
}
|
||||
}
|
||||
|
||||
void SimpleTbbMasterRunManager::CreateTask(G4int id,G4int evts)
|
||||
{
|
||||
tbbTask& task = * new(tbb::task::allocate_root())
|
||||
tbbTask( id , nullptr , evts ); //Add output for merging
|
||||
theTasks->push_back( task );
|
||||
}
|
||||
|
||||
void SimpleTbbMasterRunManager::RunTermination()
|
||||
{
|
||||
// Reduce results ....
|
||||
G4MTRunManager::RunTermination();
|
||||
}
|
||||
|
||||
@@ -1,233 +0,0 @@
|
||||
//
|
||||
// ********************************************************************
|
||||
// * 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. *
|
||||
// ********************************************************************
|
||||
//
|
||||
#include "tbbTask.hh"
|
||||
#include "tbbWorkerRunManager.hh"
|
||||
#include "G4Threading.hh"
|
||||
#include "G4String.hh"
|
||||
#include "G4WorkerRunManager.hh"
|
||||
#include "G4MTRunManager.hh"
|
||||
#include "G4UImanager.hh"
|
||||
#include "G4UserWorkerThreadInitialization.hh"
|
||||
#include "G4WorkerThread.hh"
|
||||
#include "G4MTRunManagerKernel.hh"
|
||||
#include "G4AutoLock.hh"
|
||||
#include "G4UserWorkerInitialization.hh"
|
||||
#include "G4VUserActionInitialization.hh"
|
||||
|
||||
//Equivalent to G4MTRunManagerKernel::StartThread
|
||||
|
||||
tbbTask::tbbTask(G4int anId,
|
||||
tbb::concurrent_queue<const G4Run*>* out,
|
||||
G4int nevts)
|
||||
: m_nEvents(nevts),
|
||||
m_taskID(anId),
|
||||
m_output(out),
|
||||
m_beamOnCondition(false)
|
||||
{
|
||||
}
|
||||
|
||||
tbbTask::~tbbTask()
|
||||
{
|
||||
}
|
||||
|
||||
#include <tbb/atomic.h>
|
||||
namespace {
|
||||
tbb::atomic<int> counter;
|
||||
}
|
||||
|
||||
tbb::task* tbbTask::execute()
|
||||
{
|
||||
// In tbb we do not have anymore the concept of thread:
|
||||
// tasks run "somewhere"; but there is no control over where.
|
||||
// This somewhere is a thread, created, controlled and 'switched'
|
||||
// to our task by the TBB runtime system.
|
||||
//
|
||||
// The "pedantic" way to proceed is: recreate the "context"
|
||||
// from scratch every time (context=local run manager,
|
||||
// geometry, etc)
|
||||
// This would be a clear waste of resources: there is no
|
||||
// need to initialize multiple times, when the same thread
|
||||
// is used several times, ie for several tasks.
|
||||
|
||||
// In the current version to avoid this we initialize only
|
||||
// i) the first time we run on each thread, and
|
||||
// ii) at the start of a new run on each thread (reinitialization).
|
||||
// We are confident that this works because TBB co-works with TLS.
|
||||
// In addition this ensures that minimal changes needed to G4 code base.
|
||||
//
|
||||
// Note 1: that this "thread" is responsible for 1 or more TBB task,
|
||||
// e.g. at least one event.
|
||||
// Note 2: In this first example, we do not care about memory usage:
|
||||
// The resources required depend only on the total number of
|
||||
// threads used for at least one event during the simulation.
|
||||
// Note 3: It is possible to do better - this is left for another example.
|
||||
// Here is a sketch how:
|
||||
// If there is a set maximum <N> threads which will be doing
|
||||
// simulation at any point, and that this is smaller than the
|
||||
// number of TBB tasks which can run simulataneously.
|
||||
// What would need to be done is to "acquire" a resource (workspace)
|
||||
// which holds all the memory required for a running task/thread,
|
||||
// and release it at the end of the task to be re-used by other tasks
|
||||
// possibly on different threads. This is demonstrated in another
|
||||
// example.
|
||||
|
||||
static G4ThreadLocal tbbWorkerRunManager* localRM = 0;
|
||||
|
||||
|
||||
//Is this task running for the first time?
|
||||
//How to re-initialize between runs????
|
||||
if (! localRM ) {
|
||||
//It's a new thread, basically repeat what is being done in
|
||||
//G4MTRunManagerKernel::StarThread with an
|
||||
//important difference, do not process data or wait for master to
|
||||
//communicate what to do, it will
|
||||
//not happen!
|
||||
G4MTRunManager* masterRM = G4MTRunManager::GetMasterRunManager();
|
||||
//============================
|
||||
//Step-0: Thread ID
|
||||
//============================
|
||||
//Initliazie per-thread stream-output
|
||||
//The following line is needed before we actually do I/O initialization
|
||||
//because the constructor of UI manager resets the I/O destination.
|
||||
G4int thisId = counter.fetch_and_increment();
|
||||
G4Threading::G4SetThreadId( thisId );
|
||||
G4UImanager::GetUIpointer()->SetUpForAThread( thisId );
|
||||
|
||||
//============================
|
||||
//Step-1: Random number engine
|
||||
//============================
|
||||
//RNG Engine needs to be initialized by "cloning" the master one.
|
||||
const CLHEP::HepRandomEngine* masterEngine =
|
||||
masterRM->getMasterRandomEngine();
|
||||
masterRM->GetUserWorkerThreadInitialization()->SetupRNGEngine(masterEngine);
|
||||
|
||||
//============================
|
||||
//Step-2: Initialize worker thread
|
||||
//============================
|
||||
if(masterRM->GetUserWorkerInitialization())
|
||||
masterRM->GetUserWorkerInitialization()->WorkerInitialize();
|
||||
if(masterRM->GetUserActionInitialization()) {
|
||||
G4VSteppingVerbose* sv =
|
||||
masterRM->GetUserActionInitialization()->InitializeSteppingVerbose();
|
||||
if (sv) G4VSteppingVerbose::SetInstance(sv);
|
||||
}
|
||||
//Now initialize worker part of shared objects (geometry/physics)
|
||||
G4WorkerThread::BuildGeometryAndPhysicsVector();
|
||||
localRM = static_cast<tbbWorkerRunManager*>(
|
||||
masterRM->GetUserWorkerThreadInitialization()->CreateWorkerRunManager()
|
||||
);
|
||||
G4cout<<localRM<<G4endl;
|
||||
//localRM->SetWorkerThread(wThreadContext);
|
||||
// G4AutoLock wrmm(&workerRMMutex);
|
||||
// G4MTRunManagerKernel::workerRMvector->push_back(localRM); //<<<<?????? ANDREA TBB
|
||||
// wrmm.unlock();
|
||||
|
||||
//================================
|
||||
//Step-3: Setup worker run manager
|
||||
//================================
|
||||
// Set the detector and physics list to the worker thread. Share with master
|
||||
const G4VUserDetectorConstruction* detector =
|
||||
masterRM->GetUserDetectorConstruction();
|
||||
localRM->G4RunManager::SetUserInitialization(
|
||||
const_cast<G4VUserDetectorConstruction*>(detector));
|
||||
const G4VUserPhysicsList* physicslist = masterRM->GetUserPhysicsList();
|
||||
localRM->SetUserInitialization(const_cast<G4VUserPhysicsList*>(physicslist));
|
||||
|
||||
//================================
|
||||
//Step-4: Initialize worker run manager
|
||||
//================================
|
||||
if(masterRM->GetUserActionInitialization())
|
||||
{ masterRM->GetNonConstUserActionInitialization()->Build(); }
|
||||
if(masterRM->GetUserWorkerInitialization())
|
||||
{ masterRM->GetUserWorkerInitialization()->WorkerStart(); }
|
||||
localRM->Initialize();
|
||||
|
||||
//Problem at this point is if there is more than one run...
|
||||
// Execute UI commands stored in the masther UI manager
|
||||
std::vector<G4String> cmds = masterRM->GetCommandStack();
|
||||
G4UImanager* uimgr = G4UImanager::GetUIpointer(); //TLS instance
|
||||
std::vector<G4String>::const_iterator it = cmds.begin();
|
||||
for(;it!=cmds.end();it++)
|
||||
{ uimgr->ApplyCommand(*it); }
|
||||
//Start this run
|
||||
G4String macroFile = masterRM->GetSelectMacro();
|
||||
G4int numSelect = masterRM->GetNumberOfSelectEvents();
|
||||
if ( macroFile == "" || macroFile == " " )
|
||||
{
|
||||
localRM->BeamOn(m_nEvents,0,numSelect);
|
||||
}
|
||||
else
|
||||
{
|
||||
localRM->BeamOn(m_nEvents,macroFile,numSelect);
|
||||
}
|
||||
//======= NEW TBB SPECIFIC ===========
|
||||
//Step-5: Initialize and start run
|
||||
//====================================
|
||||
// bla-bla-bla-bla
|
||||
// This is basically BeamOn
|
||||
m_beamOnCondition = localRM->ConfirmBeamOnCondition();
|
||||
if (m_beamOnCondition) {
|
||||
localRM->SetNumberOfEventsToBeProcessed( m_nEvents );
|
||||
localRM->ConstructScoringWorlds();
|
||||
localRM->RunInitialization();
|
||||
//Register this G4Run in output
|
||||
//Note: the idea is that we are going to accumulate everything in
|
||||
//G4Run or derived class. We let the kernel know this is the object
|
||||
//where the output is accumulated for the tbb::tasks that run on
|
||||
//this thread.
|
||||
if ( m_output ) {}
|
||||
}
|
||||
}
|
||||
assert(localRM!=0);
|
||||
if ( m_beamOnCondition ) {
|
||||
localRM->DoEventLoop( m_nEvents );
|
||||
//localRM->RunTermination(); //<<<< How to call this??? ANDREA TBB
|
||||
}
|
||||
|
||||
//Cannot be done here since thread can be re-used by other task
|
||||
//===============================
|
||||
//Step-6: Terminate worker thread
|
||||
//===============================
|
||||
// if(masterRM->GetUserWorkerInitialization())
|
||||
// { masterRM->GetUserWorkerInitialization()->WorkerStop(); }
|
||||
|
||||
// wrmm.lock();
|
||||
// std::vector<G4WorkerRunManager*>::iterator itrWrm = workerRMvector->begin();
|
||||
// for(;itrWrm!=workerRMvector->end();itrWrm++)
|
||||
// {
|
||||
// if((*itrWrm)==wrm)
|
||||
// {
|
||||
// workerRMvector->erase(itrWrm);
|
||||
// break;
|
||||
// }
|
||||
// }
|
||||
// wrmm.unlock();
|
||||
|
||||
// wThreadContext->DestroyGeometryAndPhysicsVector();
|
||||
// wThreadContext = 0;
|
||||
|
||||
return static_cast<tbb::task*>(NULL);
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
//
|
||||
// ********************************************************************
|
||||
// * 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. *
|
||||
// ********************************************************************
|
||||
//
|
||||
|
||||
#include "tbbUserWorkerInitialization.hh"
|
||||
#include "G4Threading.hh"
|
||||
#include "tbbWorkerRunManager.hh"
|
||||
|
||||
tbbUserWorkerInitialization::~tbbUserWorkerInitialization()
|
||||
{}
|
||||
|
||||
void tbbUserWorkerInitialization::JoinWorker(G4Thread*)
|
||||
{
|
||||
//Not needed for TBB
|
||||
}
|
||||
|
||||
G4Thread* tbbUserWorkerInitialization::CreateAndStartWorker(G4WorkerThread*)
|
||||
{
|
||||
//Not needed for TBB
|
||||
return static_cast<G4Thread*>(0);
|
||||
}
|
||||
|
||||
G4WorkerRunManager* tbbUserWorkerInitialization::CreateWorkerRunManager() const
|
||||
{
|
||||
return new tbbWorkerRunManager();
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
//
|
||||
// ********************************************************************
|
||||
// * 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. *
|
||||
// ********************************************************************
|
||||
//
|
||||
#include "tbbWorkerRunManager.hh"
|
||||
#include "G4Run.hh"
|
||||
#include "G4MTRunManager.hh"
|
||||
#include "G4UserWorkerInitialization.hh"
|
||||
#include "G4UserRunAction.hh"
|
||||
#include "G4SDManager.hh"
|
||||
|
||||
tbbWorkerRunManager::tbbWorkerRunManager() :
|
||||
G4WorkerRunManager()
|
||||
{}
|
||||
|
||||
tbbWorkerRunManager::~tbbWorkerRunManager()
|
||||
{}
|
||||
|
||||
void tbbWorkerRunManager::MergePartialResults()
|
||||
{
|
||||
//TBB ??????
|
||||
}
|
||||
|
||||
void tbbWorkerRunManager::ConstructScoringWorlds()
|
||||
{
|
||||
//Forward call to protected method, that's all
|
||||
G4WorkerRunManager::ConstructScoringWorlds();
|
||||
}
|
||||
Reference in New Issue
Block a user