forked from suyu/suyu
b3587102d1
Squash attributes into the pointer's integer, making them an uintptr_t pair containing 2 bits at the bottom and then the pointer. These bits are currently unused thanks to alignment requirements. Configure Dynarmic to mask out these bits on pointer reads. While we are at it, remove some unused attributes carried over from Citra. Read/Write and other hot functions use a two step unpacking process that is less readable to stop MSVC from emitting an extra AND instruction in the hot path: mov rdi,rcx shr rdx,0Ch mov r8,qword ptr [rax+8] mov rax,qword ptr [r8+rdx*8] mov rdx,rax -and al,3 and rdx,0FFFFFFFFFFFFFFFCh je Core::Memory::Memory::Impl::Read<unsigned char> mov rax,qword ptr [vaddr] movzx eax,byte ptr [rdx+rax]
84 lines
2.4 KiB
C++
84 lines
2.4 KiB
C++
// Copyright 2020 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
namespace Common {
|
|
|
|
void* AllocateMemoryPages(std::size_t size) noexcept;
|
|
void FreeMemoryPages(void* base, std::size_t size) noexcept;
|
|
|
|
template <typename T>
|
|
class VirtualBuffer final {
|
|
public:
|
|
// TODO: Uncomment this and change Common::PageTable::PageInfo to be trivially constructible
|
|
// using std::atomic_ref once libc++ has support for it
|
|
// static_assert(
|
|
// std::is_trivially_constructible_v<T>,
|
|
// "T must be trivially constructible, as non-trivial constructors will not be executed "
|
|
// "with the current allocator");
|
|
|
|
constexpr VirtualBuffer() = default;
|
|
explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
|
|
base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
|
|
}
|
|
|
|
~VirtualBuffer() noexcept {
|
|
FreeMemoryPages(base_ptr, alloc_size);
|
|
}
|
|
|
|
VirtualBuffer(const VirtualBuffer&) = delete;
|
|
VirtualBuffer& operator=(const VirtualBuffer&) = delete;
|
|
|
|
VirtualBuffer(VirtualBuffer&& other) noexcept
|
|
: alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
|
|
nullptr} {}
|
|
|
|
VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
|
|
alloc_size = std::exchange(other.alloc_size, 0);
|
|
base_ptr = std::exchange(other.base_ptr, nullptr);
|
|
return *this;
|
|
}
|
|
|
|
void resize(std::size_t count) {
|
|
const auto new_size = count * sizeof(T);
|
|
if (new_size == alloc_size) {
|
|
return;
|
|
}
|
|
|
|
FreeMemoryPages(base_ptr, alloc_size);
|
|
|
|
alloc_size = new_size;
|
|
base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
|
|
}
|
|
|
|
[[nodiscard]] constexpr const T& operator[](std::size_t index) const {
|
|
return base_ptr[index];
|
|
}
|
|
|
|
[[nodiscard]] constexpr T& operator[](std::size_t index) {
|
|
return base_ptr[index];
|
|
}
|
|
|
|
[[nodiscard]] constexpr T* data() {
|
|
return base_ptr;
|
|
}
|
|
|
|
[[nodiscard]] constexpr const T* data() const {
|
|
return base_ptr;
|
|
}
|
|
|
|
[[nodiscard]] constexpr std::size_t size() const {
|
|
return alloc_size / sizeof(T);
|
|
}
|
|
|
|
private:
|
|
std::size_t alloc_size{};
|
|
T* base_ptr{};
|
|
};
|
|
|
|
} // namespace Common
|