memory_consumption.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2000 - 2018 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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------

#ifndef dealii_memory_consumption_h
#define dealii_memory_consumption_h


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

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

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> &);
} // namespace MemoryConsumption



// 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();
  }
} // namespace MemoryConsumption

DEAL_II_NAMESPACE_CLOSE

#endif