vector_memory.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 1998 - 2024 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_vector_memory_h
#define dealii_vector_memory_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/mutex.h>
#include <deal.II/base/observer_pointer.h>
 
#include <deal.II/lac/vector.h>
 
#include <iostream>
#include <memory>
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
 
template <typename VectorType = ::Vector<double>>
class VectorMemory : public EnableObserverPointer
{
public:
  virtual ~VectorMemory() override = default;
 
  virtual VectorType *
  alloc() = 0;
 
  virtual void
  free(const VectorType *const) = 0;
 
  DeclExceptionMsg(
    ExcNotAllocatedHere,
    "You are trying to deallocate a vector from a memory pool, but this "
    "vector has not actually been allocated by the same pool before.");
 
  class Pointer
    : public std::unique_ptr<VectorType, std::function<void(VectorType *)>>
  {
  public:
    Pointer() = default;
 
    Pointer(Pointer &&p) noexcept = default;
 
    Pointer &
    operator=(Pointer &&p) noexcept = default;
 
    Pointer(VectorMemory<VectorType> &mem);
 
    ~Pointer() = default;
  };
};
 
 
 
template <typename VectorType = ::Vector<double>>
class PrimitiveVectorMemory : public VectorMemory<VectorType>
{
public:
  virtual VectorType *
  alloc() override;
 
  virtual void
  free(const VectorType *const v) override;
};
 
 
 
template <typename VectorType = ::Vector<double>>
class GrowingVectorMemory : public VectorMemory<VectorType>
{
public:
  using size_type = types::global_dof_index;
 
  GrowingVectorMemory(const size_type initial_size   = 0,
                      const bool      log_statistics = false);
 
  virtual ~GrowingVectorMemory() override;
 
  virtual VectorType *
  alloc() override;
 
  virtual void
  free(const VectorType *const) override;
 
  static void
  release_unused_memory();
 
  virtual std::size_t
  memory_consumption() const;
 
private:
  using entry_type = std::pair<bool, std::unique_ptr<VectorType>>;
 
  struct Pool
  {
    Pool();
 
    ~Pool();
 
    void
    initialize(const size_type size);
 
    std::vector<entry_type> *data;
  };
 
  static Pool &
  get_pool();
 
  size_type total_alloc;
 
  size_type current_alloc;
 
  bool log_statistics;
 
  static Threads::Mutex mutex;
};
 
 
 
namespace internal
{
  namespace GrowingVectorMemoryImplementation
  {
    void
    release_all_unused_memory();
  }
} // namespace internal
 
#ifndef DOXYGEN
/* --------------------- inline functions ---------------------- */
 
 
template <typename VectorType>
inline VectorMemory<VectorType>::Pointer::Pointer(VectorMemory<VectorType> &mem)
  : std::unique_ptr<VectorType, std::function<void(VectorType *)>>(
      mem.alloc(),
      [&mem](VectorType *v) { mem.free(v); })
{}
 
 
 
template <typename VectorType>
VectorType *
PrimitiveVectorMemory<VectorType>::alloc()
{
  return new VectorType();
}
 
 
 
template <typename VectorType>
void
PrimitiveVectorMemory<VectorType>::free(const VectorType *const v)
{
  delete v;
}
 
 
 
#endif // DOXYGEN
 
DEAL_II_NAMESPACE_CLOSE
 
#endif