G4VUPLSplitter< T > Class Template Reference

#include <G4VUPLSplitter.hh>

Collaboration diagram for G4VUPLSplitter< T >:

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

Private Attributes
G4int	totalobj
G4int	totalspace
T *	sharedOffset
G4Mutex	mutex

Detailed Description

template<class T>
class G4VUPLSplitter< T >

Definition at line 72 of file G4VUPLSplitter.hh.

Constructor & Destructor Documentation

G4VUPLSplitter()

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

CreateSubInstance()

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:

FreeWorkArea()

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

FreeWorker()

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:

GetOffset()

template<class T >

T* G4VUPLSplitter< T >::GetOffset ( )

inline

Definition at line 138 of file G4VUPLSplitter.hh.

{ return offset; }

Here is the caller graph for this function:

NewSubInstances()

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:

UseWorkArea()

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:

WorkerCopySubInstanceArray()

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));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mutex

template<class T >

G4Mutex G4VUPLSplitter< T >::mutex

private

Definition at line 194 of file G4VUPLSplitter.hh.

offset

template<class T >

G4ThreadLocal T * G4VUPLSplitter< T >::offset =0

Definition at line 188 of file G4VUPLSplitter.hh.

sharedOffset

template<class T >

T* G4VUPLSplitter< T >::sharedOffset

private

Definition at line 193 of file G4VUPLSplitter.hh.

totalobj

template<class T >

G4int G4VUPLSplitter< T >::totalobj

private

Definition at line 191 of file G4VUPLSplitter.hh.

totalspace

template<class T >

G4int G4VUPLSplitter< T >::totalspace

private

Definition at line 192 of file G4VUPLSplitter.hh.

workertotalspace

template<class T >

G4ThreadLocal G4int G4VUPLSplitter< T >::workertotalspace =0

Definition at line 187 of file G4VUPLSplitter.hh.

---

The documentation for this class was generated from the following file:

• G4VUPLSplitter.hh