alloc.h File Reference

Go to the source code of this file.

Namespaces
namespace	maia
	Namespace for auxiliary functions/classes.
namespace	maia::alloc

Functions
void	maia::alloc::debug (const MString &objectName, const MString &elementsName)
	Debug output for mAlloc. More...
void	maia::alloc::debug (const MString &objectName)
void	maia::alloc::debug_collector (const MString &objectName, const MInt maxSize, const MString &function)
void	maia::alloc::debug_list (const MString &objectName, const MInt maxSize, const MString &function)
template<class T >
MInt	maia::alloc::findAllocatedObject (const T *const a, std::vector< GenericObject * >::iterator &hit)
	Find the allocated object for a given pointer. More...
template<class T >
MBool	maia::alloc::isAllocated (const T *const a)
	Check if the given pointer belongs to an allocated object. More...
template<class T >
void	maia::alloc::checkPointer (const T *const a, const MString objectName, const MString function)
template<class T >
void	maia::alloc::checkPointer (const T *const, const MString &, const MString &)
template<class T >
void	maia::alloc::store_collector (Collector< T > *a, MLong maxSize, const MString &objectName, const MString &functionName)
template<class T >
Collector< T > *	maia::alloc::make_collector (const MLong size, const MInt dummy1, const MInt dummy2, const MInt dummy3, const MInt dummy4)
template<class T >
Collector< T > *	maia::alloc::make_collector (const MLong size, const MInt dimension, const MFloat dummy, const MInt maxNoSets)
template<class T >
Collector< T > *	maia::alloc::make_collector (const MLong size, const MInt dimension, const MInt dummy, const MInt dummy1)
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)
template<class T >
Collector< T > *	maia::alloc::make_collector (const MLong size, const MInt dimension, const MInt distributions)
template<class T >
Collector< T > *	maia::alloc::make_collector (const MLong size, const MInt dimension)
template<class T >
Collector< T > *	maia::alloc::make_collector (const MLong size)
MLong	allocatedBytes ()
	Return the number of allocated bytes. More...
MLong	maxAllocatedBytes ()
	Return the maximum number of allocated bytes. More...
template<class T >
void	mAlloc (T *&a, const MLong N, const MString &objectName, MString function)
	allocates memory for one-dimensional array 'a' of size N More...
template<class T >
void	mAlloc (T *&a, const MLong N, const MString &objectName, const T initialValue, MString function)
	allocates memory for one-dimensional array 'a' of size N More...
template<class T >
void	mAlloc (T **&a, const MLong N, const MLong M, const MString &objectName, const T initialValue, MString function)
	allocates memory for two-dimensional array 'a' of size NxM More...
template<class T >
void	mAlloc (T **&a, const MLong N, const MLong M, const MString &objectName, MString function)
	allocates memory for two-dimensional array 'a' of size NxM More...
template<class T >
void	mAlloc (T **&a, const MLong N, const MInt *arraySizes, const MString &objectName, MString function)
	allocates memory for two-dimensional array 'a' of size N x arraySizes[0:N-1] More...
template<class T >
void	mAlloc (T **&a, const MLong N, const MInt *const arraySizes, MInt factor, const MString &objectName, MString function)
	allocates memory for two-dimensional array 'a' of size N x (factor*arraySizes[0:N-1]) More...
template<class T >
void	mAlloc (List< T > *&a, const MLong N, const MString &objectName, const T initialValue, MString function)
	allocates memory for List container More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, MInt dummy1, MInt dummy2, MInt dummy3, MInt dummy4, const MString &objectName, MString function)
	allocates memory for Collector More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, MInt dimension, MFloat dummy, MInt maxNoSets, const MString &objectName, MString function)
	allocates memory for Collector More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, MInt dimension, MInt dummy, MInt dummy1, const MString &objectName, MString function)
	allocates memory for Collector More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, MInt dimension, MInt distributions, MInt distributions1, MInt maxNoSurfaces, MInt dummy1, const MString &objectName, MString function)
	Allocates memory for Collector. More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, MInt dimension, MInt distributions, const MString &objectName, MString function)
	allocates memory for Collector More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, MInt dimension, const MString &objectName, MString function)
	allocates memory for Collector More...
template<class T >
void	mAlloc (Collector< T > *&a, MLong maxSize, const MString &objectName, MString function)
	allocates memory for Collector More...
template<class T >
MBool	mDeallocate (T *&a)
	deallocates the memory previously allocated for element 'a' More...
void	mDealloc ()
	Deallocates all memory allocated previously by mAlloc(...) More...
