maia::alloc Namespace Reference

Functions
void	debug (const MString &objectName, const MString &elementsName)
	Debug output for mAlloc. More...
void	debug (const MString &objectName)
void	debug_collector (const MString &objectName, const MInt maxSize, const MString &function)
void	debug_list (const MString &objectName, const MInt maxSize, const MString &function)
template<class T >
MInt	findAllocatedObject (const T *const a, std::vector< GenericObject * >::iterator &hit)
	Find the allocated object for a given pointer. More...
template<class T >
MBool	isAllocated (const T *const a)
	Check if the given pointer belongs to an allocated object. More...
template<class T >
void	checkPointer (const T *const a, const MString objectName, const MString function)
template<class T >
void	checkPointer (const T *const, const MString &, const MString &)
template<class T >
void	store_collector (Collector< T > *a, MLong maxSize, const MString &objectName, const MString &functionName)
template<class T >
Collector< T > *	make_collector (const MLong size, const MInt dummy1, const MInt dummy2, const MInt dummy3, const MInt dummy4)
template<class T >
Collector< T > *	make_collector (const MLong size, const MInt dimension, const MFloat dummy, const MInt maxNoSets)
template<class T >
Collector< T > *	make_collector (const MLong size, const MInt dimension, const MInt dummy, const MInt dummy1)
template<class T >
Collector< T > *	make_collector (const MLong size, const MInt dimension, const MInt distributions, const MInt distributions1, const MInt maxNoSurfaces, const MInt dummy1)
template<class T >
Collector< T > *	make_collector (const MLong size, const MInt dimension, const MInt distributions)
template<class T >
Collector< T > *	make_collector (const MLong size, const MInt dimension)
template<class T >
Collector< T > *	make_collector (const MLong size)

Variables
std::vector< GenericObject * >	g_allocatedObjects
MLong	g_allocatedBytes = 0
MLong	g_maxAllocatedBytes = 0

Function Documentation

checkPointer() [1/2]

template<class T >

void maia::alloc::checkPointer ( const T *const  a, const MString  objectName, const MString  function  )

inline

Definition at line 99 of file alloc.h.

                                                                                             {
  if(isAllocated(a)) {
    std::cerr << "Warning in mAlloc: pointer for object '" << objectName
              << "' already in list of allocated objects, call mDeallocate before reallocating! " << function
              << std::endl;
  } else if(a != nullptr) {
    std::cerr << "Warning in mAlloc: passed pointer != nullptr for object '" << objectName << "'! " << function
              << std::endl;
  }
}

checkPointer() [2/2]

template<class T >

void maia::alloc::checkPointer ( const T * const  , const MString &  , const MString &    )

inline

Definition at line 111 of file alloc.h.

{}

debug() [1/2]

void maia::alloc::debug ( const MString &  objectName )

inline

Definition at line 41 of file alloc.h.

{ debug(objectName, objectName); }

debug() [2/2]

void maia::alloc::debug ( const MString &  objectName, const MString &  elementsName  )

inline

Definition at line 31 of file alloc.h.

                                                                          {
  MString allocatedObjectName = (objectName == elementsName) ? objectName : objectName + elementsName;
  typedef std::vector<GenericObject*>::iterator GenericObjIt;
  for(GenericObjIt i = g_allocatedObjects.begin(); i != g_allocatedObjects.end(); i++) {
    if((*i)->getName() == allocatedObjectName) {
      std::cerr << "Warning: object " << objectName << " has already been allocated!" << std::endl;
      m_log << "Warning: object " << objectName << " has already been allocated!" << std::endl;
    }
  }
}

debug_collector()

void maia::alloc::debug_collector ( const MString &  objectName, const MInt  maxSize, const MString &  function  )

inline

Definition at line 42 of file alloc.h.

                                                                                                    {
  debug(objectName);
  m_log << "Creating collector '" << objectName << "' with " << maxSize << " elements as requested by " << function
        << "." << std::endl;
}

debug_list()

void maia::alloc::debug_list ( const MString &  objectName, const MInt  maxSize, const MString &  function  )

inline

