G4VUPLSplitter< T > Class Template Reference

#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
G4RUN_DLL G4ThreadLocalStatic T *	offset

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

FreeWorkArea()

template<class T>

T * G4VUPLSplitter< T >::FreeWorkArea ( )

inline

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

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

GetOffset()

template<class T>

T * G4VUPLSplitter< T >::GetOffset ( )

inline

Definition at line 125 of file G4VUPLSplitter.hh.

{ return offset; }

NewSubInstances()

template<class T>

void G4VUPLSplitter< T >::NewSubInstances ( )

inline

Definition at line 92 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< G4VMPLData >::CreateSubInstance().

UseWorkArea()

template<class T>

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

inline

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

WorkerCopySubInstanceArray()

template<class T>

void G4VUPLSplitter< T >::WorkerCopySubInstanceArray ( )

inline

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

Member Data Documentation

offset

template<class T>

G4RUN_DLL G4ThreadLocalStatic T* G4VUPLSplitter< T >::offset

Definition at line 172 of file G4VUPLSplitter.hh.

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

workertotalspace

template<class T>

G4RUN_DLL G4ThreadLocalStatic G4int G4VUPLSplitter< T >::workertotalspace

Definition at line 170 of file G4VUPLSplitter.hh.

---

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

• G4VUPLSplitter.hh