ah-map-arena.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
#ifndef AH_MAP_ARENA_H
#define AH_MAP_ARENA_H
 
// ---------------------------------------------------------------------------
// Platform gating.
//
// `MapArena` depends on Linux-specific APIs that have no portable POSIX
// counterpart:
//
//   * `mremap()` and `MREMAP_MAYMOVE` (used by `remap()` to grow the
//     backing region in place).
//   * `MAP_POPULATE` (used to pre-fault pages on mmap).
//
// macOS / BSD / Windows lack these. Rather than synthesise a fragile
// portable fallback (a `munmap()` + `mmap()` cycle invalidates every
// pointer the caller is holding), we make `MapArena` a Linux-only
// feature. The header is still includable on other platforms — it
// simply declares no symbols there. Tests and clients gate their use
// behind `ALEPH_HAS_MAP_ARENA`.
// ---------------------------------------------------------------------------
 
#if defined(__linux__)
#  define ALEPH_HAS_MAP_ARENA 1
#else
#  define ALEPH_HAS_MAP_ARENA 0
#endif
 
#if ALEPH_HAS_MAP_ARENA
 
#include <unistd.h>
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <filesystem>
#include <fcntl.h>
#include <sys/mman.h>
#include <string>
 
#include <ah-errors.H>
 
namespace fs = std::filesystem;
 
namespace Aleph
{
 
class MapArena
{
public:
 
  static constexpr size_t initial_rgn_size = 4 * 1024;
 
private:
 
  char * rgn_ptr = nullptr;   
  size_t end_ = 0;            
  size_t rgn_size = initial_rgn_size;  
  int fd = -1;                
 
  bool remap(const size_t sz)
  {
    assert(sz > avail());
 
    // Determine new region size according to requested sz
    size_t new_size = 2 * rgn_size;
    while (new_size - end_ < sz)
      new_size *= 2;
 
    void * ptr = mremap(rgn_ptr, rgn_size, new_size, MREMAP_MAYMOVE);
    if (ptr == MAP_FAILED)
      return false;
 
    const auto status = ftruncate(fd, static_cast<off_t>(new_size));
    ah_runtime_error_unless(status == 0)
        << "cannot truncate the file to " << new_size << " error = " << errno;
 
    rgn_ptr = static_cast<char*>(ptr);
    rgn_size = new_size;
 
    return true;
  }
 
public:
 
  using iterator = char *;
 
  using const_iterator = const char *;
 
  using size_type = size_t;
 
  void init(const std::string & file_path_name, void * addr = nullptr)
  {
    end_ = 0;
    if (fs::exists(fs::path(file_path_name)))
      {
        fd = open(file_path_name.c_str(), O_RDWR, static_cast<mode_t>(0600));
        ah_runtime_error_unless(fd >= 0) << "cannot open " << file_path_name;
 
        // Read end_ value stored at the beginning of file
        const auto status = ::read(fd, &end_, sizeof(end_));
        ah_runtime_error_unless(status != -1)
          << "Cannot read file length of " << file_path_name;
 
        // Determine file size
        const auto file_size = lseek(fd, 0, SEEK_END);
        ah_runtime_error_unless(file_size != static_cast<off_t>(-1))
          << "Cannot determine file length of " << file_path_name;
        rgn_size = static_cast<size_t>(file_size);
      }
    else
      {
        fd = open(file_path_name.c_str(), O_RDWR | O_CREAT, static_cast<mode_t>(0600));
        ah_runtime_error_unless(fd >= 0) << "cannot open " << file_path_name;
        const auto status = ftruncate(fd, static_cast<off_t>(rgn_size));
        ah_runtime_error_unless(status == 0)
          << "cannot truncate the file to " << rgn_size << " error = " << errno;
      }
 
    void *ptr = mmap(addr, rgn_size, PROT_READ | PROT_WRITE,
                     MAP_SHARED | MAP_POPULATE, fd, 0);
    ah_runtime_error_unless(ptr != MAP_FAILED)
        << "Cannot mmap. Error = " << errno;
 
    rgn_ptr = static_cast<char*>(ptr);
  }
 
