FileMappedStorage.h

Go to the documentation of this file.

#pragma once
#include <gii/global.h>
#include <iostream>
#include <misc/gen/IFileMapper.h>
#include <misc/gen/TVector.h>
#include <misc/gen/Thread.h>
 
namespace sf
{
 
class _GII_CLASS FileMappedStorage
{
  public:
    typedef uint64_t size_type;
 
    static constexpr size_t npos = std::numeric_limits<size_type>::max();
 
    FileMappedStorage(size_type seg_sz, size_type blk_sz, size_type recycle = 0);
 
    FileMappedStorage(const FileMappedStorage&);
 
    virtual ~FileMappedStorage();
 
    bool reserve(size_type block_count);
 
    void flush();
 
    inline bool blockWrite(size_type ofs, size_type sz, const void* src);
 
    inline bool blockRead(size_type ofs, size_type sz, void* dst) const;
 
    [[nodiscard]] size_type getBlockCount() const;
 
    [[nodiscard]] size_type getSegmentCount() const;
 
    [[nodiscard]] size_type getSegmentLocks() const;
 
    [[nodiscard]] size_type getBlockSize() const;
 
    [[nodiscard]] size_type getSegmentSize() const;
 
    [[nodiscard]] size_type getSize() const;
 
    [[nodiscard]] inline size_type getRecycleCount() const;
 
    bool setRecycleCount(size_type count);
 
    std::ostream& writeStatus(std::ostream& os) const;
 
  private:
    bool blockReadWrite(bool rd, size_type ofs, size_type sz, void* src);
 
    class Segment
    {
      public:
        explicit Segment(size_type sz);
 
        ~Segment();
 
        [[nodiscard]] inline bool isLocked() const;
 
        [[nodiscard]] inline size_type getSize() const;
 
        [[nodiscard]] inline void* lockMemory();
 
        [[nodiscard]] inline const void* lockMemory() const;
 
        inline void unlockMemory() const;
 
        bool write(size_type ofs, size_type sz, const void* src);
 
        bool read(size_type ofs, size_type sz, void* dst) const;
 
        Segment(Segment&) = delete;
 
        Segment& operator=(Segment&) = delete;
 
      protected:
        bool doLockMemory();
 
        void doUnlockMemory();
 
      private:
        int _lockCount{0};
        size_type _size{0};
        char* _dataPtr{nullptr};
        IFileMapper& _fileMapper;
 
        friend class FileMappedStorage;
    };
 
    struct Reference
    {
        Reference();
 
        ~Reference();
 
        Thread::id_type _threadId{0};
        size_type _blockSize{0};
        size_type _segmentSize{0};
        int _referenceCount{0};
        TVector<Segment*> _segmentList;
        Mutex _mutex;
        typedef Mutex::Lock MtLock;
    };
 
    Reference* _reference{nullptr};
 
  public:
    class _GII_CLASS Lock
    {
      public:
        explicit inline Lock(FileMappedStorage& ds);
 
        inline Lock(FileMappedStorage& ds, size_type seg_idx);
 
        ~Lock();
 
        bool acquire(size_type seg_idx);
 
        [[nodiscard]] bool isAcquired() const;
 
        explicit operator bool() const;
 
        void* data(size_type blk_ofs);
 
        template<typename T = void*>
        T* ptr(size_type blk_ofs)
        {
          return static_cast<T*>(data(blk_ofs));
        }
 
        void release();
 
      private:
        FileMappedStorage& _store;
        size_type _segmentIndex{0};
        size_type _blockSize{0};
        Segment* _segment{nullptr};
        void* _data{nullptr};
    };
 
  private:
    bool cacheSegment(size_type idx);
 
    void uncacheSegment(size_type idx);
 
    size_type _cachedSegmentIndex{npos};
    size_type _segmentRecycleCount{0};
    static Mutex _staticSync;
};
 
inline FileMappedStorage::size_type FileMappedStorage::Segment::getSize() const
{
  return _size;
}
 
inline bool FileMappedStorage::Segment::isLocked() const
{
  return (_lockCount > 0);
}
 
inline void* FileMappedStorage::Segment::lockMemory()
{
  doLockMemory();
  return _dataPtr;
}
 
inline const void* FileMappedStorage::Segment::lockMemory() const
{
  const_cast<Segment*>(this)->doLockMemory();
  return const_cast<Segment*>(this)->_dataPtr;
}
 
inline void FileMappedStorage::Segment::unlockMemory() const
{
  const_cast<Segment*>(this)->doUnlockMemory();
}
 
inline bool FileMappedStorage::blockWrite(size_type ofs, size_type sz, const void* src)
{
  return blockReadWrite(false, ofs, sz, (void*) src);
}
 
inline bool FileMappedStorage::blockRead(size_type ofs, size_type sz, void* dst) const
{
  return const_cast<FileMappedStorage*>(this)->blockReadWrite(true, ofs, sz, dst);
}
 
inline FileMappedStorage::size_type FileMappedStorage::getRecycleCount() const
{
  return _segmentRecycleCount;
}
 
inline FileMappedStorage::Lock::Lock(FileMappedStorage& ds)
  : _store(ds)
  , _blockSize(ds.getBlockSize())
{}
 
inline FileMappedStorage::Lock::Lock(FileMappedStorage& ds, size_type seg_idx)
  : _store(ds)
  , _segmentIndex(-1)
  , _blockSize(ds.getBlockSize())
{
  acquire(seg_idx);
}
 
inline FileMappedStorage::Lock::~Lock()
{
  release();
}
 
inline bool FileMappedStorage::Lock::isAcquired() const
{
  return _data != nullptr;
}
 
inline FileMappedStorage::Lock::operator bool() const
{
  return isAcquired();
}
 
}// namespace sf