fixed_size_memory_pool.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
//
 
 
#if !defined(KRATOS_FIXED_SIZE_MEMORY_POOL_H_INCLUDED )
#define  KRATOS_FIXED_SIZE_MEMORY_POOL_H_INCLUDED
 
#include <vector>
#include <list>
 
#include "includes/thread_fixed_size_memory_pool.h"
 
namespace Kratos
{
 
 
 
  class FixedSizeMemoryPool : public LockObject
    {
    public:
 
        using SizeType = Chunk::SizeType;
 
 
        static constexpr SizeType DefaultChunkSize = 1024*1024; // 1M byte
 
 
      FixedSizeMemoryPool() = delete;
 
      FixedSizeMemoryPool(FixedSizeMemoryPool const& rOther) = delete;
 
      FixedSizeMemoryPool(std::size_t BlockSizeInBytes, SizeType ChunkSize = DefaultChunkSize)
          : LockObject()
          , mChunkSize(ChunkSize)
      {
          for (int i_thread = 0; i_thread < OpenMPUtils::GetCurrentNumberOfThreads(); i_thread++)
              mThreadsPool.emplace_back(BlockSizeInBytes, ChunkSize, i_thread);
      }
 
      virtual ~FixedSizeMemoryPool() {
 
      }
 
 
      FixedSizeMemoryPool& operator=(FixedSizeMemoryPool const& rOther) = delete;
 
 
      void* Allocate() {
          void* p_result = mThreadsPool[OpenMPUtils::ThisThread()].Allocate();
          return p_result;
      }
 
      void Deallocate(void* pPointrerToRelease) {
 
          if (mThreadsPool[OpenMPUtils::ThisThread()].Deallocate(pPointrerToRelease))
          {
              return;
          }
 
          for (int i_thread = 0; i_thread < OpenMPUtils::GetCurrentNumberOfThreads(); i_thread++)
              if (i_thread != OpenMPUtils::ThisThread())
                  if (mThreadsPool[i_thread].Deallocate(pPointrerToRelease)) {
                      return;
                  }
 
          KRATOS_ERROR << "The Pointer with address " << pPointrerToRelease << " was not found in this pool" << std::endl;
      }
 
      std::size_t MemoryUsed() const {
          std::size_t memory_used = sizeof(FixedSizeMemoryPool);
          for (int i_thread = 0; i_thread < OpenMPUtils::GetCurrentNumberOfThreads(); i_thread++)
              memory_used += mThreadsPool[i_thread].MemoryUsed();
          return memory_used;
      }
 
      std::size_t MemoryOverhead() const {
          std::size_t memory_overhead = sizeof(FixedSizeMemoryPool);
          for (int i_thread = 0; i_thread < OpenMPUtils::GetCurrentNumberOfThreads(); i_thread++)
              memory_overhead += mThreadsPool[i_thread].MemoryOverhead();
          return memory_overhead;
      }
 
      std::size_t GetNumberOfAllocatedChunks() const {
          std::size_t number_of_allocated_chunks = 0;
          for (int i_thread = 0; i_thread < OpenMPUtils::GetCurrentNumberOfThreads(); i_thread++)
              number_of_allocated_chunks += mThreadsPool[i_thread].GetNumberOfChunks() - mThreadsPool[i_thread].GetNumberOfReleasedChunks();
          return number_of_allocated_chunks;
      }
 
 
      SizeType ChunkSize() const {
          return mChunkSize;
      }
 
 
 
      std::string Info() const {
          return "FixedSizeMemoryPool";
      }
 
      void PrintInfo(std::ostream& rOStream) const {
          rOStream << Info();
      }
 
      void PrintData(std::ostream& rOStream) const {
          std::size_t memory_used = MemoryUsed();
          std::size_t memory_overhead = MemoryOverhead();
          double overhead_percentage = memory_overhead;
          if (memory_overhead < memory_used)
              overhead_percentage = static_cast<double>(memory_overhead)/(memory_used - memory_overhead);
          overhead_percentage *= 100.00;
 
          rOStream << GetNumberOfAllocatedChunks() << " Chunks of "
              << SizeInBytesToString(ChunkSize()) << " bytes each. Total memory usage: "
              << SizeInBytesToString(MemoryUsed()) << " bytes and memory overhead "
              << SizeInBytesToString(MemoryOverhead()) << "(" << overhead_percentage << "%)" << std::endl;
      }
 
 
 
    private:
 
        SizeType mChunkSize;
        std::vector<ThreadFixedSizeMemoryPool> mThreadsPool;
 
 
        std::string SizeInBytesToString(std::size_t Bytes) const {
            std::stringstream buffer;
            double result = Bytes;
            constexpr int units_size = 5;
            constexpr char units[units_size] = { ' ', 'k','M','G','T' };
            int i = 0;
            for (; i < units_size; i++)
                if (result > 1024)
                {
                    result /= 1024;
                }
                else
                    break;
            buffer << result << units[i];
 
            return buffer.str();
        }
 
 
 
    }; // Class FixedSizeMemoryPool
 
 
 
  inline std::ostream& operator << (std::ostream& rOStream,
                    const FixedSizeMemoryPool& rThis)
    {
      rThis.PrintInfo(rOStream);
      rOStream << std::endl;
      rThis.PrintData(rOStream);
 
      return rOStream;
    }
 
 
}  // namespace Kratos.
 
#endif // KRATOS_FIXED_SIZE_MEMORY_POOL_H_INCLUDED  defined