Add MemoryMapping source and test driver

Author: arrieta

memory_mapping.cpp

@@ -0,0 +1,187 @@
+// -*- coding:utf-8; mode:c++; mode:auto-fill; fill-column:80; -*-
+
+/// @file      memory_mapping.cpp
+/// @brief     Platform-independent memory mapping.
+/// @author    J. Arrieta <[email protected]>
+/// @date      January, 08, 2019
+/// @copyright (C) 2019 Nabla Zero Labs
+
+// Related header
+#include "memory_mapping.hpp"
+
+// C++ Standard Library
+#include <sstream>
+#include <stdexcept>
+#include <system_error>
+#include <utility>
+
+// Platform-specific libraries.
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#elif defined(_WIN64)
+#include <Windows.h>
+#else
+#error "Your platform is not supported"
+#endif
+
+namespace nzl {
+namespace {
+
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+auto make_mapping(const char* path) {
+  auto fp = ::open(path, O_RDONLY);
+  if (fp == -1) {
+    throw std::system_error(errno, std::system_category(), path);
+  }
+
+  struct stat sb;
+  if (::fstat(fp, &sb) == -1) {
+    ::close(fp);
+    throw std::system_error(errno, std::system_category(), path);
+  }
+
+  auto data = ::mmap(nullptr, sb.st_size, PROT_READ, MAP_SHARED, fp, 0);
+  ::close(fp);  // closing file descriptor does not unmap region
+
+  if (data == MAP_FAILED) {
+    throw std::system_error(errno, std::system_category(), path);
+  }
+
+  return std::make_pair(static_cast<std::byte*>(data),
+                        static_cast<std::size_t>(sb.st_size));
+}
+
+auto clear_mapping(std::byte* data, std::size_t size) noexcept {
+  if (data != nullptr) {
+    ::munmap(static_cast<void*>(data), size);
+    data = nullptr;
+    size = 0;
+  }
+  return std::make_pair(data, size);
+}
+
+#elif defined(_WIN64)
+// Get the last Windows error as a C++ std::string.
+std::string last_error() {
+  DWORD errorMessageID = ::GetLastError();
+  if (errorMessageID == 0) {
+    return {};
+  } else {
+    LPSTR  messageBuffer = nullptr;
+    size_t size          = FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+        nullptr, errorMessageID, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPSTR)&messageBuffer, 0, nullptr);
+    std::string message(messageBuffer, size);
+    LocalFree(messageBuffer);
+    return message;
+  }
+}
+
+auto make_mapping(const char* path) {
+  HANDLE hfile = ::CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, nullptr,
+                               OPEN_EXISTING, 0, nullptr);
+  if (hfile == INVALID_HANDLE_VALUE) {
+    std::ostringstream oss;
+    oss << "error opening \"" << path << "\": " << last_error();
+    throw std::runtime_error(oss.str());
+  }
+
+  LARGE_INTEGER size_value;
+  if (!::GetFileSizeEx(hfile, &size_value)) {
+    std::ostringstream oss;
+    oss << "cannot obtain size of \"" << path << "\": " << last_error();
+    throw std::runtime_error(oss.str());
+  }
+  auto size = size_value.QuadPart;
+
+  HANDLE hmap =
+      ::CreateFileMapping(hfile, nullptr, PAGE_READONLY, 0, 0, nullptr);
+  // closing the file handle does not affect the mapping
+  if (!::CloseHandle(hfile) || (hmap == nullptr)) {
+    std::ostringstream oss;
+    oss << "error creating file mapping of \"" << path
+        << "\": " << last_error();
+    throw std::runtime_error(oss.str());
+  }
+
+  auto data = ::MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, size);
+  // closing the map handle does not unmap the region
+  if (!::CloseHandle(hmap) || (data == nullptr)) {
+    std::ostringstream oss;
+    oss << "error finalizing creation of file mapping of \"" << path
+        << "\": " << last_error();
+    throw std::runtime_error(oss.str());
+  }
+
+  return std::make_pair(static_cast<std::byte*>(data),
+                        static_cast<std::size_t>(size));
+}
+
+auto clear_mapping(std::byte* data, std::size_t size) noexcept {
+  if (data != nullptr) {
+    ::UnmapViewOfFile(data);
+    data = nullptr;
+    size = 0;
+  }
+  return std::make_pair(data, size);
+}
+#else
+#error "Your platform is not supported"
+#endif
+
+}  // anonymous namespace
+
+MemoryMapping::MemoryMapping(const std::string& path) {
+  std::tie(m_data, m_size) = make_mapping(path.c_str());
+}
+
+MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept
+    : m_data{other.m_data}, m_size{other.m_size} {
+  other.m_data = nullptr;
+  other.m_size = 0;
+}
+
+MemoryMapping& MemoryMapping::operator=(MemoryMapping&& other) noexcept {
+  m_data = other.m_data;
+  m_size = other.m_size;
+
+  other.m_data = nullptr;
+  other.m_size = 0;
+
+  return *this;
+}
+
+MemoryMapping::~MemoryMapping() noexcept {
+  std::tie(m_data, m_size) = clear_mapping(m_data, m_size);
+}
+
+const std::byte* MemoryMapping::data() const noexcept { return m_data; }
+
+const std::byte* MemoryMapping::begin() const noexcept { return cbegin(); }
+
+const std::byte* MemoryMapping::end() const noexcept { return cend(); }
+
+const std::byte* MemoryMapping::cbegin() const noexcept { return m_data; }
+
+const std::byte* MemoryMapping::cend() const noexcept {
+  return std::next(cbegin(), size());
+}
+
+std::size_t MemoryMapping::size() const noexcept { return m_size; }
+
+void MemoryMapping::swap(MemoryMapping& other) noexcept {
+  using std::swap;
+  swap(m_data, other.m_data);
+  swap(m_size, other.m_size);
+}
+
+void swap(MemoryMapping& lhs, MemoryMapping& rhs) noexcept { lhs.swap(rhs); }
+
+}  // namespace nzl

