mmap.hpp

/*
 * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cstddef>
#include <future>
 
#include <kvikio/defaults.hpp>
#include <kvikio/file_handle.hpp>
#include <kvikio/threadpool_wrapper.hpp>
#include <optional>
 
namespace kvikio {
 
class MmapHandle {
 private:
  void* _buf{};
  std::size_t _initial_map_size{};
  std::size_t _initial_map_offset{};
  std::size_t _file_size{};
  std::size_t _map_offset{};
  std::size_t _map_size{};
  void* _map_addr{};
  bool _initialized{};
  int _map_protection{};
  int _map_flags{};
  FileWrapper _file_wrapper{};
 
  std::size_t validate_and_adjust_read_args(std::optional<std::size_t> const& size,
                                            std::size_t offset);
 
 public:
  MmapHandle() noexcept = default;
 
  MmapHandle(std::string const& file_path,
             std::string const& flags                    = "r",
             std::optional<std::size_t> initial_map_size = std::nullopt,
             std::size_t initial_map_offset              = 0,
             mode_t mode                                 = FileHandle::m644,
             std::optional<int> map_flags                = std::nullopt);
 
  MmapHandle(MmapHandle const&)            = delete;
  MmapHandle& operator=(MmapHandle const&) = delete;
  MmapHandle(MmapHandle&& o) noexcept;
  MmapHandle& operator=(MmapHandle&& o) noexcept;
  ~MmapHandle() noexcept;
 
  [[nodiscard]] std::size_t initial_map_size() const noexcept;
 
  [[nodiscard]] std::size_t initial_map_offset() const noexcept;
 
  [[nodiscard]] std::size_t file_size() const;
 
  [[nodiscard]] std::size_t nbytes() const;
 
  [[nodiscard]] bool closed() const noexcept;
 
  void close() noexcept;
 
  std::size_t read(void* buf,
                   std::optional<std::size_t> size = std::nullopt,
                   std::size_t offset              = 0);
 
  std::future<std::size_t> pread(void* buf,
                                 std::optional<std::size_t> size = std::nullopt,
                                 std::size_t offset              = 0,
                                 std::size_t task_size           = defaults::task_size(),
                                 ThreadPool* thread_pool         = &defaults::thread_pool());
};
 
}  // namespace kvikio