MrPurple666
8 months ago
6 changed files with 3 additions and 660 deletions
-
8src/common/settings.h
-
2src/video_core/CMakeLists.txt
-
84src/video_core/renderer_vulkan/renderer_vulkan.cpp
-
4src/video_core/renderer_vulkan/renderer_vulkan.h
-
446src/video_core/vulkan_common/hybrid_memory.cpp
-
119src/video_core/vulkan_common/hybrid_memory.h
@ -1,446 +0,0 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
|||
|
|||
#include <cstring>
|
|||
#include <fstream>
|
|||
#include <algorithm>
|
|||
|
|||
#include "common/logging/log.h"
|
|||
#include "video_core/vulkan_common/hybrid_memory.h"
|
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__)
|
|||
#include <sys/mman.h>
|
|||
#include <unistd.h>
|
|||
#include <poll.h>
|
|||
#include <sys/syscall.h>
|
|||
#include <linux/userfaultfd.h>
|
|||
#include <sys/ioctl.h>
|
|||
#include <fcntl.h>
|
|||
#elif defined(_WIN32)
|
|||
#include <windows.h>
|
|||
#endif
|
|||
|
|||
namespace Vulkan { |
|||
|
|||
void PredictiveReuseManager::RecordUsage(u64 address, u64 size, bool write_access) { |
|||
std::lock_guard<std::mutex> guard(mutex); |
|||
|
|||
// Add to history, removing oldest entries if we're past max_history
|
|||
access_history.push_back({address, size, write_access, current_timestamp++}); |
|||
if (access_history.size() > max_history) { |
|||
access_history.erase(access_history.begin()); |
|||
} |
|||
} |
|||
|
|||
bool PredictiveReuseManager::IsHotRegion(u64 address, u64 size) const { |
|||
std::lock_guard<std::mutex> guard(mutex); |
|||
|
|||
// Check if this memory region has been accessed frequently
|
|||
const u64 end_address = address + size; |
|||
int access_count = 0; |
|||
|
|||
for (const auto& access : access_history) { |
|||
const u64 access_end = access.address + access.size; |
|||
|
|||
// Check for overlap
|
|||
if (!(end_address <= access.address || address >= access_end)) { |
|||
access_count++; |
|||
} |
|||
} |
|||
|
|||
// Consider a region "hot" if it has been accessed in at least 10% of recent accesses
|
|||
return access_count >= static_cast<int>(std::max<size_t>(1, max_history / 10)); |
|||
} |
|||
|
|||
void PredictiveReuseManager::EvictRegion(u64 address, u64 size) { |
|||
std::lock_guard<std::mutex> guard(mutex); |
|||
|
|||
// Remove any history entries that overlap with this region
|
|||
const u64 end_address = address + size; |
|||
|
|||
access_history.erase( |
|||
std::remove_if(access_history.begin(), access_history.end(), |
|||
[address, end_address](const MemoryAccess& access) { |
|||
const u64 access_end = access.address + access.size; |
|||
// Check for overlap
|
|||
return !(end_address <= access.address || address >= access_end); |
|||
}), |
|||
access_history.end() |
|||
); |
|||
} |
|||
|
|||
void PredictiveReuseManager::ClearHistory() { |
|||
std::lock_guard<std::mutex> guard(mutex); |
|||
access_history.clear(); |
|||
current_timestamp = 0; |
|||
} |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
void FaultManagedAllocator::Touch(size_t addr) { |
|||
lru.remove(addr); |
|||
lru.push_front(addr); |
|||
dirty_set.insert(addr); |
|||
} |
|||
|
|||
void FaultManagedAllocator::EnforceLimit() { |
|||
while (lru.size() > MaxPages) { |
|||
size_t evict = lru.back(); |
|||
lru.pop_back(); |
|||
|
|||
auto it = page_map.find(evict); |
|||
if (it != page_map.end()) { |
|||
if (dirty_set.count(evict)) { |
|||
// Compress and store dirty page before evicting
|
|||
std::vector<u8> compressed((u8*)it->second, (u8*)it->second + PageSize); |
|||
compressed_store[evict] = std::move(compressed); |
|||
dirty_set.erase(evict); |
|||
} |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__)
|
|||
munmap(it->second, PageSize); |
|||
#elif defined(_WIN32)
|
|||
VirtualFree(it->second, 0, MEM_RELEASE); |
|||
#endif
|
|||
page_map.erase(it); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void* FaultManagedAllocator::GetOrAlloc(size_t addr) { |
|||
std::lock_guard<std::mutex> guard(lock); |
|||
|
|||
if (page_map.count(addr)) { |
|||
Touch(addr); |
|||
return page_map[addr]; |
|||
} |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__)
|
|||
void* mem = mmap(nullptr, PageSize, PROT_READ | PROT_WRITE, |
|||
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); |
|||
|
|||
if (mem == MAP_FAILED) { |
|||
LOG_ERROR(Render_Vulkan, "Failed to mmap memory for fault handler"); |
|||
return nullptr; |
|||
} |
|||
#elif defined(_WIN32)
|
|||
void* mem = VirtualAlloc(nullptr, PageSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); |
|||
if (!mem) { |
|||
LOG_ERROR(Render_Vulkan, "Failed to VirtualAlloc memory for fault handler"); |
|||
return nullptr; |
|||
} |
|||
#endif
|
|||
|
|||
if (compressed_store.count(addr)) { |
|||
// Decompress stored page data
|
|||
std::memcpy(mem, compressed_store[addr].data(), compressed_store[addr].size()); |
|||
compressed_store.erase(addr); |
|||
} else { |
|||
std::memset(mem, 0, PageSize); |
|||
} |
|||
|
|||
page_map[addr] = mem; |
|||
lru.push_front(addr); |
|||
dirty_set.insert(addr); |
|||
EnforceLimit(); |
|||
|
|||
return mem; |
|||
} |
|||
|
|||
#if defined(_WIN32)
|
|||
// Static member initialization
|
|||
FaultManagedAllocator* FaultManagedAllocator::current_instance = nullptr; |
|||
|
|||
LONG WINAPI FaultManagedAllocator::VectoredExceptionHandler(PEXCEPTION_POINTERS exception_info) { |
|||
// Only handle access violations (page faults)
|
|||
if (exception_info->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) { |
|||
return EXCEPTION_CONTINUE_SEARCH; |
|||
} |
|||
|
|||
if (!current_instance) { |
|||
return EXCEPTION_CONTINUE_SEARCH; |
|||
} |
|||
|
|||
// Get the faulting address - use ULONG_PTR for Windows
|
|||
const ULONG_PTR fault_addr = static_cast<ULONG_PTR>(exception_info->ExceptionRecord->ExceptionInformation[1]); |
|||
const ULONG_PTR base_addr = reinterpret_cast<ULONG_PTR>(current_instance->base_address); |
|||
|
|||
// Check if the address is within our managed range
|
|||
if (fault_addr < base_addr || |
|||
fault_addr >= (base_addr + static_cast<ULONG_PTR>(current_instance->memory_size))) { |
|||
return EXCEPTION_CONTINUE_SEARCH; |
|||
} |
|||
|
|||
// Calculate the base address of the page
|
|||
const ULONG_PTR page_addr = fault_addr & ~(static_cast<ULONG_PTR>(PageSize) - 1); |
|||
const size_t relative_addr = static_cast<size_t>(page_addr - base_addr); |
|||
|
|||
// Handle the fault by allocating memory
|
|||
void* page = current_instance->GetOrAlloc(relative_addr); |
|||
if (!page) { |
|||
return EXCEPTION_CONTINUE_SEARCH; |
|||
} |
|||
|
|||
// Copy the page data to the faulting address
|
|||
DWORD old_protect; |
|||
void* target_addr = reinterpret_cast<void*>(page_addr); |
|||
|
|||
// Make the target page writable
|
|||
if (VirtualProtect(target_addr, PageSize, PAGE_READWRITE, &old_protect)) { |
|||
std::memcpy(target_addr, page, PageSize); |
|||
// Restore original protection
|
|||
VirtualProtect(target_addr, PageSize, old_protect, &old_protect); |
|||
return EXCEPTION_CONTINUE_EXECUTION; |
|||
} |
|||
|
|||
return EXCEPTION_CONTINUE_SEARCH; |
|||
} |
|||
|
|||
void FaultManagedAllocator::ExceptionHandlerThread() { |
|||
while (running) { |
|||
// Sleep to avoid busy waiting
|
|||
Sleep(10); |
|||
} |
|||
} |
|||
#endif
|
|||
|
|||
void FaultManagedAllocator::Initialize(void* base, size_t size) { |
|||
#if defined(__linux__) || defined(__ANDROID__)
|
|||
uffd = static_cast<int>(syscall(SYS_userfaultfd, O_CLOEXEC | O_NONBLOCK)); |
|||
if (uffd < 0) { |
|||
LOG_ERROR(Render_Vulkan, "Failed to create userfaultfd, fault handling disabled"); |
|||
return; |
|||
} |
|||
|
|||
struct uffdio_api api = { .api = UFFD_API }; |
|||
ioctl(uffd, UFFDIO_API, &api); |
|||
|
|||
struct uffdio_register reg = { |
|||
.range = { .start = (uintptr_t)base, .len = size }, |
|||
.mode = UFFDIO_REGISTER_MODE_MISSING |
|||
}; |
|||
|
|||
if (ioctl(uffd, UFFDIO_REGISTER, ®) < 0) { |
|||
LOG_ERROR(Render_Vulkan, "Failed to register memory range with userfaultfd"); |
|||
close(uffd); |
|||
uffd = -1; |
|||
return; |
|||
} |
|||
|
|||
running = true; |
|||
fault_handler = std::thread(&FaultManagedAllocator::FaultThread, this); |
|||
#elif defined(_WIN32)
|
|||
// Setup Windows memory for fault handling
|
|||
base_address = base; |
|||
memory_size = size; |
|||
|
|||
// Reserve memory range but don't commit it yet - it will be demand-paged
|
|||
DWORD oldProtect; |
|||
VirtualProtect(base, size, PAGE_NOACCESS, &oldProtect); |
|||
|
|||
// Install a vectored exception handler
|
|||
current_instance = this; |
|||
AddVectoredExceptionHandler(1, VectoredExceptionHandler); |
|||
|
|||
running = true; |
|||
exception_handler = std::thread(&FaultManagedAllocator::ExceptionHandlerThread, this); |
|||
|
|||
LOG_INFO(Render_Vulkan, "Windows fault-managed memory initialized at {:p}, size: {}", |
|||
base, size); |
|||
#endif
|
|||
} |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__)
|
|||
void FaultManagedAllocator::FaultThread() { |
|||
struct pollfd pfd = { uffd, POLLIN, 0 }; |
|||
|
|||
while (running) { |
|||
if (poll(&pfd, 1, 10) > 0) { |
|||
struct uffd_msg msg; |
|||
read(uffd, &msg, sizeof(msg)); |
|||
|
|||
if (msg.event == UFFD_EVENT_PAGEFAULT) { |
|||
size_t addr = msg.arg.pagefault.address & ~(PageSize - 1); |
|||
void* page = GetOrAlloc(addr); |
|||
|
|||
if (page) { |
|||
struct uffdio_copy copy = { |
|||
.dst = (uintptr_t)addr, |
|||
.src = (uintptr_t)page, |
|||
.len = PageSize, |
|||
.mode = 0 |
|||
}; |
|||
|
|||
ioctl(uffd, UFFDIO_COPY, ©); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
#endif
|
|||
|
|||
void* FaultManagedAllocator::Translate(size_t addr) { |
|||
std::lock_guard<std::mutex> guard(lock); |
|||
|
|||
size_t base = addr & ~(PageSize - 1); |
|||
if (!page_map.count(base)) { |
|||
return nullptr; |
|||
} |
|||
|
|||
Touch(base); |
|||
return (u8*)page_map[base] + (addr % PageSize); |
|||
} |
|||
|
|||
void FaultManagedAllocator::SaveSnapshot(const std::string& path) { |
|||
std::lock_guard<std::mutex> guard(lock); |
|||
|
|||
std::ofstream out(path, std::ios::binary); |
|||
if (!out) { |
|||
LOG_ERROR(Render_Vulkan, "Failed to open snapshot file for writing: {}", path); |
|||
return; |
|||
} |
|||
|
|||
for (auto& [addr, mem] : page_map) { |
|||
out.write(reinterpret_cast<const char*>(&addr), sizeof(addr)); |
|||
out.write(reinterpret_cast<const char*>(mem), PageSize); |
|||
} |
|||
|
|||
LOG_INFO(Render_Vulkan, "Saved memory snapshot to {}", path); |
|||
} |
|||
|
|||
void FaultManagedAllocator::SaveDifferentialSnapshot(const std::string& path) { |
|||
std::lock_guard<std::mutex> guard(lock); |
|||
|
|||
std::ofstream out(path, std::ios::binary); |
|||
if (!out) { |
|||
LOG_ERROR(Render_Vulkan, "Failed to open diff snapshot file for writing: {}", path); |
|||
return; |
|||
} |
|||
|
|||
size_t dirty_count = 0; |
|||
for (const auto& addr : dirty_set) { |
|||
if (page_map.count(addr)) { |
|||
out.write(reinterpret_cast<const char*>(&addr), sizeof(addr)); |
|||
out.write(reinterpret_cast<const char*>(page_map[addr]), PageSize); |
|||
dirty_count++; |
|||
} |
|||
} |
|||
|
|||
LOG_INFO(Render_Vulkan, "Saved differential snapshot to {} ({} dirty pages)", |
|||
path, dirty_count); |
|||
} |
|||
|
|||
void FaultManagedAllocator::ClearDirtySet() { |
|||
std::lock_guard<std::mutex> guard(lock); |
|||
dirty_set.clear(); |
|||
LOG_DEBUG(Render_Vulkan, "Cleared dirty page tracking"); |
|||
} |
|||
|
|||
FaultManagedAllocator::~FaultManagedAllocator() { |
|||
running = false; |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__)
|
|||
if (fault_handler.joinable()) { |
|||
fault_handler.join(); |
|||
} |
|||
|
|||
for (auto& [addr, mem] : page_map) { |
|||
munmap(mem, PageSize); |
|||
} |
|||
|
|||
if (uffd != -1) { |
|||
close(uffd); |
|||
} |
|||
#elif defined(_WIN32)
|
|||
if (exception_handler.joinable()) { |
|||
exception_handler.join(); |
|||
} |
|||
|
|||
// Remove the vectored exception handler
|
|||
RemoveVectoredExceptionHandler(VectoredExceptionHandler); |
|||
current_instance = nullptr; |
|||
|
|||
for (auto& [addr, mem] : page_map) { |
|||
VirtualFree(mem, 0, MEM_RELEASE); |
|||
} |
|||
|
|||
// Free the base memory if needed
|
|||
if (base_address) { |
|||
VirtualFree(base_address, 0, MEM_RELEASE); |
|||
base_address = nullptr; |
|||
} |
|||
#endif
|
|||
} |
|||
#endif // defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
|
|||
HybridMemory::HybridMemory(const Device& device_, MemoryAllocator& allocator, size_t reuse_history) |
|||
: device(device_), memory_allocator(allocator), reuse_manager(reuse_history) { |
|||
} |
|||
|
|||
HybridMemory::~HybridMemory() = default; |
|||
|
|||
void HybridMemory::InitializeGuestMemory(void* base, size_t size) { |
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
fmaa.Initialize(base, size); |
|||
LOG_INFO(Render_Vulkan, "Initialized fault-managed guest memory at {:p}, size: {}", |
|||
base, size); |
|||
#else
|
|||
LOG_INFO(Render_Vulkan, "Fault-managed memory not supported on this platform"); |
|||
#endif
|
|||
} |
|||
|
|||
void* HybridMemory::TranslateAddress(size_t addr) { |
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
return fmaa.Translate(addr); |
|||
#else
|
|||
return nullptr; |
|||
#endif
|
|||
} |
|||
|
|||
ComputeBuffer HybridMemory::CreateComputeBuffer(VkDeviceSize size, VkBufferUsageFlags usage, |
|||
MemoryUsage memory_type) { |
|||
ComputeBuffer buffer; |
|||
buffer.size = size; |
|||
|
|||
VkBufferCreateInfo buffer_ci = { |
|||
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, |
|||
.pNext = nullptr, |
|||
.flags = 0, |
|||
.size = size, |
|||
.usage = usage | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, |
|||
.sharingMode = VK_SHARING_MODE_EXCLUSIVE, |
|||
.queueFamilyIndexCount = 0, |
|||
.pQueueFamilyIndices = nullptr, |
|||
}; |
|||
|
|||
// Using CreateBuffer directly handles memory allocation internally
|
|||
buffer.buffer = memory_allocator.CreateBuffer(buffer_ci, memory_type); |
|||
|
|||
LOG_DEBUG(Render_Vulkan, "Created compute buffer: size={}, usage={:x}", |
|||
size, usage); |
|||
|
|||
return buffer; |
|||
} |
|||
|
|||
void HybridMemory::SaveSnapshot(const std::string& path) { |
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
fmaa.SaveSnapshot(path); |
|||
#else
|
|||
LOG_ERROR(Render_Vulkan, "Memory snapshots not supported on this platform"); |
|||
#endif
|
|||
} |
|||
|
|||
void HybridMemory::SaveDifferentialSnapshot(const std::string& path) { |
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
fmaa.SaveDifferentialSnapshot(path); |
|||
#else
|
|||
LOG_ERROR(Render_Vulkan, "Differential memory snapshots not supported on this platform"); |
|||
#endif
|
|||
} |
|||
|
|||
void HybridMemory::ResetDirtyTracking() { |
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32)
|
|||
fmaa.ClearDirtySet(); |
|||
#endif
|
|||
} |
|||
|
|||
} // namespace Vulkan
|
|||
@ -1,119 +0,0 @@ |
|||
// SPDX-FileCopyrightText: Copyright 2025 citron Emulator Project |
|||
// SPDX-License-Identifier: GPL-2.0-or-later |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <string> |
|||
#include <vector> |
|||
#include <unordered_map> |
|||
#include <mutex> |
|||
#include <atomic> |
|||
#include <functional> |
|||
#include <list> |
|||
#include <set> |
|||
#include <map> |
|||
#include <thread> |
|||
|
|||
#include "common/common_types.h" |
|||
#include "video_core/vulkan_common/vulkan_device.h" |
|||
#include "video_core/vulkan_common/vulkan_memory_allocator.h" |
|||
#include "video_core/vulkan_common/vulkan_wrapper.h" |
|||
|
|||
namespace Vulkan { |
|||
|
|||
struct ComputeBuffer { |
|||
vk::Buffer buffer{}; |
|||
VkDeviceSize size = 0; |
|||
}; |
|||
|
|||
class PredictiveReuseManager { |
|||
public: |
|||
explicit PredictiveReuseManager(size_t history_size) : max_history{history_size} {} |
|||
|
|||
void RecordUsage(u64 address, u64 size, bool write_access); |
|||
bool IsHotRegion(u64 address, u64 size) const; |
|||
void EvictRegion(u64 address, u64 size); |
|||
void ClearHistory(); |
|||
|
|||
private: |
|||
struct MemoryAccess { |
|||
u64 address; |
|||
u64 size; |
|||
bool write_access; |
|||
u64 timestamp; |
|||
}; |
|||
|
|||
std::vector<MemoryAccess> access_history; |
|||
const size_t max_history; |
|||
u64 current_timestamp{0}; |
|||
mutable std::mutex mutex; |
|||
}; |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32) |
|||
class FaultManagedAllocator { |
|||
public: |
|||
static constexpr size_t PageSize = 0x1000; |
|||
static constexpr size_t MaxPages = 16384; |
|||
|
|||
void Initialize(void* base, size_t size); |
|||
void* Translate(size_t addr); |
|||
void SaveSnapshot(const std::string& path); |
|||
void SaveDifferentialSnapshot(const std::string& path); |
|||
void ClearDirtySet(); |
|||
~FaultManagedAllocator(); |
|||
|
|||
private: |
|||
std::map<size_t, void*> page_map; |
|||
std::list<size_t> lru; |
|||
std::set<size_t> dirty_set; |
|||
std::unordered_map<size_t, std::vector<u8>> compressed_store; |
|||
std::mutex lock; |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__) |
|||
int uffd = -1; |
|||
std::atomic<bool> running{false}; |
|||
std::thread fault_handler; |
|||
void FaultThread(); |
|||
#elif defined(_WIN32) |
|||
void* base_address = nullptr; |
|||
size_t memory_size = 0; |
|||
HANDLE exception_port = nullptr; |
|||
std::atomic<bool> running{false}; |
|||
std::thread exception_handler; |
|||
void ExceptionHandlerThread(); |
|||
static LONG WINAPI VectoredExceptionHandler(PEXCEPTION_POINTERS exception_info); |
|||
static FaultManagedAllocator* current_instance; |
|||
#endif |
|||
|
|||
void Touch(size_t addr); |
|||
void EnforceLimit(); |
|||
void* GetOrAlloc(size_t addr); |
|||
}; |
|||
#endif |
|||
|
|||
class HybridMemory { |
|||
public: |
|||
explicit HybridMemory(const Device& device, MemoryAllocator& allocator, size_t reuse_history = 32); |
|||
~HybridMemory(); |
|||
|
|||
void InitializeGuestMemory(void* base, size_t size); |
|||
void* TranslateAddress(size_t addr); |
|||
|
|||
ComputeBuffer CreateComputeBuffer(VkDeviceSize size, VkBufferUsageFlags usage, MemoryUsage memory_type); |
|||
|
|||
void SaveSnapshot(const std::string& path); |
|||
void SaveDifferentialSnapshot(const std::string& path); |
|||
void ResetDirtyTracking(); |
|||
|
|||
private: |
|||
const Device& device; |
|||
MemoryAllocator& memory_allocator; |
|||
PredictiveReuseManager reuse_manager; |
|||
|
|||
#if defined(__linux__) || defined(__ANDROID__) || defined(_WIN32) |
|||
FaultManagedAllocator fmaa; |
|||
#endif |
|||
}; |
|||
|
|||
} // namespace Vulkan |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue