virtual_memory.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdlib>
#include <filesystem>
#include <memory>
#include <string_view>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/utility.h>
 
namespace rex::memory {
 
#if REX_PLATFORM_ANDROID
REX_API void AndroidInitialize();
REX_API void AndroidShutdown();
#endif

REX_API size_t GetPageSize();

REX_API size_t GetAllocationGranularity();
 
enum class PageAccess : u8 {
  kNoAccess = 0,
  kReadOnly = 1 << 0,
  kReadWrite = kReadOnly | 1 << 1,
  kExecuteReadOnly = kReadOnly | 1 << 2,
  kExecuteReadWrite = kReadWrite | 1 << 2,
};

enum class AllocationType : u8 {
  kReserve = 1 << 0, 
  kCommit = 1 << 1,  
  kReserveCommit = kReserve | kCommit,
};

enum class DeallocationType : u8 {
  kRelease = 1 << 0,  
  kDecommit = 1 << 1, 
};

REX_API bool IsWritableExecutableMemorySupported();

REX_API void* AllocFixed(void* base_address, size_t length, AllocationType allocation_type,
                         PageAccess access);

REX_API bool DeallocFixed(void* base_address, size_t length, DeallocationType deallocation_type);

REX_API bool Protect(void* base_address, size_t length, PageAccess access,
                     PageAccess* out_old_access = nullptr);

REX_API bool QueryProtect(void* base_address, size_t& length, PageAccess& out_access);

template <typename T>
inline T* AlignedAlloc(size_t alignment) {
#if REX_PLATFORM_WIN32
  return reinterpret_cast<T*>(_aligned_malloc(sizeof(T), alignment));
#else
  void* ptr = nullptr;
  if (posix_memalign(&ptr, alignment, sizeof(T))) {
    return nullptr;
  }
  return reinterpret_cast<T*>(ptr);
#endif
}

template <typename T>
void AlignedFree(T* ptr) {
#if REX_PLATFORM_WIN32
  _aligned_free(ptr);
#else
  free(ptr);
#endif
}
 
#if REX_PLATFORM_WIN32
using FileMappingHandle = void*;
constexpr FileMappingHandle kFileMappingHandleInvalid = nullptr;
#else
using FileMappingHandle = int;
constexpr FileMappingHandle kFileMappingHandleInvalid = -1;
#endif

REX_API FileMappingHandle CreateFileMappingHandle(const std::filesystem::path& path, size_t length,
                                                  PageAccess access, bool commit);

REX_API std::filesystem::path CreateFileMappingName(std::string_view prefix);

REX_API void RemoveStaleFileMappings(std::string_view prefix);

REX_API void CloseFileMappingHandle(FileMappingHandle handle, const std::filesystem::path& path);

REX_API void* MapFileView(FileMappingHandle handle, void* base_address, size_t length,
                          PageAccess access, size_t file_offset);

REX_API bool UnmapFileView(FileMappingHandle handle, void* base_address, size_t length);

inline void* LowAddress(void* address) {
  // NOLINTNEXTLINE(performance-no-int-to-ptr): LowAddress truncates a host pointer
  return reinterpret_cast<void*>(reinterpret_cast<u64>(address) & 0xFFFFFFFF);
}
 
}  // namespace rex::memory
 
namespace rex::memory {

class REX_API MappedMemory : public rex::NonCopyable {
 public:
  enum class Mode : u8 {
    kRead,
    kReadWrite,
  };

  static std::unique_ptr<MappedMemory> Open(const std::filesystem::path& path, Mode mode,
                                            size_t offset = 0, size_t length = 0);
 
  MappedMemory() = default;

  MappedMemory(void* data, size_t size) : data_(data), size_(size) {}
  virtual ~MappedMemory() = default;

  std::unique_ptr<MappedMemory> Range(size_t offset, size_t length) const {
    return std::make_unique<MappedMemory>(GetData() + offset, length);
  }

  u8* GetData() const { return reinterpret_cast<u8*>(data_); }
 
  size_t GetSize() const { return size_; }

  virtual void Close(u64 truncate_size = 0) { (void)truncate_size; }
 
  virtual void Flush() {}

  virtual bool Remap(size_t offset, size_t length) {
    (void)offset;
    (void)length;
    return false;
  }
 
 protected:
  void* data_ = nullptr;
  size_t size_ = 0;
};

class REX_API ChunkedMappedMemoryWriter {
 public:
  virtual ~ChunkedMappedMemoryWriter() = default;

  static std::unique_ptr<ChunkedMappedMemoryWriter> Open(const std::filesystem::path& path,
                                                         size_t chunk_size,
                                                         bool low_address_space = false);

  virtual u8* Allocate(size_t length) = 0;
 
  virtual void Flush() = 0;

  virtual void FlushNew() = 0;
 
 protected:
  ChunkedMappedMemoryWriter(const std::filesystem::path& path, size_t chunk_size,
                            bool low_address_space)
      : path_(path), chunk_size_(chunk_size), low_address_space_(low_address_space) {}
 
  std::filesystem::path path_;
  size_t chunk_size_;
  bool low_address_space_;
};
 
}  // namespace rex::memory