Teuchos_Details_Allocator.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @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