memory_consumption.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2000 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.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 <optional>
#include <string>
#include <type_traits>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
namespace MemoryConsumption
{
  template <typename T>
  inline std::enable_if_t<std::is_fundamental_v<T>, std::size_t>
  memory_consumption(const T &t);
 
  template <typename T>
  inline std::enable_if_t<!(std::is_fundamental_v<T> || std::is_pointer_v<T>),
                          std::size_t>
  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, std::size_t width>
  inline std::size_t
  memory_consumption(const VectorizedArray<T, width> &);
 
  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 A>
  inline std::size_t
  memory_consumption(const std::optional<A> &o);
 
  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 std::enable_if_t<std::is_fundamental_v<T>, std::size_t>
  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, std::size_t width>
  inline std::size_t
  memory_consumption(const VectorizedArray<T, width> &)
  {
    return sizeof(VectorizedArray<T, width>);
  }
 
 
 
  inline std::size_t
  memory_consumption(const std::string &s)
  {
    return sizeof(s) + s.size();
  }
 
 
 
  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_v<T> || std::is_pointer_v<T>)
      {
        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_v<T> || std::is_pointer_v<T>)
      {
        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 A>
  inline std::size_t
  memory_consumption(const std::optional<A> &o)
  {
    if (o.has_value())
      {
        //
        // If the optional carries a value then we query the contained
        // value for memory consumption and estimate the size of the
        // control overhead.
        //
        return memory_consumption(o.value()) + sizeof(o) - sizeof(A);
      }
    else
      {
        //
        // The optional contains no value, so simply return its plain size
        // (consisting of space for the value and control overhead):
        //
        return sizeof(o);
      }
  }
 
 
 
  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 std::enable_if_t<!(std::is_fundamental_v<T> || std::is_pointer_v<T>),
                          std::size_t>
  memory_consumption(const T &t)
  {
    return t.memory_consumption();
  }
} // namespace MemoryConsumption
 
DEAL_II_NAMESPACE_CLOSE
 
#endif