#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 = nullptr

Detailed Description

template<class T>
class G4VUPLSplitter< T >

Definition at line 62 of file G4VUPLSplitter.hh.

Constructor & Destructor Documentation

◆ G4VUPLSplitter()

template<class T >

G4VUPLSplitter< T >::G4VUPLSplitter ( )

inline

Definition at line 66 of file G4VUPLSplitter.hh.

    {
      G4MUTEXINIT(mutex);
    }

Member Function Documentation

◆ CreateSubInstance()

template<class T >

G4int G4VUPLSplitter< T >::CreateSubInstance ( )

inline

Definition at line 71 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 150 of file G4VUPLSplitter.hh.

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

◆ FreeWorker()

template<class T >

void G4VUPLSplitter< T >::FreeWorker ( )

inline

Definition at line 123 of file G4VUPLSplitter.hh.

    {
      if(offset == nullptr)
      {
        return;
      }
      free(offset);
      offset = nullptr;
    }

Referenced by G4PhysicsListWorkspace::DestroyWorkspace().

◆ GetOffset()

template<class T >

T * G4VUPLSplitter< T >::GetOffset ( )

inline

Definition at line 134 of file G4VUPLSplitter.hh.

134{ return offset; }

Referenced by G4PhysicsListWorkspace::G4PhysicsListWorkspace().

◆ NewSubInstances()

template<class T >

void G4VUPLSplitter< T >::NewSubInstances ( )

inline

Definition at line 94 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 == nullptr)
      {
        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 136 of file G4VUPLSplitter.hh.

    {
      // Use recycled work area - which was created previously
      if(offset != nullptr && 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 161 of file G4VUPLSplitter.hh.

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