Definition at line 48 of file alloc.h.

                                                                                               {
  debug(objectName);
  m_log << "Creating list '" << objectName << "' with " << maxSize << " elements as requested by " << function << "."
        << std::endl;
}

findAllocatedObject()

template<class T >

MInt maia::alloc::findAllocatedObject ( const T *const  a, std::vector< GenericObject * >::iterator &  hit  )

inline

Definition at line 63 of file alloc.h.

                                                                                          {
  if(a == nullptr) {
    return 0;
  }
 
  MInt count = 0;
  for(auto i = g_allocatedObjects.begin(); i != g_allocatedObjects.end(); i++) {
    auto* object = static_cast<GenericPointer<T>*>(*i);
    if(static_cast<T*>((*object).getObjectPointer()) == a) {
      count++;
      hit = i;
      if((*object).objectIsArray) {
        auto j = i + 1;
        while((j != g_allocatedObjects.end()) && ((*j)->getObjectId() == (*i)->getObjectId())) {
          count++;
          j++;
        }
      }
      break;
    }
  }
  return count;
}

isAllocated()

template<class T >

MBool maia::alloc::isAllocated ( const T *const  a )

inline

Definition at line 90 of file alloc.h.

                                           {
  std::vector<GenericObject*>::iterator hit;
  const MInt count = findAllocatedObject(a, hit);
  return (count > 0);
}

make_collector() [1/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size )

inline

Definition at line 157 of file alloc.h.

                                                      {
  return new Collector<T>(size);
}

make_collector() [2/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size, const MInt  dimension  )

inline

Definition at line 153 of file alloc.h.

                                                                            {
  return new Collector<T>(size, dimension);
}

make_collector() [3/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size, const MInt  dimension, const MFloat  dummy, const MInt  maxNoSets  )

inline

Definition at line 132 of file alloc.h.

                                                                                                                      {
  return new Collector<T>(size, dimension, dummy, maxNoSets);
}

make_collector() [4/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size, const MInt  dimension, const MInt  distributions  )

inline

Definition at line 149 of file alloc.h.

                                                                                                      {
  return new Collector<T>(size, dimension, distributions);
}

make_collector() [5/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size, const MInt  dimension, const MInt  distributions, const MInt  distributions1, const MInt  maxNoSurfaces, const MInt  dummy1  )

inline

Definition at line 142 of file alloc.h.

                                                                                                            {
  return new Collector<T>(size, dimension, distributions, distributions1, maxNoSurfaces, dummy1);
}

make_collector() [6/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size, const MInt  dimension, const MInt  dummy, const MInt  dummy1  )

inline

Definition at line 138 of file alloc.h.

                                                                                                                 {
  return new Collector<T>(size, dimension, dummy, dummy1);
}

make_collector() [7/7]

template<class T >

Collector< T > * maia::alloc::make_collector ( const MLong  size, const MInt  dummy1, const MInt  dummy2, const MInt  dummy3, const MInt  dummy4  )

inline

Definition at line 127 of file alloc.h.

                                                       {
  return new Collector<T>(size, dummy1, dummy2, dummy3, dummy4);
}

store_collector()

template<class T >

void maia::alloc::store_collector ( Collector< T > *  a, MLong  maxSize, const MString &  objectName, const MString &  functionName  )

inline

Definition at line 116 of file alloc.h.

                                                                                                                    {
  const MLong size = (T::staticElementSize() * (maxSize + 2) * sizeof(char)) + ((maxSize + 1) * sizeof(T));
  g_allocatedObjects.push_back(new GenericPointer<Collector<T>>(a, objectName, size, functionName, false));
}

Variable Documentation

g_allocatedBytes

MLong maia::alloc::g_allocatedBytes = 0

Definition at line 27 of file globalvariables.cpp.

g_allocatedObjects

std::vector< GenericObject * > maia::alloc::g_allocatedObjects

Definition at line 26 of file globalvariables.cpp.

g_maxAllocatedBytes

MLong maia::alloc::g_maxAllocatedBytes = 0

Definition at line 28 of file globalvariables.cpp.