mmap.hpp

/*
 * Copyright (c) 2025, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cstddef>
#include <future>
 
#include <kvikio/defaults.hpp>
#include <kvikio/file_handle.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());
};
 
}  // namespace kvikio