memory.hpp

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
#include <cstring> // strdup
#include <memory>
#include <sys/mman.h> // munmap
#include "attributes/common.hpp"
#include "attributes/strings.hpp"
#include "attributes/null_safety.hpp"
 
namespace ein {
 
template<typename T>
concept trivially_destructible = std::is_trivially_destructible_v<std::remove_extent_t<T>>;
 
struct c_munmap {
  size_t size;
  ein_inline ein_artificial
  void operator()(void * p) const noexcept {
    if (p != nullptr)
      munmap(p, size);
  }
};
 
using mmap_ptr = std::unique_ptr<void,c_munmap>;
 
ein_inline ein_artificial ein_nonnull(1)
mmap_ptr make_mmap_ptr(void * p, size_t size) noexcept {
  return mmap_ptr(p,c_munmap(size));
}
 
struct c_free {
  template <trivially_destructible T>
  ein_inline ein_artificial
  static void operator()(T * p) noexcept {
    std::free(const_cast<std::remove_const_t<T>*>(p));
  }
};
 
template<trivially_destructible T>
using unique_c_ptr = std::unique_ptr<T, c_free>;
 
static_assert(sizeof(char *)== sizeof(unique_c_ptr<char>),"");
 
using unique_str = unique_c_ptr<char const>;
 
ein_nodiscard ein_inline ein_artificial ein_pure
ein_nonnull(1) ein_null_terminated_string_arg(1)
unique_str dup(
  ein_noescape char const * str
) noexcept {
  return unique_str { strdup(str) };
}
 
} // ein
 
#if defined(EIN_TESTING) || defined(EIN_TESTING_MEMORY)
TEST_CASE("memory","[memory]") {
  using namespace ein;
 
  SECTION("unique_str manages strdup-allocated strings") {
    const char* original = "Hello, World!";
    unique_str managed_str = dup(original);
 
    CHECK(managed_str != nullptr);
    CHECK(std::strcmp(managed_str.get(), original) == 0);
  }
 
  SECTION("unique_c_ptr manages malloc-allocated memory") {
    constexpr size_t size = 1024;
    ein::unique_c_ptr<char> managed_ptr(static_cast<char*>(std::malloc(size)));
    CHECK(managed_ptr);
    //std::memset(managed_ptr.get(), 0, size);
  }
 
  SECTION("mmap_ptr manages mmap-allocated memory") {
    constexpr size_t size = 4096;
    void* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    CHECK(ptr != MAP_FAILED);
 
    mmap_ptr managed_mmap = make_mmap_ptr(ptr, size);
    CHECK(managed_mmap != nullptr);
  }
}
#endif