memory_consumption.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2017 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_memory_consumption_h
#define dealii_memory_consumption_h


#include <deal.II/base/config.h>

#include <string>
#include <complex>
#include <vector>
#include <cstddef>
#include <cstring>
#include <memory>
#include <array>
#include <type_traits>

DEAL_II_NAMESPACE_OPEN


// forward declaration
template <typename T> class VectorizedArray;


namespace MemoryConsumption
{
  template <typename T>
  inline
  typename std::enable_if<std::is_fundamental<T>::value, std::size_t>::type
  memory_consumption (const T &t);

  template <typename T>
  inline
  typename std::enable_if<!(std::is_fundamental<T>::value || std::is_pointer<T>::value), std::size_t>::type
  memory_consumption (const T &t);

  inline
  std::size_t memory_consumption (const char *string);

  template <typename T>
  inline
  std::size_t memory_consumption (const std::complex<T> &);

  template <typename T>
  inline
  std::size_t memory_consumption (const VectorizedArray<T> &);

  inline
  std::size_t memory_consumption (const std::string &s);

  template <typename T>
  inline
  std::size_t memory_consumption (const std::vector<T> &v);

  template <typename T, std::size_t N>
  inline
  std::size_t memory_consumption (const std::array<T,N> &v);

  template <typename T, int N>
  inline
  std::size_t memory_consumption (const T (&v)[N]);

  inline
  std::size_t memory_consumption (const std::vector<bool> &v);

  template <typename A, typename B>
  inline
  std::size_t memory_consumption (const std::pair<A,B> &p);

  template <typename T>
  inline
  std::size_t
  memory_consumption (const T *const);

  template <typename T>
  inline
  std::size_t memory_consumption (const std::shared_ptr<T> &);

  template <typename T>
  inline
  std::size_t memory_consumption (const std::unique_ptr<T> &);
}



// now comes the implementation of these functions

namespace MemoryConsumption
{
  template <typename T>
  inline
  typename std::enable_if<std::is_fundamental<T>::value, std::size_t>::type
  memory_consumption(const T &)
  {
    return sizeof(T);
  }



  inline
  std::size_t memory_consumption (const char *string)
  {
    if (string == nullptr)
      {
        return 0;
      }
    else
      {
        return sizeof(char)*(strlen(string) /*Remember the NUL*/ + 1);
      }
  }



  template <typename T>
  inline
  std::size_t memory_consumption (const std::complex<T> &)
  {
    return sizeof(std::complex<T>);
  }



  template <typename T>
  inline
  std::size_t memory_consumption (const VectorizedArray<T> &)
  {
    return sizeof(VectorizedArray<T>);
  }



  inline
  std::size_t memory_consumption (const std::string &s)
  {
    return sizeof(s) + s.length();
  }



  template <typename T>
  std::size_t memory_consumption (const std::vector<T> &v)
  {
    // shortcut for types that do not allocate memory themselves
    if (std::is_fundamental<T>::value || std::is_pointer<T>::value)
      {
        return v.capacity()*sizeof(T) + sizeof(v);
      }
    else
      {
        std::size_t mem = sizeof(std::vector<T>);
        for (unsigned int i=0; i<v.size(); ++i)
          {
            mem += memory_consumption(v[i]);
          }
        mem += (v.capacity() - v.size())*sizeof(T);
        return mem;
      }
  }



  template <typename T, std::size_t N>
  std::size_t memory_consumption (const std::array<T,N> &v)
  {
    // shortcut for types that do not allocate memory themselves
    if (std::is_fundamental<T>::value || std::is_pointer<T>::value)
      {
        return sizeof(v);
      }
    else
      {
        std::size_t mem = 0;
        for (std::size_t i=0; i!=N; ++i)
          mem += memory_consumption(v[i]);
        return mem;
      }
  }



  template <typename T, int N>
  std::size_t memory_consumption (const T (&v)[N])
  {
    std::size_t mem = 0;
    for (unsigned int i=0; i<N; ++i)
      mem += memory_consumption(v[i]);
    return mem;
  }



  inline
  std::size_t memory_consumption (const std::vector<bool> &v)
  {
    return v.capacity() / 8 + sizeof(v);
  }



  template <typename A, typename B>
  inline
  std::size_t memory_consumption (const std::pair<A,B> &p)
  {
    return (memory_consumption(p.first) +
            memory_consumption(p.second));
  }



  template <typename T>
  inline
  std::size_t
  memory_consumption(const T *const)
  {
    return sizeof(T *);
  }



  template <typename T>
  inline
  std::size_t
  memory_consumption (const std::shared_ptr<T> &)
  {
    return sizeof(std::shared_ptr<T>);
  }



  template <typename T>
  inline
  std::size_t
  memory_consumption (const std::unique_ptr<T> &)
  {
    return sizeof(std::unique_ptr<T>);
  }



  template <typename T>
  inline
  typename std::enable_if<!(std::is_fundamental<T>::value || std::is_pointer<T>::value), std::size_t>::type
  memory_consumption (const T &t)
  {
    return t.memory_consumption();
  }
}

DEAL_II_NAMESPACE_CLOSE

#endif