#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 72 of file G4VUPLSplitter.hh.

Constructor & Destructor Documentation

template<class T >

G4VUPLSplitter< T >::G4VUPLSplitter ( )

inline

Definition at line 76 of file G4VUPLSplitter.hh.

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

Member Function Documentation

template<class T >

G4int G4VUPLSplitter< T >::CreateSubInstance ( )

inline

Definition at line 81 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);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

T* G4VUPLSplitter< T >::FreeWorkArea ( )

inline

Definition at line 154 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;
     }

template<class T >

void G4VUPLSplitter< T >::FreeWorker ( )

inline

Definition at line 130 of file G4VUPLSplitter.hh.

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

Here is the caller graph for this function:

template<class T >

T* G4VUPLSplitter< T >::GetOffset ( )

inline

Definition at line 138 of file G4VUPLSplitter.hh.

138 { return offset; }

G4VUPLSplitter::offset

G4RUN_DLL G4ThreadLocalStatic T * offset

Definition: G4VUPLSplitter.hh:188

Here is the caller graph for this function:

template<class T >

void G4VUPLSplitter< T >::NewSubInstances ( )

inline

Definition at line 104 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();
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

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

inline

Definition at line 140 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;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T >

void G4VUPLSplitter< T >::WorkerCopySubInstanceArray ( )

inline

Definition at line 166 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));
     }