Memory.h

#ifndef UTIL_MEMORY_H
#define UTIL_MEMORY_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/global.h>
#include <stddef.h>
#include <iostream>
#include <new>
 
namespace Util
{

   class Memory
   { 
   public:

      template <typename Data>
      static void allocate(Data*& ptr, size_t size);

      template <typename Data>
      static void deallocate(Data*& ptr, size_t size);

      template <typename Data>
      static void reallocate(Data*& ptr, size_t oldSize, size_t newSize);

      static long int nAllocate();

      static long int nDeallocate();

      static long int total();

      static long int max();
 
      #ifdef UTIL_MPI
      static long int max(MPI::Intracomm& communicator);
      #endif

      static void initStatic();
   
   private: 

      static long int total_;
   
      static long int max_;
   
      static long int nAllocate_;
   
      static long int nDeallocate_;
   
   };
   
   /*
   * Allocate a C array.
   */
   template <typename Data>
   void Memory::allocate(Data*& ptr, size_t size)
   {
      if (ptr) {
         UTIL_THROW("Attempt to allocate to non-null pointer");
      }
      try {
         ptr = new Data[size];
         UTIL_CHECK(ptr);
         total_ += size * sizeof(Data);
         ++nAllocate_;
         if (total_ > max_) max_ = total_;
      } catch (std::bad_alloc&) {
         std::cout << "Allocation error in Util::Memory" << std::endl;
         throw;
      }
   }
 
   /*
   * De-allocate a C array that was allocated with Memory::allocate.
   */
   template <typename Data>
   void Memory::deallocate(Data*& ptr, size_t size)
   {
      // Preconditions
      UTIL_CHECK(ptr);
      UTIL_CHECK(size > 0);
 
      delete [] ptr;
      ptr = nullptr;
      long int change = size * sizeof(Data);
      UTIL_CHECK(total_ >= change);
      total_ -= change;
      ++nDeallocate_;
   }
 
   /*
   * Re-allocate a C array (allocate new memory and copy).
   */
   template <typename Data>
   void Memory::reallocate(Data*& ptr, size_t oldSize, size_t newSize)
   {
      UTIL_CHECK(newSize > 0);
      UTIL_CHECK(newSize > oldSize);
 
      Data* newPtr = nullptr;
      allocate(newPtr, newSize);
      if (oldSize > 0) {
         UTIL_CHECK(ptr);
         for (size_t i = 0; i < oldSize; ++i) {
            newPtr[i] = ptr[i];
         }
         deallocate(ptr, oldSize);
      }
      ptr = newPtr;
   }
 
} 
#endif