  void init_and_erase(const std::string & file_path_name)
  {
    fs::remove(file_path_name);
    init(file_path_name);
  }
 
  explicit MapArena(const std::string & file_path_name)
  {
    init(file_path_name);
  }
 
  MapArena() noexcept = default;
 
  MapArena(const MapArena &) = delete;
 
  MapArena & operator=(const MapArena &) = delete;
 
  MapArena(MapArena && other) noexcept
    : rgn_ptr(other.rgn_ptr), end_(other.end_),
      rgn_size(other.rgn_size), fd(other.fd)
  {
    other.rgn_ptr = nullptr;
    other.end_ = 0;
    other.rgn_size = initial_rgn_size;
    other.fd = -1;
  }
 
  MapArena & operator=(MapArena && other) noexcept
  {
    if (this != &other)
      {
        // Clean up current resources
        if (rgn_ptr)
          munmap(rgn_ptr, rgn_size);
        if (fd != -1)
          close(fd);
 
        // Transfer ownership
        rgn_ptr = other.rgn_ptr;
        end_ = other.end_;
        rgn_size = other.rgn_size;
        fd = other.fd;
 
        // Invalidate other
        other.rgn_ptr = nullptr;
        other.end_ = 0;
        other.rgn_size = initial_rgn_size;
        other.fd = -1;
      }
    return *this;
  }
 
  ~MapArena()
  {
    if (rgn_ptr)
      munmap(rgn_ptr, rgn_size);
    if (fd != -1)
      close(fd);
  }
 
  [[nodiscard]] iterator begin() noexcept { return rgn_ptr; }
 
  [[nodiscard]] const_iterator begin() const noexcept { return rgn_ptr; }
 
  [[nodiscard]] iterator end() noexcept { return rgn_ptr + end_; }
 
  [[nodiscard]] const_iterator end() const noexcept { return rgn_ptr + end_; }
 
  [[nodiscard]] char * base() const noexcept { return rgn_ptr; }
 
  [[nodiscard]] size_type avail() const noexcept
  {
    return rgn_size - end_;
  }
 
  [[nodiscard]] char * reserve(const size_type sz)
  {
    if (sz > avail() && !remap(sz))
      return nullptr;
 
    return rgn_ptr + end_;
  }
 
  void commit(const size_type sz) noexcept
  {
    end_ += sz;
  }
 
  void sync() noexcept
  {
    msync(rgn_ptr, rgn_size, MS_ASYNC);
  }
 
  [[nodiscard]] size_type size() const noexcept
  {
    return end_;
  }
 
  [[nodiscard]] size_type capacity() const noexcept
  {
    return rgn_size;
  }
 
  [[nodiscard]] bool empty() const noexcept
  {
    return end_ == 0;
  }
 
  [[nodiscard]] bool is_initialized() const noexcept
  {
    return rgn_ptr != nullptr;
  }
 
  [[nodiscard]] void * mapped_addr() const noexcept
  {
    return rgn_ptr;
  }
 
  [[nodiscard]] int file_descriptor() const noexcept
  {
    return fd;
  }
 
  friend std::ostream & operator<<(std::ostream & o, const MapArena & s)
  {
    return o << "MapArena:\n"
             << "  rgn_ptr   = " << static_cast<void*>(s.rgn_ptr) << '\n'
             << "  end_      = " << s.end_ << '\n'
             << "  rgn_size  = " << s.rgn_size << '\n'
             << "  size      = " << s.size() << '\n'
             << "  capacity  = " << s.capacity() << '\n'
             << "  avail     = " << s.avail();
  }
};
 
} // end namespace Aleph
 
#endif // ALEPH_HAS_MAP_ARENA
 
#endif // AH_MAP_ARENA_H