DiskBuffer.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MantidKernel/FreeBlock.h"
#include "MantidKernel/System.h"
#ifndef Q_MOC_RUN
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
#include <boost/multi_index_container.hpp>
#endif
#include <cstdint>
#include <limits>
#include <list>
#include <mutex>
#include <string>
#include <vector>
 
namespace Mantid {
namespace Kernel {
 
// Forward declare
class ISaveable;
 
class MANTID_KERNEL_DLL DiskBuffer {
public:
  using freeSpace_t = boost::multi_index::multi_index_container<
      FreeBlock, boost::multi_index::indexed_by<
                     boost::multi_index::ordered_non_unique<
                         ::boost::multi_index::const_mem_fun<FreeBlock, uint64_t, &FreeBlock::getFilePosition>>,
                     boost::multi_index::ordered_non_unique<
                         ::boost::multi_index::const_mem_fun<FreeBlock, uint64_t, &FreeBlock::getSize>>>>;
 
  using freeSpace_bySize_t = freeSpace_t::nth_index<1>::type;
 
  DiskBuffer();
  DiskBuffer(uint64_t m_writeBufferSize);
  DiskBuffer(const DiskBuffer &) = delete;
  DiskBuffer &operator=(const DiskBuffer &) = delete;
  virtual ~DiskBuffer() = default;
 
  void toWrite(ISaveable *item);
  void flushCache();
  void objectDeleted(ISaveable *item);
 
  // Free space map methods
  void freeBlock(uint64_t const pos, uint64_t const size);
  void defragFreeBlocks();
 
  // Allocating
  uint64_t allocate(uint64_t const newSize);
  uint64_t relocate(uint64_t const oldPos, uint64_t const oldSize, const uint64_t newSize);
 
  // For reporting and saving
  void getFreeSpaceVector(std::vector<uint64_t> &free) const;
  void setFreeSpaceVector(std::vector<uint64_t> &free);
  std::string getMemoryStr() const;
 
  //-------------------------------------------------------------------------------------------
  void setWriteBufferSize(uint64_t buffer) {
    if (buffer > std::numeric_limits<size_t>::max() / 2)
      throw std::runtime_error(" Can not aloocate memory for that many events "
                               "on given architecture ");
 
    m_writeBufferSize = static_cast<size_t>(buffer);
  }
 
  uint64_t getWriteBufferSize() const { return m_writeBufferSize; }
 
  uint64_t getWriteBufferUsed() const { return m_writeBufferUsed; }
 
  //-------------------------------------------------------------------------------------------
  freeSpace_t &getFreeSpaceMap() { return m_free; }
 
  //-------------------------------------------------------------------------------------------
  uint64_t getFileLength() const { return m_fileLength; }
 
  void setFileLength(const uint64_t length) const { m_fileLength = length; }
 
  //-------------------------------------------------------------------------------------------
 
protected:
  inline void writeOldObjects();
 
  // ----------------------- To-write buffer
  // --------------------------------------
  // bool m_useWriteBuffer;
 
  size_t m_writeBufferSize;
 
  size_t m_writeBufferUsed;
  size_t m_nObjectsToWrite;
  std::list<ISaveable *> m_toWriteBuffer;
 
  std::mutex m_mutex;
 
  // ----------------------- Free space map
  // --------------------------------------
  freeSpace_t m_free;
 
  freeSpace_bySize_t &m_free_bySize;
 
  std::mutex m_freeMutex;
 
  // ----------------------- File object --------------------------------------
  mutable uint64_t m_fileLength;
 
private:
};
 
} // namespace Kernel
} // namespace Mantid