#include <G4VUPLSplitter.hh>

Public Member Functions
	G4VUPLSplitter ()

G4int	CreateSubInstance ()

void	NewSubInstances ()

void	FreeWorker ()

T *	GetOffset ()

void	UseWorkArea (T *newOffset)

T *	FreeWorkArea ()

void	WorkerCopySubInstanceArray ()

Public Attributes
G4RUN_DLL G4ThreadLocalStatic G4int	workertotalspace = 0

G4RUN_DLL G4ThreadLocalStatic T *	offset = 0

Detailed Description

template<class T>
class G4VUPLSplitter< T >

Definition at line 71 of file G4VUPLSplitter.hh.

Constructor & Destructor Documentation

◆ G4VUPLSplitter()

template<class T >

G4VUPLSplitter< T >::G4VUPLSplitter ( )

inline

Definition at line 74 of file G4VUPLSplitter.hh.

    : totalobj(0)
    , totalspace(0)
    , sharedOffset(0)
  {
    G4MUTEXINIT(mutex);
  }

Member Function Documentation

◆ CreateSubInstance()

template<class T >

G4int G4VUPLSplitter< T >::CreateSubInstance ( )

inline

Definition at line 82 of file G4VUPLSplitter.hh.

  {
    G4AutoLock l(&mutex);
    // One more instance
    totalobj++;
    // If the number of objects is larger than the available spaces,
    // a re-allocation is needed
    if(totalobj > workertotalspace)
    {
      l.unlock();
      NewSubInstances();
      l.lock();
    }
    // Since this is called by Master thread, we can remember this
    totalspace   = workertotalspace;
    sharedOffset = offset;
    return (totalobj - 1);
  }

Referenced by G4VModularPhysicsList::G4VModularPhysicsList(), G4VPhysicsConstructor::G4VPhysicsConstructor(), G4VUserPhysicsList::G4VUserPhysicsList(), and G4VModularPhysicsList::operator=().

◆ FreeWorkArea()

template<class T >

T * G4VUPLSplitter< T >::FreeWorkArea ( )

inline

Definition at line 161 of file G4VUPLSplitter.hh.

  {
    // Detach this thread from this Location
    // The object which calls this method is responsible for it.
    //
    T* offsetRet = offset;
 
    offset = 0;
 
    return offsetRet;
  }

◆ FreeWorker()

template<class T >

void G4VUPLSplitter< T >::FreeWorker ( )

inline

Definition at line 134 of file G4VUPLSplitter.hh.

  {
    if(!offset)
    {
      return;
    }
    free(offset);
    offset = 0;
  }

Referenced by G4PhysicsListWorkspace::DestroyWorkspace().

◆ GetOffset()

template<class T >

T * G4VUPLSplitter< T >::GetOffset ( )

inline

Definition at line 145 of file G4VUPLSplitter.hh.

145{ return offset; }

Referenced by G4PhysicsListWorkspace::G4PhysicsListWorkspace().

◆ NewSubInstances()

template<class T >

void G4VUPLSplitter< T >::NewSubInstances ( )

inline

Definition at line 105 of file G4VUPLSplitter.hh.

  {
    G4AutoLock l(&mutex);
    if(workertotalspace >= totalobj)
    {
      return;
    }
    // Remember current large size
    G4int originaltotalspace = workertotalspace;
    // Increase its size by some value (purely arbitrary)
    workertotalspace = totalobj + 512;
    // Now re-allocate new space
    offset = (T*) realloc(offset, workertotalspace * sizeof(T));
    if(offset == 0)
    {
      G4Exception("G4VUPLSplitter::NewSubInstances()", "OutOfMemory",
                  FatalException, "Cannot malloc space!");
      return;
    }
    // The newly created objects need to be initialized
    for(G4int i = originaltotalspace; i < workertotalspace; i++)
    {
      offset[i].initialize();
    }
  }

Referenced by G4VUPLSplitter< T >::CreateSubInstance(), and G4PhysicsListWorkspace::InitialiseWorkspace().

◆ UseWorkArea()

template<class T >

void G4VUPLSplitter< T >::UseWorkArea ( T * newOffset )

inline

Definition at line 147 of file G4VUPLSplitter.hh.

  {
    // Use recycled work area - which was created previously
    if(offset && offset != newOffset)
    {
      G4Exception("G4VUPLSplitter::UseWorkspace()", "TwoWorkspaces",
                  FatalException,
                  "Thread already has workspace - cannot use another.");
    }
    offset = newOffset;
    // totalobj= numObjects;
    // totalspace= numSpace;
  }

Referenced by G4PhysicsListWorkspace::ReleaseWorkspace(), and G4PhysicsListWorkspace::UseWorkspace().

◆ WorkerCopySubInstanceArray()

template<class T >

void G4VUPLSplitter< T >::WorkerCopySubInstanceArray ( )

inline

Definition at line 173 of file G4VUPLSplitter.hh.

  {
    if(offset)
      return;
    // Since this is called by worker threds, totalspace is some valid number >
    // 0 Remember totalspace is the number of availabel slots from master. We
    // are sure that it has valid data
    G4AutoLock l(&mutex);
    offset = (T*) realloc(offset, totalspace * sizeof(T));
    if(offset == 0)
    {
      G4Exception("G4VUPLSplitter::WorkerCopySubInstanceArray()", "OutOfMemory",
                  FatalException, "Cannot malloc space!");
      return;
    }
    // Now just copy from master thread (sharedOffset)
    memcpy(offset, sharedOffset, totalspace * sizeof(T));
  }