vector_memory.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 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_vector_memory_h
#define dealii_vector_memory_h


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

#include <deal.II/base/logstream.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/thread_management.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 Subscriptor
{
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 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