G4EnhancedVecAllocator< _Tp > Class Template Reference

#include <G4EnhancedVecAllocator.hh>

Inheritance diagram for G4EnhancedVecAllocator< _Tp >:

Classes
struct	rebind

Public Member Functions
	G4EnhancedVecAllocator ()
	G4EnhancedVecAllocator (const G4EnhancedVecAllocator< _Tp > &)
template<typename _Tp1 >
	G4EnhancedVecAllocator (const G4EnhancedVecAllocator< _Tp1 > &)
	~G4EnhancedVecAllocator ()
void	deallocate (_Tp *_Ptr, size_t _Count)
_Tp *	allocate (size_t _Count)

Detailed Description

template<typename _Tp>
class G4EnhancedVecAllocator< _Tp >

Definition at line 80 of file G4EnhancedVecAllocator.hh.

Constructor & Destructor Documentation

G4EnhancedVecAllocator() [1/3]

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::G4EnhancedVecAllocator ( )

inline

Definition at line 87 of file G4EnhancedVecAllocator.hh.

{;}

G4EnhancedVecAllocator() [2/3]

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::G4EnhancedVecAllocator ( const G4EnhancedVecAllocator< _Tp > &  )

inline

Definition at line 89 of file G4EnhancedVecAllocator.hh.

      : std::allocator<_Tp>() {;}

G4EnhancedVecAllocator() [3/3]

template<typename _Tp >

template<typename _Tp1 >

G4EnhancedVecAllocator< _Tp >::G4EnhancedVecAllocator ( const G4EnhancedVecAllocator< _Tp1 > &  )

inline

Definition at line 93 of file G4EnhancedVecAllocator.hh.

      : std::allocator<_Tp>() {;}

~G4EnhancedVecAllocator()

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::~G4EnhancedVecAllocator ( )

inline

Definition at line 96 of file G4EnhancedVecAllocator.hh.

{;}

Member Function Documentation

allocate()

template<typename _Tp >

_Tp * G4EnhancedVecAllocator< _Tp >::allocate

(

size_t

_Count

)

Definition at line 152 of file G4EnhancedVecAllocator.hh.

{
  size_t totalsize = _Count * sizeof(_Tp);
 
  G4int found = -1;
  for (register int j = 0 ; j < G4AllocStats::numCat ; j++)
  {
    if ( (G4AllocStats::allocStat != 0)
      && (G4AllocStats::allocStat[j].size == totalsize) )
    {
      found = j;
      break;
    } 
  }   
 
  if (found == -1)  // Find the new size
  {
    G4AllocStats::numCat++;
    if (G4AllocStats::numCat > G4AllocStats::totSpace)
    {
      G4AllocStats::totSpace = G4AllocStats::totSpace + 128;
        // heuristic parameter for different sizes
 
      G4AllocStats::allocStat =
           (G4ChunkIndexType *) realloc(G4AllocStats::allocStat,
           sizeof(G4ChunkIndexType) * G4AllocStats::totSpace);
        // This value must be different than zero; otherwise means
        // failure in allocating extra space !
      // assert(G4AllocStats::allocStat != 0);
    }
 
    G4AllocStats::allocStat[G4AllocStats::numCat-1].size = totalsize;
    G4AllocStats::allocStat[G4AllocStats::numCat-1].totalspace = 0;
    G4AllocStats::allocStat[G4AllocStats::numCat-1].preAllocated = 0;
 
    found = G4AllocStats::numCat - 1;
 
    G4AllocStats::allocStat[found].totalspace = 512;
      // heuristic for the number of STL vector instances
 
    G4AllocStats::allocStat[found].preAllocated =
        (G4ChunkType *) realloc(G4AllocStats::allocStat[found].preAllocated,
          sizeof(G4ChunkType) * G4AllocStats::allocStat[found].totalspace);
      // This value must be different than zero; otherwise means
      // failure in allocating extra space for pointers !
    // assert(G4AllocStats::allocStat[found].preAllocated != 0);
 
    char *newSpace1 = (char *) malloc(totalsize * 512);
      // This pointer must be different than zero; otherwise means
      // failure in allocating extra space for instances !
    // assert(newSpace1 != 0);
 
    for (register int k = 0; k < 512 ; k++)
    {
      ((G4AllocStats::allocStat[found]).preAllocated[k]).isAllocated = 0;
      ((G4AllocStats::allocStat[found]).preAllocated[k]).address =
                                                    newSpace1+totalsize*k;
    }
 
    ((G4AllocStats::allocStat[found]).preAllocated[0]).isAllocated = 1;
    return (_Tp*)(((G4AllocStats::allocStat[found]).preAllocated[0]).address);
  }
 
  // assert(G4AllocStats::allocStat[found].size == totalsize);
 
  for (register int k = 0; k < G4AllocStats::allocStat[found].totalspace; k++)
  {
    if (((G4AllocStats::allocStat[found]).preAllocated[k]).isAllocated == 0)
    { 
      ((G4AllocStats::allocStat[found]).preAllocated[k]).isAllocated = 1;
      return (_Tp*)(((G4AllocStats::allocStat[found]).preAllocated[k]).address);
    }
  }
 
  G4int originalchunknumber = G4AllocStats::allocStat[found].totalspace;
      
  G4AllocStats::allocStat[found].totalspace =      // heuristic for the number
    G4AllocStats::allocStat[found].totalspace+512; // of STL vector instances
 
  G4AllocStats::allocStat[found].preAllocated =
    (G4ChunkType *) realloc(G4AllocStats::allocStat[found].preAllocated,
      sizeof(G4ChunkType) * G4AllocStats::allocStat[found].totalspace);
    // This value must be different than zero; otherwise means
    // failure in allocating extra space for pointers !
  // assert(G4AllocStats::allocStat[found].preAllocated != 0);
 
  char *newSpace = (char *) malloc(totalsize * 512);
    // This pointer must be different than zero; otherwise means
    // failure in allocating extra space for instances !
  // assert(newSpace != 0);
 
  for (register int k = 0; k < 512 ; k++)
  {
    ((G4AllocStats::allocStat[found]).
      preAllocated[originalchunknumber + k]).isAllocated= 0;
    ((G4AllocStats::allocStat[found]).
      preAllocated[originalchunknumber + k]).address= newSpace+totalsize*k;
  }
 
  ((G4AllocStats::allocStat[found]).preAllocated[originalchunknumber])
                                   .isAllocated = 1;
 
  return (_Tp*)(((G4AllocStats::allocStat[found]).
                  preAllocated[originalchunknumber]).address);
}

deallocate()

template<typename _Tp >

void G4EnhancedVecAllocator< _Tp >::deallocate	(	_Tp *	_Ptr,
		size_t	_Count
	)

Definition at line 117 of file G4EnhancedVecAllocator.hh.

{
  G4int found = -1;
  for (register int j = 0 ; j < G4AllocStats::numCat ; j++)
  {
    if ( (G4AllocStats::allocStat != 0)
      && (G4AllocStats::allocStat[j].size == (_Count * sizeof(_Tp))))
    {
      found = j;
      break;
    }
  }
  // assert(found != -1);
 
  for (register int k = 0; k < G4AllocStats::allocStat[found].totalspace; k++)
  {
    if ( ((G4AllocStats::allocStat[found]).preAllocated[k]).address
      == ((char *) _Ptr))
    {
   // assert(((G4AllocStats::allocStat[found]).preAllocated[k]).isAllocated==1);
      ((G4AllocStats::allocStat[found]).preAllocated[k]).isAllocated = 0;
      return;
    }
  }
}

---

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

• G4EnhancedVecAllocator.hh