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, std::size_t _Count)
_Tp *	allocate (std::size_t _Count)

Detailed Description

template<typename _Tp>
class G4EnhancedVecAllocator< _Tp >

Definition at line 70 of file G4EnhancedVecAllocator.hh.

Constructor & Destructor Documentation

G4EnhancedVecAllocator() [1/3]

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::G4EnhancedVecAllocator ( )

inline

Definition at line 77 of file G4EnhancedVecAllocator.hh.

{;}

G4EnhancedVecAllocator() [2/3]

template<typename _Tp >

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

inline

Definition at line 79 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 83 of file G4EnhancedVecAllocator.hh.

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

~G4EnhancedVecAllocator()

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::~G4EnhancedVecAllocator ( )

inline

Definition at line 86 of file G4EnhancedVecAllocator.hh.

{;}

Member Function Documentation

allocate()

template<typename _Tp >

_Tp * G4EnhancedVecAllocator< _Tp >::allocate

(

std::size_t

_Count

)

Definition at line 145 of file G4EnhancedVecAllocator.hh.

{
  std::size_t totalsize = _Count * sizeof(_Tp);
 
  G4int found = -1;
  if (G4AllocStats::allocStat != 0)
  {
    for (auto j = 0 ; j < G4AllocStats::numCat ; ++j)
    {
      if (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;
    G4ChunkIndexType& chunk = G4AllocStats::allocStat[found];
 
    chunk.totalspace = 512;
      // heuristic for the number of STL vector instances
 
    chunk.preAllocated = (G4ChunkType *) realloc(chunk.preAllocated,
                         sizeof(G4ChunkType) * chunk.totalspace);
      // This value must be different than zero; otherwise means
      // failure in allocating extra space for pointers !
    // assert(chunk.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 (auto k = 0; k < 512 ; ++k)
    {
      (chunk.preAllocated[k]).isAllocated = 0;
      (chunk.preAllocated[k]).address = newSpace1+totalsize*k;
    }
 
    (chunk.preAllocated[0]).isAllocated = 1;
    return (_Tp*)((chunk.preAllocated[0]).address);
  }
 
  G4ChunkIndexType& chunk = G4AllocStats::allocStat[found];
 
  // assert(chunk.size == totalsize);
 
  for (auto k = 0; k < chunk.totalspace; ++k)
  {
    if ((chunk.preAllocated[k]).isAllocated == 0)
    { 
      (chunk.preAllocated[k]).isAllocated = 1;
      return (_Tp*)((chunk.preAllocated[k]).address);
    }
  }
 
  G4int originalchunknumber = chunk.totalspace;
      
  chunk.totalspace += 512;  // heuristic for the number of STL vector instances
 
  chunk.preAllocated = (G4ChunkType *) realloc(chunk.preAllocated,
                       sizeof(G4ChunkType) * chunk.totalspace);
    // This value must be different than zero; otherwise means
    // failure in allocating extra space for pointers !
  // assert(chunk.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 (auto k = 0; k < 512 ; ++k)
  {
    (chunk.preAllocated[originalchunknumber+k]).isAllocated = 0;
    (chunk.preAllocated[originalchunknumber+k]).address = newSpace+totalsize*k;
  }
 
  (chunk.preAllocated[originalchunknumber]).isAllocated = 1;
 
  return (_Tp*)((chunk.preAllocated[originalchunknumber]).address);
}

deallocate()

template<typename _Tp >

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

Definition at line 107 of file G4EnhancedVecAllocator.hh.

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

---

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

• G4EnhancedVecAllocator.hh