memory_mapping.hpp

@@ -0,0 +1,66 @@
+// -*- coding:utf-8; mode:c++; mode:auto-fill; fill-column:80; -*-
+
+/// @file      memory_mapping.hpp
+/// @brief     Platform-independent memory mapping.
+/// @author    J. Arrieta <[email protected]>
+/// @date      January, 08, 2019
+/// @copyright (C) 2019 Nabla Zero Labs
+
+#pragma once
+
+// C++ Standard Library
+#include <cstdint>
+#include <string>
+
+namespace nzl {
+
+class MemoryMapping {
+ public:
+  /// @brief Create a read-only MemoryMaping of file.
+  /// @param path Filesystem path to the file.
+  /// @throws std::system_error (Linux/macOS) if mapping cannot be created.
+  /// @throws std::runtime_error (Windows) if mapping cannot be created.
+  MemoryMapping(const std::string& path);
+
+  /// @brief Move constructor.
+  MemoryMapping(MemoryMapping&& other) noexcept;
+
+  /// @brief Move assignment.
+  MemoryMapping& operator=(MemoryMapping&& other) noexcept;
+
+  /// @brief Destructor.
+  ~MemoryMapping() noexcept;
+
+  /// @brief Return a pointer to the beginning of the data block.
+  const std::byte* data() const noexcept;
+
+  /// @brief Return a pointer to the beginning of the data block.
+  const std::byte* begin() const noexcept;
+
+  /// @brief Return a pointer to the end of the data block.
+  const std::byte* end() const noexcept;
+
+  /// @brief Return a pointer to the beginning
+  const std::byte* cbegin() const noexcept;
+
+  /// @brief Return a pointer to the end of the data block.
+  const std::byte* cend() const noexcept;
+
+  /// @brief Return the size of the mapped region in bytes.
+  std::size_t size() const noexcept;
+
+  /// @brief Swap this and other MemoryMapping
+  /// @param other The MemoryMapping to swap with this one.
+  void swap(MemoryMapping& other) noexcept;
+
+ private:
+  std::byte*  m_data{nullptr};
+  std::size_t m_size{0};
+};
+
+/// @brief Swap two @link MemoryMapping MemoryMappings@endlink
+/// @param lhs First MemoryMapping to swap.
+/// @param rhs Second MemoryMapping to swap.
+void swap(MemoryMapping& lhs, MemoryMapping& rhs) noexcept;
+
+}  // namespace nzl

memory_mapping.t.cpp

@@ -0,0 +1,64 @@
+// -*- coding:utf-8; mode:c++; mode:auto-fill; fill-column:80; -*-
+
+/// @file      memory_mapping.t.cpp
+/// @brief     Test driver for platform-independent memory mapping.
+/// @author    J. Arrieta <[email protected]>
+/// @date      January, 08, 2019
+/// @copyright (C) 2019 Nabla Zero Labs
+
+// Nabla Zero Labs Library.
+#include "memory_mapping.hpp"
+
+// C++ Standard Library
+#include <algorithm>
+#include <chrono>
+#include <cstdlib>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <iterator>
+
+void using_file(const std::string& path) {
+  std::ifstream fp(path, std::ios::in | std::ios::binary);
+
+  std::istreambuf_iterator<char>       it(fp);
+  const std::istreambuf_iterator<char> it_end{};
+
+  std::size_t n{0};
+  while (it != it_end) {
+    if (*it++ == '\n') ++n;
+  }
+  std::cout << "[f] " << std::setw(8) << n << " " << path << "\n";
+}
+
+void using_mapping(const std::string& path) {
+  nzl::MemoryMapping mm{path};
+
+  std::size_t n{0};
+  for (auto&& c : mm) {
+    if (c == std::byte('\n')) ++n;
+  }
+  std::cout << "[m] " << std::setw(8) << n << " " << path << "\n";
+}
+
+int main(int argc, char* argv[]) {
+  using namespace std::chrono;
+
+  bool use_map = std::getenv("NZL_USE_MAP") != nullptr;
+  if (use_map) {
+    std::cout << "using memory mapping\n";
+    auto cpu_beg = system_clock::now();
+    std::for_each(argv + 1, argv + argc, using_mapping);
+    auto cpu_end = system_clock::now();
+    auto cpu_dur = nanoseconds(cpu_end - cpu_beg).count();
+    std::cout << cpu_dur << " nanoseconds elapsed\n";
+
+  } else {
+    std::cout << "using file\n";
+    auto cpu_beg = system_clock::now();
+    std::for_each(argv + 1, argv + argc, using_file);
+    auto cpu_end = system_clock::now();
+    auto cpu_dur = nanoseconds(cpu_end - cpu_beg).count();
+    std::cout << cpu_dur << " nanoseconds elapsed\n";
+  }
+}