G4EnhancedVecAllocator< _Tp > Class Template Reference

#include <G4EnhancedVecAllocator.hh>

Inheritance diagram for G4EnhancedVecAllocator< _Tp >:

Collaboration 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

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::G4EnhancedVecAllocator ( )

inline

Definition at line 87 of file G4EnhancedVecAllocator.hh.

{;}

template<typename _Tp >

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

inline

Definition at line 89 of file G4EnhancedVecAllocator.hh.

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

template<typename _Tp >

template<typename _Tp1 >

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

inline

Definition at line 93 of file G4EnhancedVecAllocator.hh.

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

template<typename _Tp >

G4EnhancedVecAllocator< _Tp >::~G4EnhancedVecAllocator ( )

inline

Definition at line 96 of file G4EnhancedVecAllocator.hh.

{;}

Member Function Documentation

template<typename _Tp >

_Tp * G4EnhancedVecAllocator< _Tp >::allocate

(

size_t

_Count

)

Definition at line 155 of file G4EnhancedVecAllocator.hh.

{
  size_t totalsize = _Count * sizeof(_Tp);

  G4int found = -1;
  if (G4AllocStats::allocStat != 0)
  {
    for (G4int 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 (G4int 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 (G4int 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 (G4int 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);
}

template<typename _Tp >

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

Definition at line 117 of file G4EnhancedVecAllocator.hh.

{
  G4int found = -1;
  if (G4AllocStats::allocStat != 0)
  {
    for (G4int 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 (G4int 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:

• geant4.10.03.p01/source/geometry/volumes/include/G4EnhancedVecAllocator.hh