Teuchos_Details_Allocator.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
 
#ifndef TEUCHOS_DETAILS_ALLOCATOR
#define TEUCHOS_DETAILS_ALLOCATOR
 
#include <Teuchos_ConfigDefs.hpp>
#include <iostream>
#include <limits>
#include <type_traits>
#include <typeinfo>
 
namespace Teuchos {
namespace Details {
 
class AllocationLogger {
public:
  typedef std::size_t size_type;
 
  static void
  logAllocation (std::ostream& out,
                 const size_type numEntries,
                 const size_type numBytes,
                 const char typeName[],
                 const bool verbose);
 
  static void
  logDeallocation (std::ostream& out,
                   const size_type numEntries,
                   const size_type numBytes,
                   const char typeName[],
                   const bool verbose);
 
  static size_type curAllocInBytes ();
 
  static size_type maxAllocInBytes ();
 
  static void resetAllocationCounts ();
 
private:
  static size_type curAllocInBytes_;
 
  static size_type maxAllocInBytes_;
};
 
template<class T>
class Allocator {
private:
  enum EAllocatorOp {
    ALLOCATOR_ALLOCATE,
    ALLOCATOR_DEALLOCATE
  };
 
  bool tracking () const { return track_; }
 
  bool verbose () const { return verbose_; }
 
  // This lets tracking() and verbose() stay private,
  // without breaking the templated copy constructor.
  template<class U>
  friend class Allocator;
 
public:
  typedef T value_type;
 
  typedef T* pointer;
  typedef const T* const_pointer;
  typedef T& reference;
  typedef const T& const_reference;
 
  typedef AllocationLogger::size_type size_type;
 
#ifdef HAVE_TEUCHOSCORE_CXX11
  typedef std::make_signed<size_type>::type difference_type;
#else
  typedef std::ptrdiff_t difference_type;
#endif // HAVE_TEUCHOSCORE_CXX11
 
  Allocator () :
    track_ (true), verbose_ (false)
  {}
 
  Allocator (const bool trackMemory,
             const bool verboseOutput) :
    track_ (trackMemory), verbose_ (verboseOutput)
  {}
 
  template<class U>
  Allocator (const Allocator<U>& src) :
    track_ (src.tracking ()), verbose_ (src.verbose ())
  {}
 
  template<class U>
  struct rebind { typedef Allocator<U> other; };
 
  size_type max_size() const {
    return std::numeric_limits<size_type>::max();
  }
 
  value_type* allocate (const size_type& n, const void* = 0) {
    if (tracking ()) {
      AllocationLogger::logAllocation (std::cerr, n, n * sizeof (value_type),
                                       typeid (value_type).name (), verbose_);
    }
    return (value_type*) (::operator new (n * sizeof (T)));
  }
 
  void deallocate (value_type* p, const size_type& n) {
    if (tracking ()) {
      // Thankfully, this method accepts the array size.  Thus, we don't
      // have to do tricks like allocating extra space and stashing the
      // size in the array.
      AllocationLogger::logDeallocation (std::cerr, n, n * sizeof (value_type),
                                         typeid (value_type).name (), verbose_);
    }
    ::operator delete ((void*) p);
  }
 
  size_type curAllocInBytes () {
    return AllocationLogger::curAllocInBytes ();
  }
 
  size_type maxAllocInBytes () {
    return AllocationLogger::maxAllocInBytes ();
  }
 
#ifndef HAVE_TEUCHOSCORE_CXX11
  void construct (pointer p, const_reference val) {
    new ((void*) p) T (val);
  }
#endif // HAVE_TEUCHOSCORE_CXX11
 
#ifndef HAVE_TEUCHOSCORE_CXX11
  void destroy (pointer p) {
    ((T*)p)->~T ();
  }
#endif // HAVE_TEUCHOSCORE_CXX11
 
private:
  bool track_;
  bool verbose_;
};
 
 
template<class T, class U>
bool operator== (const Allocator<T>&, const Allocator<U>&) {
  return true;
}
 
template<class T, class U>
bool operator!= (const Allocator<T>& a_t, const Allocator<U>& a_u) {
  return ! (a_t == a_u);
}
 
} // namespace Details
} // namespace Teuchos
 
#endif // TEUCHOS_DETAILS_ALLOCATOR