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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_vector_memory_h
#define dealii_vector_memory_h


#include <deal.II/base/config.h>
#include <deal.II/base/smartpointer.h>
#include <deal.II/base/logstream.h>
#include <deal.II/base/thread_management.h>
#include <deal.II/lac/vector.h>

#include <vector>
#include <iostream>
#include <memory>

DEAL_II_NAMESPACE_OPEN



template <typename VectorType = ::Vector<double> >
class VectorMemory : public Subscriptor
{
public:

  virtual ~VectorMemory () = 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 ();

  virtual void free (const VectorType *const v);
};



template <typename VectorType = ::Vector<double> >
class GrowingVectorMemory : public VectorMemory<VectorType>
{
public:
  typedef types::global_dof_index size_type;

  GrowingVectorMemory (const size_type initial_size = 0,
                       const bool log_statistics = false);

  virtual ~GrowingVectorMemory();

  virtual VectorType *alloc ();

  virtual void free (const VectorType *const);

  static void release_unused_memory ();

  virtual std::size_t memory_consumption() const;

private:
  typedef std::pair<bool, std::unique_ptr<VectorType> > entry_type;

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

#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