void	printAllocatedObjects ()
	Prints the name of all objects which are currently allocated via mAlloc. More...
void	printAllocatedObjects (const MString &filterString)
	Prints the name of all objects which are currently allocated via mAlloc and contain the given string. More...

Function Documentation

allocatedBytes()

MLong allocatedBytes

(

)

Definition at line 121 of file alloc.cpp.

{ return maia::alloc::g_allocatedBytes; }

mAlloc() [1/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 530 of file alloc.h.

                                                                                          {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [2/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		MInt	dimension,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 516 of file alloc.h.

                                                                                                          {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize, dimension);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [3/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		MInt	dimension,
		MFloat	dummy,
		MInt	maxNoSets,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 447 of file alloc.h.

                              {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize, dimension, dummy, maxNoSets);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [4/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		MInt	dimension,
		MInt	distributions,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Used to allocate:

• DG: m_elements

Definition at line 501 of file alloc.h.

                              {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize, dimension, distributions);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [5/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		MInt	dimension,
		MInt	distributions,
		MInt	distributions1,
		MInt	maxNoSurfaces,
		MInt	dummy1,
		const MString &	objectName,
		MString	function
	)

Used to allocate:

• FvBndryCell

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 483 of file alloc.h.

                                                                                          {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize, dimension, distributions, distributions1, maxNoSurfaces, dummy1);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [6/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		MInt	dimension,
		MInt	dummy,
		MInt	dummy1,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Used to allocate:

• DG: m_surfaces

Definition at line 465 of file alloc.h.

                              {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize, dimension, dummy, dummy1);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [7/14]

template<class T >

void mAlloc	(	Collector< T > *&	a,
		MLong	maxSize,
		MInt	dummy1,
		MInt	dummy2,
		MInt	dummy3,
		MInt	dummy4,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 432 of file alloc.h.

                                                         {
  maia::alloc::checkPointer(a, objectName, function);
  maia::alloc::debug_collector(objectName, maxSize, function);
  a = maia::alloc::make_collector<T>(maxSize, dummy1, dummy2, dummy3, dummy4);
  maia::alloc::store_collector(a, maxSize, objectName, function);
}

mAlloc() [8/14]

template<class T >

void mAlloc	(	List< T > *&	a,
		const MLong	N,
		const MString &	objectName,
		const T	initialValue,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 397 of file alloc.h.

                                                                                                           {
  using namespace maia::alloc;
  maia::alloc::debug_list(objectName, N, function);
  maia::alloc::checkPointer(a, objectName, function);
 
#ifdef MAIA_ASSERT_ALLOC
  ASSERT(N > 0, "Error in mAlloc: size must be >0, is " + std::to_string(N) + " for " + objectName + " allocated in "
                    + function);
#endif
 
  if(N <= 0) {
#ifdef MAIA_DEBUG_ALLOC
    std::cerr << "Warning in mAlloc: size should be >0, is " << std::to_string(N) << " for " << objectName
              << " allocated in " << function << std::endl;
#endif
    return;
  }
 
  a = new List<T>(N);
 
  g_allocatedObjects.push_back(new GenericPointer<List<T>>(a, objectName, N * sizeof(T), function, false));
 
#ifndef SKIP_INITIAL_VALUE_ALLOC
  for(MInt i = 0; i < N; i++)
    a->a[i] = initialValue;
#endif
}

mAlloc() [9/14]

template<class T >

void mAlloc	(	T *&	a,
		const MLong	N,
		const MString &	objectName,
		const T	initialValue,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 201 of file alloc.h.

                                                                                                     {
  mAlloc(a, N, objectName, function);
#ifndef SKIP_INITIAL_VALUE_ALLOC
  for(MInt i = 0; i < N; i++)
    a[i] = initialValue;
#endif
}

mAlloc() [10/14]

template<class T >

void mAlloc	(	T *&	a,
		const MLong	N,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 173 of file alloc.h.

                                                                               {
  using namespace maia::alloc;
  maia::alloc::debug(objectName);
  maia::alloc::checkPointer(a, objectName, function);
 
#ifdef MAIA_ASSERT_ALLOC
  ASSERT(N > 0, "Error in mAlloc: size must be >0, is " + std::to_string(N) + " for " + objectName + " allocated in "
                    + function);
#endif
 
  if(N <= 0) {
#ifdef MAIA_DEBUG_ALLOC
    std::cerr << "Warning in mAlloc: size should be >0, is " << std::to_string(N) << " for " << objectName
              << " allocated in " << function << std::endl;
#endif
    return;
  }
 
  a = new T[N];
  g_allocatedObjects.push_back(new GenericPointer<T>(a, objectName, N * sizeof(T), function, true));
}

mAlloc() [11/14]

template<class T >

void mAlloc	(	T **&	a,
		const MLong	N,
		const MInt *	arraySizes,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 301 of file alloc.h.

                                                                                                        {
  using namespace maia::alloc;
  maia::alloc::debug(objectName);
  maia::alloc::checkPointer(a, objectName, function);
 
  size_t size = 0;
  for(MInt k = 0; k < N; k++) {
    size += arraySizes[k];
  }
 
#ifdef MAIA_ASSERT_ALLOC
  ASSERT(N > 0 && size > 0, "Error in mAlloc: sizes must be >0, but they are " + std::to_string(N) + " and "
                                + std::to_string(size) + " for " + objectName + " allocated in " + function);
#endif
 
  if(N <= 0 || size <= 0) {
#ifdef MAIA_DEBUG_ALLOC
    std::cerr << "Error in mAlloc: sizes should be >0, but they are " << std::to_string(N) << " and "
              << std::to_string(size) << " for " << objectName << " allocated in " << function << std::endl;
#endif
    return;
  }
 
  a = new T*[N];
  g_allocatedObjects.push_back(new GenericPointer<T*>(a, objectName, N * sizeof(T*), function, true));
 
  const MString elementsName = "_elements";
  maia::alloc::debug(objectName, elementsName);
 
  T* dummy = new T[size];
  g_allocatedObjects.push_back(
      new GenericPointer<T>(dummy, objectName + elementsName, size * sizeof(T), function, true, false));
 
  size_t cnt = 0;
  for(MInt i = 0; i < N; i++) {
    a[i] = (T*)(&(dummy[cnt]));
    cnt += arraySizes[i];
  }
}

mAlloc() [12/14]

template<class T >

void mAlloc	(	T **&	a,
		const MLong	N,
		const MInt *const	arraySizes,
		MInt	factor,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 349 of file alloc.h.

                              {
  using namespace maia::alloc;
  maia::alloc::debug(objectName);
  maia::alloc::checkPointer(a, objectName, function);
 
  size_t size = 0;
  for(MInt k = 0; k < N; k++) {
    size += factor * arraySizes[k];
  }
 
#ifdef MAIA_ASSERT_ALLOC
  ASSERT(N > 0 && size > 0, "Error in mAlloc: sizes must be >0, but they are " + std::to_string(N) + " and "
                                + std::to_string(size) + " for " + objectName + " allocated in " + function);
#endif
 
  if(N <= 0 || size <= 0) {
#ifdef MAIA_DEBUG_ALLOC
    std::cerr << "Error in mAlloc: sizes should be >0, but they are " << std::to_string(N) << " and "
              << std::to_string(size) << " for " << objectName << " allocated in " << function << std::endl;
#endif
    return;
  }
 
  a = new T*[N];
  g_allocatedObjects.push_back(new GenericPointer<T*>(a, objectName, N * sizeof(T*), function, true));
 
  const MString elementsName = "_elements";
  maia::alloc::debug(objectName, elementsName);
 
  T* dummy = new T[size];
  g_allocatedObjects.push_back(
      new GenericPointer<T>(dummy, objectName + elementsName, size * sizeof(T), function, true, false));
 
  size_t cnt = 0;
  for(MInt i = 0; i < N; i++) {
    a[i] = (T*)(&(dummy[cnt]));
    cnt += factor * arraySizes[i];
  }
}

mAlloc() [13/14]

template<class T >

void mAlloc	(	T **&	a,
		const MLong	N,
		const MLong	M,
		const MString &	objectName,
		const T	initialValue,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 215 of file alloc.h.

                                                                                                                     {
  using namespace maia::alloc;
  maia::alloc::debug(objectName);
  maia::alloc::checkPointer(a, objectName, function);
 
#ifdef MAIA_ASSERT_ALLOC
  ASSERT(N > 0 && M > 0, "Error in mAlloc: sizes must be >0, but they are " + std::to_string(N) + " and "
                             + std::to_string(M) + " for " + objectName + " allocated in " + function);
#endif
 
  if(N <= 0 || M <= 0) {
#ifdef MAIA_DEBUG_ALLOC
    std::cerr << "Error in mAlloc: sizes should be >0, but they are " << std::to_string(N) << " and "
              << std::to_string(M) << " for " << objectName << " allocated in " << function << std::endl;
#endif
    return;
  }
 
  a = new T*[N];
  g_allocatedObjects.push_back(new GenericPointer<T*>(a, objectName, N * sizeof(T*), function, true));
 
  const MString elementsName = "_elements";
  maia::alloc::debug(objectName, elementsName);
 
  T* dummy = new T[N * M];
  g_allocatedObjects.push_back(
      new GenericPointer<T>(dummy, objectName + elementsName, N * M * sizeof(T), function, true, false));
 
  for(MInt i = 0; i < N; i++) {
    a[i] = (T*)(&(dummy[M * i]));
  }
 
#ifndef SKIP_INITIAL_VALUE_ALLOC
  for(MInt i = 0; i < N * M; i++)
    dummy[i] = initialValue;
#endif
}

mAlloc() [14/14]

template<class T >

void mAlloc	(	T **&	a,
		const MLong	N,
		const MLong	M,
		const MString &	objectName,
		MString	function
	)

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 260 of file alloc.h.

                                                                                               {
  using namespace maia::alloc;
  maia::alloc::debug(objectName);
  maia::alloc::checkPointer(a, objectName, function);
 
#ifdef MAIA_ASSERT_ALLOC
  ASSERT(N > 0 && M > 0, "Error in mAlloc: sizes must be >0, but they are " + std::to_string(N) + " and "
                             + std::to_string(M) + " for " + objectName + " allocated in " + function);
#endif
 
  if(N <= 0 || M <= 0) {
#ifdef MAIA_DEBUG_ALLOC
    std::cerr << "Error in mAlloc: sizes should be >0, but they are " << std::to_string(N) << " and "
              << std::to_string(M) << " for " << objectName << " allocated in " << function << std::endl;
#endif
    return;
  }
 
  a = new T*[N];
 
  g_allocatedObjects.push_back(new GenericPointer<T*>(a, objectName, N * sizeof(T*), function, true));
 
  const MString elementsName = "[0]";
  maia::alloc::debug(objectName, elementsName);
 
  a[0] = new T[N * M];
  g_allocatedObjects.push_back(
      new GenericPointer<T>(a[0], objectName + elementsName, N * M * sizeof(T), function, true, false));
 
  for(MInt i = 1; i < N; i++) {
    a[i] = (T*)(&(a[0][M * i]));
  }
}

maxAllocatedBytes()

MLong maxAllocatedBytes

(

)

Definition at line 123 of file alloc.cpp.

{ return maia::alloc::g_maxAllocatedBytes; }

mDealloc()

void mDealloc

(

)

Author

Lennart Schneiders

Date

08.12.2011

Author

Lennart Schneiders

Date

08.12.2011

Definition at line 20 of file alloc.cpp.

                {
  TRACE();
  using namespace maia::alloc;
 
  const MInt padSize = 50;
  MInt N = 20;
  std::vector<MString> topConsumers;
  std::vector<MLong> consumption(N);
  for(MInt k = 0; k < N; k++) {
    consumption[k] = 0;
    topConsumers.emplace_back("-");
  }
  MInt count = 0;
  for(auto i = g_allocatedObjects.begin(); i != g_allocatedObjects.end(); i++) {
    MLong size = (*i)->getElementSize();
    MString name = (*i)->getName();
    auto j = i + 1;
    while((j != g_allocatedObjects.end()) && ((*j)->getObjectId() == (*i)->getObjectId())) {
      size += (*j)->getElementSize();
      j++;
      i++;
    }
    count++;
    for(MInt k = 0; k < N; k++) {
      if(size > consumption[k]) {
        for(MInt l = N - 1; l > k; l--) {
          consumption[l] = consumption[l - 1];
        }
        consumption[k] = size;
        topConsumers.insert(topConsumers.begin() + k, name);
        topConsumers.pop_back();
        k = N;
      }
    }
  }
 
  N = mMin(N, count);
 
  for(MInt k = 0; k < padSize + 24; k++) {
    m_log << "_";
  }
  m_log << endl;
  m_log << "Freeing allocated memory...";
 
  reverse(g_allocatedObjects.begin(), g_allocatedObjects.end());
 
  for(auto& g_allocatedObject : g_allocatedObjects) {
#ifdef MAIA_EXTRA_DEBUG
    m_log << "Deallocating " << g_allocatedObject->getName() << " " << std::endl;
    m_log.flush();
#endif
    delete g_allocatedObject;
  }
  g_allocatedObjects.clear();
 
  m_log << " finished" << endl;
  m_log << "Maximum allocated memory was " << getMemorySize(maxAllocatedBytes()) << "." << endl;
  m_log << endl << "Top " << N << " (out of " << count << ") memory consumers are:" << endl;
  MChar buffer[100 + padSize];
  MLong sum = 0;
  for(MInt k = 0; k < N; k++) {
    sum += consumption[k];
    MString name(topConsumers[k], 0, mMin(std::size_t(padSize - 2), topConsumers[k].size()));
    name += ":";
    if(padSize > (signed)name.size()) {
      name.insert(name.end(), padSize - name.size(), ' ');
    }
    MString buf0 = name;
    MString buf1 = getMemorySize(consumption[k]);
    MFloat perc = 100.0 * ((static_cast<MFloat>(consumption[k])) / (static_cast<MFloat>(maxAllocatedBytes())));
    sprintf(buffer, "%3d%s %s %s %s%6.2f%s", k + 1, ".", buf0.c_str(), buf1.c_str(), "=", perc, "%");
    m_log << buffer << endl;
  }
  MString tmp;
  tmp.insert(tmp.end(), padSize + 6, ' ');
  tmp.insert(tmp.end(), 18, '-');
  m_log << tmp << endl;
  MString name;
  if(padSize > (signed)name.size()) {
    name.insert(name.end(), padSize - name.size(), ' ');
  }
  MString buf0 = name;
  MString buf1 = getMemorySize(sum);
  MFloat perc = 100.0 * ((static_cast<MFloat>(sum)) / (static_cast<MFloat>(maxAllocatedBytes())));
  sprintf(buffer, "%s%s %s %s %s%6.2f%s", "   ", " ", buf0.c_str(), buf1.c_str(), "=", perc, "%");
  m_log << buffer << endl;
 
  topConsumers.clear();
 
  if(allocatedBytes() > 0) {
    m_log << "Uncleared memory: " << getMemorySize(allocatedBytes()) << "." << endl;
  } else {
    m_log << "All memory cleared." << endl;
  }
  for(MInt k = 0; k < padSize + 24; k++) {
    m_log << "_";
  }
  m_log << endl << endl << endl;
}

mDeallocate()

template<class T >

MBool mDeallocate

(

T *&

a

)

Author

Lennart Schneiders

Date

09.12.2011

Definition at line 544 of file alloc.h.

                         {
  using namespace maia::alloc;
  if(a == nullptr) {
#ifdef MAIA_EXTRA_DEBUG
    m_log << "cannot deallocate zero pointer " << a << std::endl;
#endif
    return false;
  }
 
  std::vector<GenericObject*>::iterator hit;
  const MInt count = findAllocatedObject(a, hit);
 
#ifdef MAIA_EXTRA_DEBUG
  if(count > 0)
    m_log << "Deallocating " << (*hit)->getName() << "."
          << " " << &a << " " << count << std::endl;
  m_log.flush();
  if(count > 0)
    std::cerr << "Deallocating " << (*hit)->getName() << "."
              << " " << &a << " " << count << std::endl;
#endif
 
  if(count <= 0) {
#ifndef NDEBUG
    std::cerr << "mDeallocate error: " << count << " " << a << std::endl;
    if(count == 0) {
      std::cerr << "Pointer should have been reset to nullptr!" << std::endl;
    }
#endif
    a = nullptr;
    return false;
  }
 
 
  for(MInt k = count; k--;) {
    delete *(hit + k);
  }
 
  if(count == 1)
    g_allocatedObjects.erase(hit);
  else if(count > 1)
    g_allocatedObjects.erase(hit, hit + count);
 
  if(count > 0) {
    a = nullptr;
  }
 
  return (count > 0);
}

printAllocatedObjects() [1/2]

void printAllocatedObjects ( )

inline

Author

Julian Vorspohl

Date

20.06.2021

Definition at line 606 of file alloc.h.

                                    {
  for(auto&& obj : maia::alloc::g_allocatedObjects) {
#ifdef MAIA_EXTRA_DEBUG
    std::cout << "Name " << obj->getName() << " Function " << obj->getCallingFunction() << std::endl;
#else
    std::cout << "Name " << obj->getName() << std::endl;
#endif
  }
  std::cout << "Total number of allocated objects: " << maia::alloc::g_allocatedObjects.size() << std::endl;
}

printAllocatedObjects() [2/2]

void printAllocatedObjects ( const MString &  filterString )

inline

Author

Julian Vorspohl

Date

20.06.2021

Definition at line 623 of file alloc.h.

                                                               {
  for(auto&& obj : maia::alloc::g_allocatedObjects) {
    const MString fName = obj->getCallingFunction();
    const MBool containsFilterString = (fName.find(filterString) != std::string::npos);
    if(containsFilterString) {
      std::cout << filterString << ": Memory for " << obj->getName() << " from function " << fName
                << " should have been deallocated by now!" << std::endl;
    }
  }
}