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 int nAllocate();
 
      static int nDeallocate();
 
      static int total();
 
      static int max();
 
      #ifdef UTIL_MPI
      static int max(MPI::Intracomm& communicator);
      #endif
 
      static void initStatic();
   
   private: 
 
      static int total_;
   
      static int max_;
   
      static int nAllocate_;
   
      static 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];
         total_ += (size*sizeof(Data));
         ++nAllocate_;
         if (total_ > max_) max_ = total_;
      } catch (std::bad_alloc&) {
         std::cout << "Allocation error" << std::endl;
         throw;
      }
   }
 
   /*
   * De-allocate a C array.
   */
   template <typename Data>
   void Memory::deallocate(Data*& ptr, size_t size)
   {
      // Preconditions
      UTIL_CHECK(ptr);
      UTIL_CHECK(size > 0);
 
      delete [] ptr;
      ptr = 0;
      total_ -= size*sizeof(Data);
      ++nDeallocate_;
   }
 
   /*
   * Re-allocate a C array (allocate 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 = 0;
      allocate(newPtr, newSize);
      if (oldSize > 0) {
         UTIL_CHECK(ptr);
         for (size_t i = 0; i < oldSize; ++i) {
            newPtr[i] = ptr[i];
         }
         Data* oldPtr = ptr;
         deallocate(oldPtr, oldSize);
      }
      ptr = newPtr;
   }
 
} 
#endif