vector_memory.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2017 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>

DEAL_II_NAMESPACE_OPEN



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

  virtual ~VectorMemory () {}

  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:
    Pointer(VectorMemory<VectorType> &mem);
    ~Pointer();

    operator VectorType *() const;

    VectorType &operator * () const;

    VectorType *operator -> () const;

  private:
    SmartPointer<VectorMemory<VectorType>,Pointer> pool;

    VectorType *v;
  };
};



template<typename VectorType = ::Vector<double> >
class PrimitiveVectorMemory : public VectorMemory<VectorType>
{
public:
  PrimitiveVectorMemory () {}

  virtual VectorType *alloc ()
  {
    return new VectorType();
  }

  virtual void free (const VectorType *const v)
  {
    delete 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, 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 GrowingVectorMemory
  {
    void release_all_unused_memory();
  }
}

#ifndef DOXYGEN
/* --------------------- inline functions ---------------------- */


template <typename VectorType>
inline
VectorMemory<VectorType>::Pointer::Pointer(VectorMemory<VectorType> &mem)
  :
  pool(&mem, typeid(*this).name()), v(0)
{
  v = pool->alloc();
}


template <typename VectorType>
inline
VectorMemory<VectorType>::Pointer::~Pointer()
{
  try
    {
      pool->free(v);
    }
  catch (...)
    {}
}


template <typename VectorType>
inline
VectorMemory<VectorType>::Pointer::operator VectorType *() const
{
  return v;
}


template <typename VectorType>
inline
VectorType &VectorMemory<VectorType>::Pointer::operator * () const
{
  return *v;
}


template <typename VectorType>
inline
VectorType *VectorMemory<VectorType>::Pointer::operator -> () const
{
  return v;
}


#endif // DOXYGEN

DEAL_II_NAMESPACE_CLOSE

#endif