kernel: preserve guest pthread priorities

Extracted from Stefanos Costa's pthread fix in #147.

.github/workflows/build.yml

@@ -6,27 +6,9 @@ on:
     branches: [ main, master ]
   pull_request:
 
-env:
-  KYTY_BUILD_ORIGIN: ${{ github.repository != 'KytyPS5/KytyPS5' && 'Fork' || github.event_name == 'push' && 'Official' || 'Source' }}
-  KYTY_BUILD_REPOSITORY: ${{ github.repository }}
-
 jobs:
-  metadata:
-    name: Prepare build metadata
-    runs-on: ubuntu-latest
-    outputs:
-      release_tag: ${{ steps.release_tag.outputs.value }}
-
-    steps:
-      - name: Generate release tag
-        id: release_tag
-        shell: bash
-        run: |
-          echo "value=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_OUTPUT"
-
   windows:
     name: Build KytyPS5 (Windows)
-    needs: metadata
     runs-on: windows-2022
 
     steps:
@@ -94,9 +76,6 @@ jobs:
           cmake -S . -B _Build/windows ^
             -G Ninja ^
             -DCMAKE_BUILD_TYPE=Release ^
-            -DKYTY_BUILD_ORIGIN=%KYTY_BUILD_ORIGIN% ^
-            -DKYTY_BUILD_REPOSITORY=%KYTY_BUILD_REPOSITORY% ^
-            -DKYTY_RELEASE_TAG=${{ needs.metadata.outputs.release_tag }} ^
             -DCMAKE_C_COMPILER=clang-cl ^
             -DCMAKE_CXX_COMPILER=clang-cl ^
             -DCMAKE_PREFIX_PATH="%Qt6_DIR%"
@@ -125,7 +104,6 @@ jobs:
 
   macos:
     name: Build KytyPS5 (macOS)
-    needs: metadata
     runs-on: macos-15
 
     steps:
@@ -172,9 +150,6 @@ jobs:
           cmake -S . -B _Build/macos \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
-            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
-            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
-            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
             -DCMAKE_OSX_ARCHITECTURES=x86_64 \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
@@ -238,7 +213,6 @@ jobs:
 
   linux:
     name: Build KytyPS5 (Linux)
-    needs: metadata
     runs-on: ubuntu-24.04
 
     steps:
@@ -299,9 +273,6 @@ jobs:
           cmake -S . -B _Build/linux \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
-            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
-            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
-            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
             -DCMAKE_PREFIX_PATH="$Qt6_DIR" 2>&1 | tee _Build/configure.log
@@ -371,12 +342,10 @@ jobs:
   release:
     name: Release KytyPS5
     if: github.event_name == 'push' && github.repository == 'KytyPS5/KytyPS5'
-    needs: [metadata, windows, macos, linux]
+    needs: [windows, macos, linux]
     runs-on: ubuntu-latest
     permissions:
       contents: write
-    env:
-      RELEASE_NAME: ${{ needs.metadata.outputs.release_tag }}
 
     steps:
       - name: Download builds
@@ -384,6 +353,11 @@ jobs:
         with:
           path: artifacts
 
+      - name: Set release name
+        shell: bash
+        run: |
+          echo "RELEASE_NAME=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_ENV"
+
       - name: Package builds
         shell: bash
         run: |

CMakeLists.txt

@@ -28,29 +28,6 @@ include(CTest)
 
 option(KYTY_ENABLE_CLANG_TIDY "Run clang-tidy checks during builds" OFF)
 
-set(KYTY_BUILD_ORIGIN "Source" CACHE STRING "Build provenance shown in diagnostics")
-set_property(CACHE KYTY_BUILD_ORIGIN PROPERTY STRINGS Source Official Fork)
-if(NOT KYTY_BUILD_ORIGIN STREQUAL "Source" AND NOT KYTY_BUILD_ORIGIN STREQUAL "Official" AND
-   NOT KYTY_BUILD_ORIGIN STREQUAL "Fork")
-	message(FATAL_ERROR "KYTY_BUILD_ORIGIN must be Source, Official, or Fork")
-endif()
-
-set(KYTY_RELEASE_TAG "" CACHE STRING "Release tag embedded in official builds")
-set(KYTY_BUILD_REPOSITORY "" CACHE STRING "GitHub repository embedded in fork builds")
-set(KYTY_OFFICIAL_BUILD OFF)
-set(KYTY_FORK_BUILD OFF)
-if(KYTY_BUILD_ORIGIN STREQUAL "Official")
-	if(KYTY_RELEASE_TAG STREQUAL "")
-		message(FATAL_ERROR "Official builds require KYTY_RELEASE_TAG")
-	endif()
-	set(KYTY_OFFICIAL_BUILD ON)
-elseif(KYTY_BUILD_ORIGIN STREQUAL "Fork")
-	if(KYTY_BUILD_REPOSITORY STREQUAL "")
-		message(FATAL_ERROR "Fork builds require KYTY_BUILD_REPOSITORY")
-	endif()
-	set(KYTY_FORK_BUILD ON)
-endif()
-
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
 include(TestBigEndian)
@@ -140,20 +117,16 @@ configure_file(
 
 find_package(Git)
 
-add_custom_target(KytyGitVersion
-	COMMAND ${CMAKE_COMMAND}
-		-D INPUT_FILE=${KYTY_SOURCE_DIR}/kytyGitVersion.h.in
-		-D OUTPUT_FILE=${PROJECT_BINARY_DIR}/kytyGitVersion.h
-		-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
-		-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
-		-P ${KYTY_SOURCE_DIR}/generate_version.cmake
-	BYPRODUCTS ${PROJECT_BINARY_DIR}/kytyGitVersion.h
+add_custom_target( KytyGitVersion
+    COMMAND ${CMAKE_COMMAND}
+	-D INPUT_FILE=${KYTY_SOURCE_DIR}/kytyGitVersion.h.in
+	-D OUTPUT_FILE=${PROJECT_BINARY_DIR}/kytyGitVersion.h
+	-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
+	-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
+	-P ${KYTY_SOURCE_DIR}/generate_version.cmake
 	COMMENT "Generate kytyGitVersion.h"
 )
 
-add_library(kyty_git_version INTERFACE)
-add_dependencies(kyty_git_version KytyGitVersion)
-
 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
 	list(APPEND KYTY_IWYU
 		kyty_emulator
@@ -286,7 +259,7 @@ if (KYTY_CLANG_CL)
 	set_source_files_properties(${kyty_emulator_src} PROPERTIES COMPILE_FLAGS "-Wno-pragma-pack -Wno-deprecated-declarations -D_TIMESPEC_DEFINED")
 endif()
 
-set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9 kyty_git_version)
+set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9)
 
 # Linux system libraries required by the static FFmpeg archive.
 if(LINUX)
@@ -590,6 +563,8 @@ elseif(WIN32 OR LINUX)
 	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS} -Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
 endif()
 
+add_dependencies(kyty_emulator KytyGitVersion)
+
 if(APPLE)
 	# The emulator writes x86-64 trampolines/PLT stubs into memory and executes them, and
 	# runs guest code under Rosetta. That requires the JIT / unsigned-executable-memory

src/cmake_config.h.in

@@ -1,8 +1,4 @@
 #define KYTY_VERSION "@KYTY_VERSION@"
-#define KYTY_BUILD_REPOSITORY "@KYTY_BUILD_REPOSITORY@"
-#define KYTY_RELEASE_TAG "@KYTY_RELEASE_TAG@"
-#cmakedefine KYTY_OFFICIAL_BUILD
-#cmakedefine KYTY_FORK_BUILD
 #define KYTY_ENDIAN @KYTY_ENDIAN@
 #define KYTY_PLATFORM @KYTY_PLATFORM@
 #define KYTY_COMPILER KYTY_COMPILER_@KYTY_COMPILER@

src/common/emulatorConfig.cpp

@@ -33,18 +33,10 @@ uint32_t GetScreenHeight() {
 	return g_config->screen_height;
 }
 
-bool FullscreenEnabled() {
-	return g_config->fullscreen_enabled;
-}
-
 uint32_t GetVblankFrequency() {
 	return std::clamp(g_config->vblank_frequency, 30u, 360u);
 }
 
-uint32_t GetConsoleLanguage() {
-	return g_config->console_language;
-}
-
 bool VulkanValidationEnabled() {
 	return g_config->vulkan_validation_enabled;
 }
@@ -101,8 +93,4 @@ bool ReadbackLinearImagesEnabled() {
 	return g_config->readback_linear_images;
 }
 
-const Keymap& GetKeymap() {
-	return g_config->keymap;
-}
-
 } // namespace Config

src/common/emulatorConfig.h

@@ -5,8 +5,6 @@
 #include "common/subsystems.h"
 
 #include <filesystem>
-#include <string>
-#include <vector>
 
 namespace Config {
 
@@ -20,17 +18,10 @@ enum class ProfilerDirection { None, Network };
 
 enum class OutputDirection { Silent, Console, File };
 
-using Keymap = std::vector<std::string>;
-
-constexpr uint32_t DEFAULT_CONSOLE_LANGUAGE = 1;
-constexpr uint32_t MAX_CONSOLE_LANGUAGE     = 29;
-
 struct ConfigOptions {
 	uint32_t               screen_width                = 1280;
 	uint32_t               screen_height               = 720;
-	bool                   fullscreen_enabled          = false;
 	uint32_t               vblank_frequency            = 60;
-	uint32_t               console_language            = DEFAULT_CONSOLE_LANGUAGE;
 	bool                   vulkan_validation_enabled   = false;
 	bool                   shader_validation_enabled   = false;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::None;
@@ -45,16 +36,13 @@ struct ConfigOptions {
 	bool                   spirv_debug_printf_enabled  = false;
 	bool                   renderdoc_enabled           = false;
 	bool                   readback_linear_images      = false;
-	Keymap                 keymap;
 };
 
 void Load(const ConfigOptions& cfg);
 
 uint32_t GetScreenWidth();
 uint32_t GetScreenHeight();
-bool     FullscreenEnabled();
 uint32_t GetVblankFrequency();
-uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();
 
 bool                   ShaderValidationEnabled();
@@ -77,8 +65,6 @@ bool SpirvDebugPrintfEnabled();
 bool RenderDocEnabled();
 bool ReadbackLinearImagesEnabled();
 
-const Keymap& GetKeymap();
-
 } // namespace Config
 
 #endif /* KYTY_COMMON_EMULATOR_CONFIG_H_ */

src/generate_version.cmake

@@ -1,8 +1,7 @@
 set(KYTY_GIT_VERSION "unknown")
-set(KYTY_GIT_HASH "unknown")
 if(GIT_EXECUTABLE)
 	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
+		COMMAND "${GIT_EXECUTABLE}" describe --tags --always
 		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
 		OUTPUT_VARIABLE KYTY_GIT_VERSION
 		OUTPUT_STRIP_TRAILING_WHITESPACE
@@ -12,27 +11,5 @@ if(GIT_EXECUTABLE)
 	if(NOT GIT_RESULT EQUAL 0)
 		set(KYTY_GIT_VERSION "unknown")
 	endif()
-
-	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" rev-parse --short=7 HEAD
-		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
-		OUTPUT_VARIABLE KYTY_GIT_HASH
-		OUTPUT_STRIP_TRAILING_WHITESPACE
-		RESULT_VARIABLE GIT_HASH_RESULT
-		ERROR_QUIET
-	)
-	if(NOT GIT_HASH_RESULT EQUAL 0)
-		set(KYTY_GIT_HASH "unknown")
-	else()
-		execute_process(
-			COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
-			WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
-			RESULT_VARIABLE GIT_DIRTY_RESULT
-			ERROR_QUIET
-		)
-		if(NOT GIT_DIRTY_RESULT EQUAL 0)
-			string(APPEND KYTY_GIT_HASH "-dirty")
-		endif()
-	endif()
 endif()
 configure_file("${INPUT_FILE}" "${OUTPUT_FILE}")

src/graphics/guest_gpu/command_processor/commandProcessor.h

@@ -50,10 +50,23 @@ public:
 
 	void Reset();
 
-	void            BufferInit();
-	void            BufferFlush();
-	void            BufferFlushAndWait();
-	void            BufferWait();
+	void BufferInit();
+	void BufferFlush();
+	void BufferFlushAndWait();
+	void BufferWait();
+	void BeginReadbackTransaction() {
+		if (m_readback_active) {
+			EXIT("nested command-processor readback transaction\n");
+		}
+		m_readback_active = true;
+	}
+	void EndReadbackTransaction() {
+		if (!m_readback_active) {
+			EXIT("command-processor readback transaction is not active\n");
+		}
+		m_readback_active = false;
+	}
+
 	HW::Context&    GetCtx() { return m_ctx; }
 	HW::UserConfig& GetUcfg() { return m_ucfg; }
 	HW::Shader&     GetShCtx() { return m_sh_ctx; }
@@ -160,9 +173,10 @@ private:
 	// Persistent draw state: indirect draws update it for subsequent draws.
 	uint32_t m_num_instances = 1;
 
-	uint32_t m_de_count    = 0;
-	uint32_t m_ce_count    = 0;
-	bool     m_ce_complete = false;
+	uint32_t m_de_count        = 0;
+	uint32_t m_ce_count        = 0;
+	bool     m_ce_complete     = false;
+	bool     m_readback_active = false;
 
 	uint32_t m_const_ram[0x3000] = {0};
 

src/graphics/guest_gpu/graphicsRun.cpp

@@ -36,7 +36,6 @@ static thread_local CommandProcessor* g_current_processor = nullptr;
 static thread_local Pm4Execution*     g_current_execution = nullptr;
 static thread_local bool              g_gpu_mutex_owned   = false;
 static thread_local bool              g_gpu_thread        = false;
-static thread_local GpuState*         g_gpu_state         = nullptr;
 
 class GpuMutexLock final {
 public:
@@ -99,10 +98,11 @@ public:
 	void SubmitFlipPreparation(uint64_t request_id);
 	void Done();
 	void Shutdown();
-	[[nodiscard]] bool        IsStopping();
-	void                      SendCommand(Common::UniqueFunction<void>&& command);
-	void                      SendCommandSync(Common::UniqueFunction<void>&& command);
-	int                       GetFrameNum();
+	[[nodiscard]] bool IsStopping();
+	void               SendCommand(Common::UniqueFunction<void>&& command);
+	void               SendCommandSync(Common::UniqueFunction<void>&& command);
+	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);
+	int  GetFrameNum();
 	[[nodiscard]] static bool IsGpuThread() noexcept { return g_gpu_thread; }
 
 private:
@@ -127,7 +127,6 @@ private:
 	void              WaitLocked();
 	void              Enqueue(Submission submission);
 	void              WaitForIdle();
-	void              ProcessCommands();
 	bool              Process(Submission& submission);
 	static void       ThreadRun(void* data);
 	CommandProcessor& GetProcessor(uint32_t queue_id);
@@ -140,7 +139,6 @@ private:
 	Common::CondVar                                m_idle;
 	std::array<std::deque<Submission>, QueueCount> m_queues;
 	std::deque<Common::UniqueFunction<void>>       m_commands;
-	std::atomic_uint32_t                           m_pending_commands {0};
 	uint32_t                                       m_next_queue        = 0;
 	uint32_t                                       m_submission_count  = 0;
 	bool                                           m_processing        = false;
@@ -155,8 +153,6 @@ private:
 	uint64_t        m_submit_id = 0;
 	std::atomic_int m_done_num  = 0;
 	std::jthread    m_thread;
-
-	friend class CommandProcessor;
 };
 
 static bool GraphicsRunDebugDumpEnabled() {
@@ -199,25 +195,9 @@ void GpuState::SendCommand(Common::UniqueFunction<void>&& command) {
 	Common::LockGuard lock(m_queue_mutex);
 	EXIT_IF(!m_accepting);
 	m_commands.push_back(std::move(command));
-	m_pending_commands.fetch_add(1, std::memory_order_release);
 	m_work_available.Signal();
 }
 
-void GpuState::ProcessCommands() {
-	EXIT_IF(!IsGpuThread());
-	while (m_pending_commands.load(std::memory_order_acquire) != 0) {
-		Common::UniqueFunction<void> command;
-		{
-			Common::LockGuard lock(m_queue_mutex);
-			EXIT_IF(m_commands.empty());
-			command = std::move(m_commands.front());
-			m_commands.pop_front();
-			EXIT_IF(m_pending_commands.fetch_sub(1, std::memory_order_acq_rel) == 0);
-		}
-		command();
-	}
-}
-
 void GpuState::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	EXIT_IF(!command);
 	if (IsGpuThread()) {
@@ -232,6 +212,17 @@ void GpuState::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	done.acquire();
 }
 
+void GpuState::SendCommandSyncWithProcessor(
+    Common::UniqueFunction<void, CommandProcessor&>&& command) {
+	EXIT_IF(!command);
+	SendCommandSync([this, operation = std::move(command)]() mutable {
+		EXIT_IF(g_current_processor != nullptr);
+		g_current_processor = m_gfx_cp.get();
+		operation(*m_gfx_cp);
+		g_current_processor = nullptr;
+	});
+}
+
 void GpuState::Submit(uint32_t* cmd_draw_buffer, uint32_t num_draw_dw, uint32_t* cmd_const_buffer,
                       uint32_t num_const_dw, bool trigger_agc_interrupt_on_done) {
 	GpuMutexLock lock(m_submission_mutex);
@@ -518,7 +509,6 @@ void GpuState::ThreadRun(void* data) {
 	EXIT_IF(gpu == nullptr);
 	KYTY_PROFILER_THREAD("Thread_Gpu");
 	g_gpu_thread = true;
-	g_gpu_state  = gpu;
 
 	for (;;) {
 		Submission                   submission;
@@ -539,7 +529,6 @@ void GpuState::ThreadRun(void* data) {
 			} else if (!gpu->m_commands.empty()) {
 				command = std::move(gpu->m_commands.front());
 				gpu->m_commands.pop_front();
-				EXIT_IF(gpu->m_pending_commands.fetch_sub(1, std::memory_order_acq_rel) == 0);
 				gpu->m_processing = true;
 			} else {
 				int selected_queue = -1;
@@ -571,7 +560,6 @@ void GpuState::ThreadRun(void* data) {
 		}
 		if (should_stop) {
 			gpu->m_gfx_cp->BufferWait();
-			g_gpu_state  = nullptr;
 			g_gpu_thread = false;
 			return;
 		}
@@ -753,9 +741,6 @@ void CommandProcessor::SuspendPm4() {
 
 void CommandProcessor::ProcessPm4(Pm4Execution& execution, size_t stop_depth) {
 	while (execution.m_buffer_stack.size() > stop_depth) {
-		if (g_gpu_state != nullptr) {
-			g_gpu_state->ProcessCommands();
-		}
 		const auto buffer_index = execution.m_buffer_stack.size() - 1;
 		auto&      cursor       = execution.m_buffer_stack[buffer_index];
 		if (cursor.deferred_advance_dw != 0) {
@@ -1665,6 +1650,10 @@ void Gpu::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	m_state->SendCommandSync(std::move(command));
 }
 
+void Gpu::SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command) {
+	m_state->SendCommandSyncWithProcessor(std::move(command));
+}
+
 void Gpu::Submit(uint32_t* draw_commands, uint32_t draw_size_dw, uint32_t* constant_commands,
                  uint32_t constant_size_dw, bool trigger_agc_interrupt_on_done) {
 	EXIT_IF(draw_commands == nullptr || draw_size_dw == 0);
@@ -1690,8 +1679,12 @@ int Gpu::GetFrameNum() const {
 	return m_state->GetFrameNum();
 }
 
-bool Gpu::IsGpuThread() noexcept {
-	return GpuState::IsGpuThread();
+bool Gpu::IsCommandProcessorThread() noexcept {
+	return g_current_processor != nullptr;
+}
+
+CommandProcessor* Gpu::CurrentCommandProcessor() noexcept {
+	return g_current_processor;
 }
 
 } // namespace Libs::Graphics

src/graphics/guest_gpu/graphicsRun.h

@@ -9,6 +9,7 @@
 
 namespace Libs::Graphics {
 
+class CommandProcessor;
 class GpuState;
 class RenderContext;
 
@@ -22,6 +23,7 @@ public:
 	[[nodiscard]] bool IsStopping();
 	void               SendCommand(Common::UniqueFunction<void>&& command);
 	void               SendCommandSync(Common::UniqueFunction<void>&& command);
+	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);
 
 	void Submit(uint32_t* draw_commands, uint32_t draw_size_dw, uint32_t* constant_commands,
 	            uint32_t constant_size_dw, bool trigger_agc_interrupt_on_done = false);
@@ -31,7 +33,8 @@ public:
 	void Done();
 	[[nodiscard]] int GetFrameNum() const;
 
-	[[nodiscard]] static bool IsGpuThread() noexcept;
+	[[nodiscard]] static bool              IsCommandProcessorThread() noexcept;
+	[[nodiscard]] static CommandProcessor* CurrentCommandProcessor() noexcept;
 
 private:
 	std::unique_ptr<GpuState> m_state;

src/graphics/host_gpu/memoryTracker.h

@@ -29,29 +29,45 @@ public:
 	void               MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UntrackMemory(uint64_t vaddr, uint64_t size);
-	// Removes protection from a range and flushes GPU-owned data when required.
 	template <typename Flush>
-	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) noexcept {
+	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) {
 		static_assert(std::is_invocable_v<Flush&>);
 		CheckNotInUploadCallback();
 		ValidateRange(vaddr, size);
 
-		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-			const bool should_flush = [&] {
-				// Perform both the GPU modification check and CPU state change with the lock in
-				// case the GPU thread is racing to mark the page modified. If a flush is needed,
-				// on_flush performs the CPU state change.
-				std::scoped_lock lock(manager->lock);
-				if (manager->IsModified<DirtySource::Gpu>(offset, bytes)) {
-					return true;
-				}
-				manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-				return false;
-			}();
-			if (should_flush) {
-				on_flush();
+		const auto update_cpu_state = [this, vaddr, size] {
+			std::lock_guard             access(m_access_mutex);
+			std::vector<RegionManager*> managers;
+			Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t, uint64_t) {
+				managers.push_back(manager);
+			});
+			std::vector<std::unique_lock<TrackingSpinLock>> locks;
+			locks.reserve(managers.size());
+			for (auto* manager: managers) {
+				locks.emplace_back(manager->lock);
 			}
-		});
+			const bool gpu_modified = Iterate<false>(
+			    vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+				    return manager->IsModified<DirtySource::Gpu>(offset, bytes);
+			    });
+			if (gpu_modified) {
+				return true;
+			}
+			Iterate<false>(vaddr, size,
+			               [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+				               manager->ChangeState<DirtySource::Cpu, true>(
+				                   manager->GetCpuAddr() + offset, bytes);
+			               });
+			return false;
+		};
+
+		if (!update_cpu_state()) {
+			return;
+		}
+		std::forward<Flush>(on_flush)();
+		if (update_cpu_state()) {
+			EXIT("memory invalidation retained GPU-owned pages\n");
+		}
 	}
 #if KYTY_BUILD == KYTY_BUILD_DEBUG
 	void ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,

src/graphics/host_gpu/renderer/cache/bufferCache.cpp

@@ -3,18 +3,15 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
-#include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/cache/resourceMutex.h"
 #include "graphics/host_gpu/renderer/cache/textureCache.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 #include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
 #include "kernel/memory.h"
 
 #include <algorithm>
 #include <array>
-#include <cinttypes>
 #include <cstring>
 #include <utility>
 #include <vector>
@@ -291,29 +288,10 @@ void BufferCache::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 		return;
 	}
 	m_memory_tracker.InvalidateRegion(vaddr, size,
-	                                  [this, vaddr, size] { ReadMemory(vaddr, size, true); });
+	                                  [this, vaddr, size] { ReadMemory(vaddr, size); });
 }
 
-void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size, bool is_write) {
-	if (Gpu::IsGpuThread()) {
-		ReadMemoryOnGpu(vaddr, size, is_write);
-		return;
-	}
-	if (CommandScheduler::InDeferredOperation()) {
-		EXIT("unsupported buffer readback from an asynchronous GPU completion, "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	if (m_resource_mutex.IsOwnedByCurrentThread()) {
-		EXIT("unsupported buffer readback from a pre-owned resource transaction, "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	m_scheduler.Context().GetGpu().SendCommandSync(
-	    [this, vaddr, size, is_write] { ReadMemoryOnGpu(vaddr, size, is_write); });
-}
-
-void BufferCache::ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write) {
+void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size) {
 	std::vector<DownloadCopy> copies;
 	{
 		FaultSafeCacheLock lock(this, m_mutex);
@@ -344,16 +322,9 @@ void BufferCache::ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write)
 				    }
 			    }
 		    });
-		if (copies.empty()) {
-			if (!is_write) {
-				return;
-			}
-			// A preceding read fault can consume the last GPU-owned copy after this write
-			// invalidation has already chosen to flush. Complete the CPU ownership handoff even
-			// though this callback no longer has bytes to download.
-			m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
-			return;
-		}
+	}
+	if (copies.empty()) {
+		return;
 	}
 	auto downloads = RecordDownloads(copies);
 	m_scheduler.FinishCurrent();
@@ -365,9 +336,6 @@ void BufferCache::ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write)
 		}
 		// The enumeration above covered whole dirty pages and every exact interval on them.
 		m_memory_tracker.UnmarkRegionAsGpuModified(vaddr, size);
-		if (is_write) {
-			m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
-		}
 	}
 }
 

src/graphics/host_gpu/renderer/cache/bufferCache.h

@@ -46,7 +46,7 @@ public:
 	KYTY_CLASS_NO_COPY(BufferCache);
 
 	void                        InvalidateMemory(uint64_t vaddr, uint64_t size);
-	void                        ReadMemory(uint64_t vaddr, uint64_t size, bool is_write = false);
+	void                        ReadMemory(uint64_t vaddr, uint64_t size);
 	void                        UnmapMemory(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] BufferBinding ObtainBuffer(CommandBuffer& command, uint64_t vaddr, uint64_t size,
 	                                         bool is_written = false, bool is_read = true,
@@ -97,7 +97,6 @@ private:
 	void PublishDownloads(std::span<const DownloadRange> downloads);
 	void QueueGarbageDownload(std::span<const DownloadCopy> copies, RetiredBuffer retire);
 	void WriteHostMemory(uint64_t vaddr, std::span<const uint8_t> data);
-	void ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write);
 
 	GraphicContext&                                   m_graphics;
 	CommandScheduler&                                 m_scheduler;

src/graphics/host_gpu/renderer/cache/gpuResourceManager.cpp

@@ -1,6 +1,7 @@
 #include "graphics/host_gpu/renderer/cache/gpuResourceManager.h"
 
 #include "common/assert.h"
+#include "graphics/guest_gpu/command_processor/commandProcessor.h"
 #include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 namespace Libs::Graphics {
@@ -17,21 +18,69 @@ bool GpuResourceManager::HandleFault(PageFaultAccess access, uint64_t fault_vadd
 	if (!IsMapped(fault_vaddr, fault_size)) {
 		return false;
 	}
-	if (access == PageFaultAccess::Write) {
-		m_buffer_cache.InvalidateMemory(fault_vaddr, fault_size);
-		m_texture_cache.InvalidateMemory(fault_vaddr, fault_size);
-	} else {
-		m_buffer_cache.ReadMemory(fault_vaddr, fault_size);
+	if (CommandScheduler::InDeferredOperation()) {
+		EXIT("unsupported guest-memory fault from an asynchronous GPU completion, "
+		     "addr=0x%016" PRIx64 " access=%u\n",
+		     fault_vaddr, static_cast<uint32_t>(access));
 	}
-	return true;
+	bool       handled = false;
+	const auto resolve = [this, access, fault_vaddr, &handled](CommandProcessor& cp) {
+		cp.BeginReadbackTransaction();
+		{
+			ResourceMutex::FaultScope fault(m_resource_mutex);
+			if (access == PageFaultAccess::Write) {
+				m_buffer_cache.InvalidateMemory(fault_vaddr, fault_size);
+				m_texture_cache.InvalidateMemory(fault_vaddr, fault_size);
+			} else {
+				m_buffer_cache.ReadMemory(fault_vaddr, fault_size);
+			}
+			handled = true;
+		}
+		cp.EndReadbackTransaction();
+	};
+	if (auto* cp = Gpu::CurrentCommandProcessor(); cp != nullptr) {
+		resolve(*cp);
+		return handled;
+	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported page fault from a pre-owned resource transaction, addr=0x%016" PRIx64
+		     " access=%u\n",
+		     fault_vaddr, static_cast<uint32_t>(access));
+	}
+	EXIT_IF(m_gpu == nullptr);
+	m_gpu->SendCommandSyncWithProcessor(resolve);
+	return handled;
 }
 
 bool GpuResourceManager::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 	if (!IsMapped(vaddr, size)) {
 		return false;
 	}
-	m_buffer_cache.InvalidateMemory(vaddr, size);
-	m_texture_cache.InvalidateMemory(vaddr, size);
+	if (CommandScheduler::InDeferredOperation()) {
+		EXIT("unsupported memory invalidation from an asynchronous GPU completion, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	const auto resolve = [this, vaddr, size](CommandProcessor& cp) {
+		cp.BeginReadbackTransaction();
+		{
+			ResourceMutex::FaultScope fault(m_resource_mutex);
+			m_buffer_cache.InvalidateMemory(vaddr, size);
+			m_texture_cache.InvalidateMemory(vaddr, size);
+		}
+		cp.EndReadbackTransaction();
+	};
+	if (auto* cp = Gpu::CurrentCommandProcessor(); cp != nullptr) {
+		resolve(*cp);
+		return true;
+	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported memory invalidation from a pre-owned resource transaction, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	EXIT_IF(m_gpu == nullptr);
+	m_gpu->SendCommandSyncWithProcessor(resolve);
 	return true;
 }
 

src/graphics/host_gpu/renderer/cache/multiLevelPageTable.h

@@ -7,9 +7,8 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <cstring>
+#include <list>
 #include <memory>
-#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -104,158 +103,6 @@ private:
 	size_t                               m_allocated_buckets = 0;
 };
 
-// Inline owner storage for page-table entries. Texture pages normally have only a
-// handful of owners, so avoid a heap allocation on the first 16 registrations.
-//
-// Owners are packed into live uint64_t objects instead of being constructed in
-// raw storage. This keeps sparse bucket construction cheap without relying on
-// subtle implicit-lifetime or pointer-provenance rules.
-template <typename OwnerT, size_t InlineCapacity = 16>
-class InlinePageOwnerList final {
-public:
-	using value_type = OwnerT;
-	using size_type  = size_t;
-
-	class const_iterator final {
-	public:
-		[[nodiscard]] OwnerT operator*() const noexcept { return m_owners->At(m_index); }
-		const_iterator&      operator++() noexcept {
-			++m_index;
-			return *this;
-		}
-		bool operator==(const const_iterator&) const = default;
-
-	private:
-		friend class InlinePageOwnerList;
-		const_iterator(const InlinePageOwnerList* owners, size_type index) noexcept
-		    : m_owners(owners), m_index(index) {}
-
-		const InlinePageOwnerList* m_owners = nullptr;
-		size_type                  m_index  = 0;
-	};
-
-	static_assert(InlineCapacity > 0);
-	static_assert(std::is_default_constructible_v<OwnerT>);
-	static_assert(std::is_trivially_copyable_v<OwnerT>);
-	static_assert(std::has_unique_object_representations_v<OwnerT>);
-	static_assert(sizeof(OwnerT) <= sizeof(uint64_t));
-
-	InlinePageOwnerList() noexcept {}
-	InlinePageOwnerList(const InlinePageOwnerList&)            = delete;
-	InlinePageOwnerList& operator=(const InlinePageOwnerList&) = delete;
-	InlinePageOwnerList(InlinePageOwnerList&& other) noexcept
-	    : m_overflow(std::move(other.m_overflow)),
-	      m_inline_size(std::exchange(other.m_inline_size, 0)) {
-		if (m_overflow == nullptr) {
-			std::copy_n(other.m_inline.begin(), m_inline_size, m_inline.begin());
-		}
-	}
-	InlinePageOwnerList& operator=(InlinePageOwnerList&& other) noexcept {
-		if (this != &other) {
-			m_overflow    = std::move(other.m_overflow);
-			m_inline_size = std::exchange(other.m_inline_size, 0);
-			if (m_overflow == nullptr) {
-				std::copy_n(other.m_inline.begin(), m_inline_size, m_inline.begin());
-			}
-		}
-		return *this;
-	}
-
-	[[nodiscard]] const_iterator begin() const noexcept { return {this, 0}; }
-	[[nodiscard]] const_iterator end() const noexcept { return {this, size()}; }
-
-	[[nodiscard]] bool      empty() const noexcept { return size() == 0; }
-	[[nodiscard]] size_type size() const noexcept {
-		return m_overflow == nullptr ? m_inline_size : m_overflow->size();
-	}
-	[[nodiscard]] OwnerT front() const noexcept { return At(0); }
-	[[nodiscard]] OwnerT operator[](size_type index) const noexcept { return At(index); }
-
-	void push_back(const OwnerT& owner) {
-		const uint64_t packed = Pack(owner);
-		if (m_overflow != nullptr) {
-			m_overflow->push_back(packed);
-			return;
-		}
-		if (m_inline_size < InlineCapacity) {
-			m_inline[m_inline_size] = packed;
-			++m_inline_size;
-			return;
-		}
-		auto overflow = std::make_unique<std::vector<uint64_t>>();
-		overflow->reserve(InlineCapacity * 2);
-		overflow->assign(m_inline.begin(), m_inline.end());
-		overflow->push_back(packed);
-		m_overflow = std::move(overflow);
-	}
-
-	[[nodiscard]] bool Contains(const OwnerT& owner) const noexcept {
-		const uint64_t packed = Pack(owner);
-		if (m_overflow != nullptr) {
-			return std::find(m_overflow->begin(), m_overflow->end(), packed) != m_overflow->end();
-		}
-		return std::find(m_inline.begin(), m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size),
-		                 packed) != m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size);
-	}
-
-	[[nodiscard]] bool Erase(const OwnerT& owner) noexcept {
-		const uint64_t packed = Pack(owner);
-		if (m_overflow != nullptr) {
-			const auto found = std::find(m_overflow->begin(), m_overflow->end(), packed);
-			if (found == m_overflow->end()) {
-				return false;
-			}
-			m_overflow->erase(found);
-			if (m_overflow->size() == InlineCapacity) {
-				std::copy(m_overflow->begin(), m_overflow->end(), m_inline.begin());
-				m_inline_size = InlineCapacity;
-				m_overflow.reset();
-			}
-			return true;
-		}
-		const auto end   = m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size);
-		const auto found = std::find(m_inline.begin(), end, packed);
-		if (found == end) {
-			return false;
-		}
-		std::move(found + 1, end, found);
-		--m_inline_size;
-		return true;
-	}
-
-	template <typename Func>
-	void ForEach(Func&& func) const {
-		if (m_overflow != nullptr) {
-			for (const uint64_t owner: *m_overflow) {
-				func(Unpack(owner));
-			}
-			return;
-		}
-		for (size_type index = 0; index < m_inline_size; ++index) {
-			func(Unpack(m_inline[index]));
-		}
-	}
-
-private:
-	[[nodiscard]] OwnerT At(size_type index) const noexcept {
-		return Unpack(m_overflow == nullptr ? m_inline[index] : (*m_overflow)[index]);
-	}
-	[[nodiscard]] static uint64_t Pack(const OwnerT& owner) noexcept {
-		uint64_t packed = 0;
-		std::memcpy(&packed, &owner, sizeof(owner));
-		return packed;
-	}
-	[[nodiscard]] static OwnerT Unpack(uint64_t packed) noexcept {
-		OwnerT owner {};
-		std::memcpy(&owner, &packed, sizeof(owner));
-		return owner;
-	}
-
-	std::array<uint64_t, InlineCapacity>   m_inline;
-	std::unique_ptr<std::vector<uint64_t>> m_overflow;
-	size_type                              m_inline_size = 0;
-};
-
 // Removes only the requested owner. Other owners in the same page entry remain intact.
 template <typename Container, typename Value>
 [[nodiscard]] bool EraseExact(Container& owners, const Value& owner) {
@@ -267,6 +114,247 @@ template <typename Container, typename Value>
 	return true;
 }
 
+// Multi-range ownership with 1 MiB candidate buckets and precise 4 KiB
+// lifetime accounting. OwnerT only needs equality.
+template <typename OwnerT>
+class MultiRangePageOwnerIndex final {
+private:
+	struct Registration;
+	using MembershipList = std::vector<const Registration*>;
+
+public:
+	struct ByteRange final {
+		uint64_t address = 0;
+		uint64_t size    = 0;
+	};
+
+	using CoarseTable   = MultiLevelPageTable<MembershipList, 20, 40, 10>;
+	using TrackingTable = MultiLevelPageTable<MembershipList, 12, 40, 18>;
+
+	[[nodiscard]] bool Register(const OwnerT& owner, const std::vector<ByteRange>& ranges) {
+		if (FindRegistration(owner) != m_registrations.end()) {
+			return false;
+		}
+		auto normalized = Normalize(ranges);
+		if (normalized.empty()) {
+			return false;
+		}
+		m_registrations.push_back({owner, std::move(normalized)});
+		const Registration* registration = &m_registrations.back();
+		for (const size_t page: CollectPages<20>(registration->ranges)) {
+			m_coarse_pages[page].push_back(registration);
+		}
+		for (const size_t page: CollectPages<12>(registration->ranges)) {
+			m_tracking_pages[page].push_back(registration);
+		}
+		return true;
+	}
+
+	// No state changes if an expected membership is absent. Final releases are
+	// sorted and coalesced 4 KiB spans whose final owner disappeared.
+	[[nodiscard]] bool Unregister(const OwnerT& owner, std::vector<ByteRange>& final_releases) {
+		final_releases.clear();
+		auto registration = FindRegistration(owner);
+		if (registration == m_registrations.end()) {
+			return false;
+		}
+		const auto          coarse_pages     = CollectPages<20>(registration->ranges);
+		const auto          tracking_pages   = CollectPages<12>(registration->ranges);
+		const Registration* registration_ptr = &*registration;
+		if (!HasAllMemberships(m_coarse_pages, coarse_pages, registration_ptr) ||
+		    !HasAllMemberships(m_tracking_pages, tracking_pages, registration_ptr)) {
+			return false;
+		}
+		std::vector<size_t> final_pages;
+		for (const size_t page: coarse_pages) {
+			(void)EraseExact(*m_coarse_pages.Find(page), registration_ptr);
+		}
+		for (const size_t page: tracking_pages) {
+			auto& owners = *m_tracking_pages.Find(page);
+			if (owners.size() == 1) {
+				final_pages.push_back(page);
+			}
+			(void)EraseExact(owners, registration_ptr);
+		}
+		m_registrations.erase(registration);
+		final_releases = CoalesceTrackingPages(final_pages);
+		return true;
+	}
+
+	[[nodiscard]] std::vector<OwnerT> Query(uint64_t address, uint64_t size) const {
+		return Query(address, size, [](const OwnerT&) { return true; });
+	}
+
+	template <typename Predicate>
+	[[nodiscard]] std::vector<OwnerT> Query(uint64_t address, uint64_t size,
+	                                        Predicate&& predicate) const {
+		return QueryImpl(address, size, true, std::forward<Predicate>(predicate));
+	}
+
+	// Fault paths use page candidates: exact byte-disjoint owners sharing a
+	// touched 4 KiB page are intentionally retained.
+	[[nodiscard]] std::vector<OwnerT> QueryCandidates(uint64_t address, uint64_t size) const {
+		return QueryCandidates(address, size, [](const OwnerT&) { return true; });
+	}
+
+	template <typename Predicate>
+	[[nodiscard]] std::vector<OwnerT> QueryCandidates(uint64_t address, uint64_t size,
+	                                                  Predicate&& predicate) const {
+		return QueryImpl(address, size, false, std::forward<Predicate>(predicate));
+	}
+
+	[[nodiscard]] size_t CoarseMembershipCount(size_t page) const {
+		const auto* owners = m_coarse_pages.Find(page);
+		return owners == nullptr ? 0 : owners->size();
+	}
+	[[nodiscard]] size_t TrackingMembershipCount(size_t page) const {
+		const auto* owners = m_tracking_pages.Find(page);
+		return owners == nullptr ? 0 : owners->size();
+	}
+
+private:
+	template <typename Predicate>
+	[[nodiscard]] std::vector<OwnerT> QueryImpl(uint64_t address, uint64_t size, bool strict_bytes,
+	                                            Predicate&& predicate) const {
+		typename CoarseTable::PageRange   coarse_range {};
+		typename TrackingTable::PageRange tracking_range {};
+		if (!CoarseTable::TryGetPageRange(address, size, coarse_range) ||
+		    (!strict_bytes && !TrackingTable::TryGetPageRange(address, size, tracking_range))) {
+			return {};
+		}
+		MembershipList candidates;
+		for (size_t page = coarse_range.first; page < coarse_range.last_exclusive; ++page) {
+			if (const auto* owners = m_coarse_pages.Find(page); owners != nullptr) {
+				AppendUnique(candidates, *owners);
+			}
+		}
+		std::vector<OwnerT> result;
+		for (const Registration* registration: candidates) {
+			if ((strict_bytes ? Overlaps(registration->ranges, address, size)
+			                  : HasTrackingMembership(registration, tracking_range)) &&
+			    predicate(registration->owner)) {
+				result.push_back(registration->owner);
+			}
+		}
+		return result;
+	}
+
+	struct Registration final {
+		OwnerT                 owner;
+		std::vector<ByteRange> ranges;
+	};
+	using RegistrationIterator      = typename std::list<Registration>::iterator;
+	using ConstRegistrationIterator = typename std::list<Registration>::const_iterator;
+
+	[[nodiscard]] RegistrationIterator FindRegistration(const OwnerT& owner) {
+		return std::find_if(m_registrations.begin(), m_registrations.end(),
+		                    [&](const Registration& item) { return item.owner == owner; });
+	}
+	[[nodiscard]] ConstRegistrationIterator FindRegistration(const OwnerT& owner) const {
+		return std::find_if(m_registrations.begin(), m_registrations.end(),
+		                    [&](const Registration& item) { return item.owner == owner; });
+	}
+
+	[[nodiscard]] static std::vector<ByteRange> Normalize(const std::vector<ByteRange>& ranges) {
+		std::vector<ByteRange> sorted;
+		for (const auto& range: ranges) {
+			typename CoarseTable::PageRange ignored {};
+			if (!CoarseTable::TryGetPageRange(range.address, range.size, ignored)) {
+				return {};
+			}
+			sorted.push_back(range);
+		}
+		std::sort(sorted.begin(), sorted.end(), [](const ByteRange& lhs, const ByteRange& rhs) {
+			return lhs.address < rhs.address;
+		});
+		std::vector<ByteRange> merged;
+		for (const auto& range: sorted) {
+			if (merged.empty() || range.address > merged.back().address + merged.back().size) {
+				merged.push_back(range);
+			} else {
+				const uint64_t end = std::max(merged.back().address + merged.back().size,
+				                              range.address + range.size);
+				merged.back().size = end - merged.back().address;
+			}
+		}
+		return merged;
+	}
+
+	template <size_t Bits>
+	[[nodiscard]] static std::vector<size_t> CollectPages(const std::vector<ByteRange>& ranges) {
+		std::vector<size_t> pages;
+		for (const auto& range: ranges) {
+			const size_t first = static_cast<size_t>(range.address >> Bits);
+			const size_t last  = static_cast<size_t>((range.address + range.size - 1) >> Bits);
+			for (size_t page = first; page <= last; ++page) {
+				pages.push_back(page);
+			}
+		}
+		std::sort(pages.begin(), pages.end());
+		pages.erase(std::unique(pages.begin(), pages.end()), pages.end());
+		return pages;
+	}
+
+	template <typename Table>
+	[[nodiscard]] static bool HasAllMemberships(const Table&               table,
+	                                            const std::vector<size_t>& pages,
+	                                            const Registration*        registration) {
+		for (const size_t page: pages) {
+			const auto* owners = table.Find(page);
+			if (owners == nullptr ||
+			    std::find(owners->begin(), owners->end(), registration) == owners->end()) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	[[nodiscard]] bool HasTrackingMembership(const Registration*                      registration,
+	                                         const typename TrackingTable::PageRange& range) const {
+		for (size_t page = range.first; page < range.last_exclusive; ++page) {
+			const auto* owners = m_tracking_pages.Find(page);
+			if (owners != nullptr &&
+			    std::find(owners->begin(), owners->end(), registration) != owners->end()) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	[[nodiscard]] static bool Overlaps(const std::vector<ByteRange>& ranges, uint64_t address,
+	                                   uint64_t size) {
+		const uint64_t end = address + size;
+		return std::any_of(ranges.begin(), ranges.end(), [&](const ByteRange& range) {
+			return range.address < end && address < range.address + range.size;
+		});
+	}
+	static void AppendUnique(MembershipList& destination, const MembershipList& source) {
+		for (const Registration* registration: source) {
+			if (std::find(destination.begin(), destination.end(), registration) ==
+			    destination.end()) {
+				destination.push_back(registration);
+			}
+		}
+	}
+	[[nodiscard]] static std::vector<ByteRange>
+	CoalesceTrackingPages(const std::vector<size_t>& pages) {
+		std::vector<ByteRange> result;
+		for (const size_t page: pages) {
+			const uint64_t address = static_cast<uint64_t>(page) << 12;
+			if (!result.empty() && result.back().address + result.back().size == address) {
+				result.back().size += uint64_t {1} << 12;
+			} else {
+				result.push_back({address, uint64_t {1} << 12});
+			}
+		}
+		return result;
+	}
+
+	CoarseTable             m_coarse_pages;
+	TrackingTable           m_tracking_pages;
+	std::list<Registration> m_registrations;
+};
+
 } // namespace Libs::Graphics
 
 #endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_

src/graphics/host_gpu/renderer/cache/resourceMutex.cpp

@@ -4,10 +4,18 @@
 
 namespace Libs::Graphics {
 
+ResourceMutex::FaultScope::FaultScope(ResourceMutex& mutex): m_mutex(mutex) {
+	m_resource_preowned = m_mutex.BeginFault();
+}
+
+ResourceMutex::FaultScope::~FaultScope() {
+	m_mutex.EndFault(m_resource_preowned);
+}
+
 ResourceMutex::~ResourceMutex() {
 	std::lock_guard state(m_state);
-	if (m_resource_owner != std::thread::id {}) {
-		EXIT("ResourceMutex destroyed with an active owner\n");
+	if (m_resource_owner != std::thread::id {} || m_fault_owner != std::thread::id {}) {
+		EXIT("ResourceMutex destroyed with an active owner or fault transaction\n");
 	}
 }
 
@@ -18,6 +26,9 @@ void ResourceMutex::lock() {
 		if (m_resource_owner == current) {
 			EXIT("recursive resource transaction\n");
 		}
+		if (m_fault_owner == current) {
+			EXIT("resource transaction re-entered from a page-fault callback\n");
+		}
 	}
 	m_resource.lock();
 	std::lock_guard state(m_state);
@@ -44,4 +55,39 @@ bool ResourceMutex::IsOwnedByCurrentThread() {
 	return m_resource_owner == std::this_thread::get_id();
 }
 
+bool ResourceMutex::BeginFault() {
+	const auto current = std::this_thread::get_id();
+	{
+		std::lock_guard state(m_state);
+		if (m_fault_owner == current) {
+			EXIT("nested resource page-fault transaction\n");
+		}
+		if (m_resource_owner == current) {
+			m_fault_owner = current;
+			return true;
+		}
+	}
+	lock();
+	std::lock_guard state(m_state);
+	if (m_resource_owner != current || m_fault_owner != std::thread::id {}) {
+		EXIT("resource fault transaction acquired inconsistent ownership\n");
+	}
+	m_fault_owner = current;
+	return false;
+}
+
+void ResourceMutex::EndFault(bool resource_preowned) {
+	const auto current = std::this_thread::get_id();
+	{
+		std::lock_guard state(m_state);
+		if (m_fault_owner != current || m_resource_owner != current) {
+			EXIT("resource page-fault transaction ended with inconsistent ownership\n");
+		}
+		m_fault_owner = {};
+	}
+	if (!resource_preowned) {
+		unlock();
+	}
+}
+
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/resourceMutex.h

@@ -8,9 +8,21 @@
 
 namespace Libs::Graphics {
 
-// Owner-tracked shared buffer/image transaction.
+// Owner-tracked shared buffer/image transaction. External faults pause GPU submissions first;
+// command-processor faults drain pending guest processors before entering this transaction.
 class ResourceMutex final {
 public:
+	class FaultScope final {
+	public:
+		explicit FaultScope(ResourceMutex& mutex);
+		~FaultScope();
+		KYTY_CLASS_NO_COPY(FaultScope);
+
+	private:
+		ResourceMutex& m_mutex;
+		bool           m_resource_preowned = false;
+	};
+
 	ResourceMutex() = default;
 	~ResourceMutex();
 	KYTY_CLASS_NO_COPY(ResourceMutex);
@@ -20,9 +32,15 @@ public:
 	[[nodiscard]] bool IsOwnedByCurrentThread();
 
 private:
+	friend class FaultScope;
+
+	[[nodiscard]] bool BeginFault();
+	void               EndFault(bool resource_preowned);
+
 	std::mutex      m_resource;
 	std::mutex      m_state;
 	std::thread::id m_resource_owner;
+	std::thread::id m_fault_owner;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/textureCache.cpp

@@ -195,12 +195,10 @@ void TextureCache::RegisterImage(ImageId id) {
 	if (image.registered || image.info.data.Empty()) {
 		EXIT("TextureCache: invalid image registration\n");
 	}
-	ImagePageTable::PageRange pages {};
-	if (!ImagePageTable::TryGetPageRange(image.info.data.address, image.info.data.size, pages)) {
-		EXIT("TextureCache: image registration is outside the guest address space\n");
-	}
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		m_image_page_table[page].push_back(id);
+	std::vector<ImageOwnerIndex::ByteRange> ranges;
+	ranges.push_back({image.info.data.address, image.info.data.size});
+	if (!m_image_owner_index.Register(id, ranges)) {
+		EXIT("TextureCache: duplicate or invalid image registration\n");
 	}
 	image.registered = true;
 	image.lru_id     = m_lru_cache.Insert(id, m_gc_tick);
@@ -213,15 +211,9 @@ void TextureCache::UnregisterImage(ImageId id) {
 		return;
 	}
 	UntrackImage(id);
-	ImagePageTable::PageRange pages {};
-	if (!ImagePageTable::TryGetPageRange(image.info.data.address, image.info.data.size, pages)) {
-		EXIT("TextureCache: registered image is outside the guest address space\n");
-	}
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		auto* owners = m_image_page_table.Find(page);
-		if (owners == nullptr || !owners->Erase(id)) {
-			EXIT("TextureCache: image missing from page owner index\n");
-		}
+	std::vector<ImageOwnerIndex::ByteRange> releases;
+	if (!m_image_owner_index.Unregister(id, releases)) {
+		EXIT("TextureCache: image missing from owner index\n");
 	}
 	m_lru_cache.Free(image.lru_id);
 	const auto accounted = image.AccountedSize();
@@ -459,48 +451,10 @@ const Image& TextureCache::GetImage(ImageId id) const {
 	return ResolveImage(id);
 }
 
-TextureCache::ImageIds TextureCache::FindImagesInRegion(uint64_t address, uint64_t size,
-                                                        bool page_overlap) const {
-	ImagePageTable::PageRange pages {};
-	if (!ImagePageTable::TryGetPageRange(address, size, pages)) {
-		return {};
-	}
-
-	uint32_t query_epoch = ++m_image_query_epoch;
-	if (query_epoch == 0) {
-		for (const auto& slot: m_slots) {
-			if (slot.image != nullptr) {
-				slot.image->query_epoch = 0;
-			}
-		}
-		query_epoch = ++m_image_query_epoch;
-	}
-
-	ImageIds result;
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		const auto* owners = m_image_page_table.Find(page);
-		if (owners == nullptr) {
-			continue;
-		}
-		owners->ForEach([&](ImageId id) {
-			if (!id || id.index >= m_slots.size()) {
-				return;
-			}
-			const auto& slot = m_slots[id.index];
-			if (slot.generation != id.generation || slot.image == nullptr) {
-				return;
-			}
-			auto& image = *slot.image;
-			if (image.query_epoch == query_epoch) {
-				return;
-			}
-			image.query_epoch = query_epoch;
-			if (image.Overlaps(address, size, page_overlap)) {
-				result.push_back(id);
-			}
-		});
-	}
-	return result;
+std::vector<ImageId> TextureCache::FindImagesInRegion(uint64_t address, uint64_t size,
+                                                      bool page_overlap) const {
+	return page_overlap ? m_image_owner_index.QueryCandidates(address, size)
+	                    : m_image_owner_index.Query(address, size);
 }
 
 ImageId TextureCache::GetNullImage(const ImageDesc& desc) {
@@ -1198,9 +1152,9 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 	ImageId result {};
 	bool    inserted_new = false;
 	{
-		std::lock_guard transaction(m_resource_mutex);
-		CacheLock       lock(*this, m_lock);
-		const auto      candidates =
+		std::lock_guard            transaction(m_resource_mutex);
+		CacheLock                  lock(*this, m_lock);
+		const std::vector<ImageId> candidates =
 		    FindImagesInRegion(desc.info.data.address, desc.info.data.size, false);
 
 		for (const auto id: candidates) {

src/graphics/host_gpu/renderer/cache/textureCache.h

@@ -99,8 +99,7 @@ private:
 		int32_t layer = -1;
 	};
 
-	using ImageIds       = InlinePageOwnerList<ImageId, 16>;
-	using ImagePageTable = MultiLevelPageTable<ImageIds, 20, 40, 10>;
+	using ImageOwnerIndex = MultiRangePageOwnerIndex<ImageId>;
 
 	[[nodiscard]] Image&                 ResolveImage(ImageId id);
 	[[nodiscard]] const Image&           ResolveImage(ImageId id) const;
@@ -126,9 +125,8 @@ private:
 	[[nodiscard]] static BindingType UploadBinding(const Image& image);
 	[[nodiscard]] bool               SafeToDownload(const Image& image);
 
-	// Caller holds m_lock; it also serializes the per-image query epoch.
-	[[nodiscard]] ImageIds      FindImagesInRegion(uint64_t address, uint64_t size,
-	                                               bool page_overlap) const;
+	[[nodiscard]] std::vector<ImageId> FindImagesInRegion(uint64_t address, uint64_t size,
+	                                                      bool page_overlap) const;
 	[[nodiscard]] OverlapResult ResolveOverlap(const ImageInfo& requested, BindingType binding,
 	                                           ImageId cached, ImageId merged);
 	[[nodiscard]] ImageId       ResolveDepthOverlap(const ImageInfo& requested, BindingType binding,
@@ -171,7 +169,7 @@ private:
 	ResourceMutex&                                    m_resource_mutex;
 	std::vector<Slot>                                 m_slots;
 	std::vector<uint32_t>                             m_free_slots;
-	ImagePageTable                                    m_image_page_table;
+	ImageOwnerIndex                                   m_image_owner_index;
 	std::map<vk::Format, ImageId>                     m_null_images;
 	Common::LeastRecentlyUsedCache<ImageId, uint64_t> m_lru_cache;
 	std::set<ImageId>                                 m_download_images;
@@ -179,10 +177,9 @@ private:
 	uint64_t                                          m_total_used_memory  = 0;
 	uint64_t                                          m_trigger_gc_memory  = 0;
 	uint64_t                                          m_pressure_gc_memory = 1536ull * 1024 * 1024;
-	uint64_t         m_critical_gc_memory     = 3ull * 1024 * 1024 * 1024;
-	uint64_t         m_gc_tick                = 0;
-	mutable uint32_t m_image_query_epoch      = 0;
-	bool             m_readback_linear_images = false;
+	uint64_t m_critical_gc_memory     = 3ull * 1024 * 1024 * 1024;
+	uint64_t m_gc_tick                = 0;
+	bool     m_readback_linear_images = false;
 
 	friend struct TextureCacheTestAccess;
 	friend class BufferCache;

src/graphics/host_gpu/renderer/image/image.h

@@ -154,18 +154,17 @@ public:
 	}
 	[[nodiscard]] uint64_t HashGuestEdges() const;
 
-	ImageInfo        info;
-	VulkanImage      backing;
-	ImageViewCache   views;
-	ImageUsage       usage;
-	ImageBinding     binding;
-	bool             registered     = false;
-	mutable uint32_t query_epoch    = 0;
-	uint64_t         track_addr     = 0;
-	uint64_t         track_addr_end = 0;
-	ImageId          depth_id {};
-	uint64_t         tick_accessed_last = 0;
-	size_t           lru_id             = 0;
+	ImageInfo      info;
+	VulkanImage    backing;
+	ImageViewCache views;
+	ImageUsage     usage;
+	ImageBinding   binding;
+	bool           registered     = false;
+	uint64_t       track_addr     = 0;
+	uint64_t       track_addr_end = 0;
+	ImageId        depth_id {};
+	uint64_t       tick_accessed_last = 0;
+	size_t         lru_id             = 0;
 
 private:
 	friend struct ImageTestAccess;

src/graphics/host_gpu/renderer/renderDraw.cpp

@@ -664,10 +664,12 @@ struct DrawIndexBufferSource {
 
 struct PreparedIndexBuffer {
 	std::shared_ptr<void> owner;
-	vk::Buffer            buffer = nullptr;
-	uint64_t              size   = 0;
-	vk::DeviceSize        offset = 0;
-	vk::IndexType         type   = vk::IndexType::eUint16;
+	vk::Buffer            buffer   = nullptr;
+	uint64_t              address  = 0;
+	uint64_t              size     = 0;
+	vk::DeviceSize        offset   = 0;
+	vk::IndexType         type     = vk::IndexType::eUint16;
+	bool                  streamed = false;
 };
 
 static uint64_t VertexBufferDescriptorSize(const ShaderVertexInputBuffer& buffer) {
@@ -894,6 +896,12 @@ static std::vector<BufferBinding> PrepareVertexBuffers(uint64_t
 	return AcquireVertexBuffers(buffer, vs_input_info);
 }
 
+static void RebindVertexBuffers(RenderCommandBuffer&         buffer,
+                                const ShaderVertexInputInfo& vs_input_info,
+                                std::vector<BufferBinding>&  bindings) {
+	bindings = AcquireVertexBuffers(buffer, vs_input_info);
+}
+
 static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffer,
                                               const DrawIndexBufferSource& source) {
 	PreparedIndexBuffer prepared;
@@ -901,14 +909,16 @@ static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffe
 		return prepared;
 	}
 	EXIT_IF(source.size == 0);
-	prepared.size = source.size;
-	prepared.type = source.type;
+	prepared.address = source.address;
+	prepared.size    = source.size;
+	prepared.type    = source.type;
 	if (source.host_data != nullptr) {
 		auto binding =
 		    buffer.GetContext().GetBufferCache().UploadTransient(source.host_data, source.size, 16);
-		prepared.owner  = std::move(binding.owner);
-		prepared.buffer = binding.buffer;
-		prepared.offset = binding.offset;
+		prepared.owner    = std::move(binding.owner);
+		prepared.buffer   = binding.buffer;
+		prepared.offset   = binding.offset;
+		prepared.streamed = true;
 	} else {
 		auto binding =
 		    buffer.GetContext().GetBufferCache().ObtainBuffer(buffer, source.address, source.size);
@@ -919,6 +929,17 @@ static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffe
 	return prepared;
 }
 
+static void RebindIndexBuffer(RenderCommandBuffer& buffer, PreparedIndexBuffer& prepared) {
+	if (prepared.size == 0 || prepared.streamed) {
+		return;
+	}
+	auto binding =
+	    buffer.GetContext().GetBufferCache().ObtainBuffer(buffer, prepared.address, prepared.size);
+	prepared.owner  = std::move(binding.owner);
+	prepared.buffer = binding.buffer;
+	prepared.offset = binding.offset;
+}
+
 static void CommitVertexBuffers(RenderCommandBuffer& buffer, vk::CommandBuffer vk_buffer,
                                 std::vector<BufferBinding>& bindings) {
 	for (uint32_t slot = 0; slot < bindings.size(); slot++) {
@@ -1025,6 +1046,8 @@ void RenderExecutor::ExecutePreparedDraw(uint64_t submit_id, RenderCommandBuffer
 	                                               state.ps_input_info.stage, state.ps_active);
 	auto vertex_bindings = PrepareVertexBuffers(submit_id, buffer, draw, state.vs_input_info);
 	auto index_binding   = PrepareIndexBuffer(buffer, index_source);
+	RebindVertexBuffers(buffer, state.vs_input_info, vertex_bindings);
+	RebindIndexBuffer(buffer, index_binding);
 	state.rendering =
 	    AcquireRenderTargets(buffer, state.color_info, state.color_count, state.depth_info);
 

src/graphics/presentation/window/hostInput.cpp

@@ -1,256 +0,0 @@
-#include "graphics/presentation/window/hostInput.h"
-
-#include "SDL_keyboard.h"
-#include "SDL_keycode.h"
-#include "SDL_mouse.h"
-#include "common/assert.h"
-#include "common/emulatorConfig.h"
-#include "libs/controller.h"
-
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <string>
-#include <string_view>
-#include <utility>
-
-namespace Libs::Graphics {
-
-namespace {
-
-struct Binding {
-	SDL_Keycode key          = SDLK_UNKNOWN;
-	uint8_t     mouse_button = 0;
-	uint32_t    pad_button   = 0;
-};
-
-static constexpr std::array PAD_BUTTONS = {
-    std::pair {std::string_view("L3"), Controller::PAD_BUTTON_L3},
-    std::pair {std::string_view("R3"), Controller::PAD_BUTTON_R3},
-    std::pair {std::string_view("Options"), Controller::PAD_BUTTON_OPTIONS},
-    std::pair {std::string_view("Up"), Controller::PAD_BUTTON_UP},
-    std::pair {std::string_view("Right"), Controller::PAD_BUTTON_RIGHT},
-    std::pair {std::string_view("Down"), Controller::PAD_BUTTON_DOWN},
-    std::pair {std::string_view("Left"), Controller::PAD_BUTTON_LEFT},
-    std::pair {std::string_view("L2"), Controller::PAD_BUTTON_L2},
-    std::pair {std::string_view("R2"), Controller::PAD_BUTTON_R2},
-    std::pair {std::string_view("L1"), Controller::PAD_BUTTON_L1},
-    std::pair {std::string_view("R1"), Controller::PAD_BUTTON_R1},
-    std::pair {std::string_view("Triangle"), Controller::PAD_BUTTON_TRIANGLE},
-    std::pair {std::string_view("Circle"), Controller::PAD_BUTTON_CIRCLE},
-    std::pair {std::string_view("Cross"), Controller::PAD_BUTTON_CROSS},
-    std::pair {std::string_view("Square"), Controller::PAD_BUTTON_SQUARE},
-    std::pair {std::string_view("TouchPad"), Controller::PAD_BUTTON_TOUCH_PAD},
-};
-
-uint32_t PadButtonFromName(std::string_view name) {
-	const auto button = std::find_if(PAD_BUTTONS.begin(), PAD_BUTTONS.end(),
-	                                 [name](const auto& item) { return item.first == name; });
-	return button != PAD_BUTTONS.end() ? button->second : 0;
-}
-
-SDL_Keycode NormalizeKey(SDL_Keycode key) {
-	switch (key) {
-		case SDLK_RSHIFT: return SDLK_LSHIFT;
-		case SDLK_RCTRL: return SDLK_LCTRL;
-		case SDLK_RALT: return SDLK_LALT;
-		case SDLK_RGUI: return SDLK_LGUI;
-		default: return key;
-	}
-}
-
-uint8_t MouseButtonFromName(std::string_view name) {
-	static constexpr std::array buttons = {
-	    std::pair {std::string_view("Mouse:Left"), uint8_t {SDL_BUTTON_LEFT}},
-	    std::pair {std::string_view("Mouse:Middle"), uint8_t {SDL_BUTTON_MIDDLE}},
-	    std::pair {std::string_view("Mouse:Right"), uint8_t {SDL_BUTTON_RIGHT}},
-	    std::pair {std::string_view("Mouse:X1"), uint8_t {SDL_BUTTON_X1}},
-	    std::pair {std::string_view("Mouse:X2"), uint8_t {SDL_BUTTON_X2}},
-	};
-
-	const auto button = std::find_if(buttons.begin(), buttons.end(),
-	                                 [name](const auto& item) { return item.first == name; });
-	return button != buttons.end() ? button->second : 0;
-}
-
-bool Conflicts(const Binding& first, const Binding& second) {
-	return first.pad_button == second.pad_button ||
-	       (first.key != SDLK_UNKNOWN && first.key == second.key) ||
-	       (first.mouse_button != 0 && first.mouse_button == second.mouse_button);
-}
-
-class InputMap {
-public:
-	InputMap(): m_custom(!Config::GetKeymap().empty()) {
-		for (const auto& value: Config::GetKeymap()) {
-			const std::string_view entry = value;
-			const auto             split = entry.find('=');
-
-			Binding binding;
-			if (split != std::string_view::npos) {
-				binding.pad_button    = PadButtonFromName(entry.substr(0, split));
-				const auto host_input = entry.substr(split + 1);
-				binding.mouse_button  = MouseButtonFromName(host_input);
-				if (binding.mouse_button == 0) {
-					binding.key = NormalizeKey(SDL_GetKeyFromName(std::string(host_input).c_str()));
-				}
-			}
-
-			const bool reserved =
-			    binding.key == SDLK_ESCAPE || binding.key == SDLK_SPACE || binding.key == SDLK_F1;
-			if (binding.pad_button == 0 || reserved ||
-			    (binding.key == SDLK_UNKNOWN && binding.mouse_button == 0)) {
-				EXIT("Invalid input mapping: %s\n", value.c_str());
-			}
-			Add(binding);
-		}
-	}
-	[[nodiscard]] bool Custom() const { return m_custom; }
-
-	[[nodiscard]] uint32_t FindKey(int key_code) const {
-		key_code = NormalizeKey(static_cast<SDL_Keycode>(key_code));
-		const auto binding =
-		    std::find_if(m_bindings.begin(), m_bindings.begin() + m_size,
-		                 [key_code](const auto& item) { return item.key == key_code; });
-		return binding != m_bindings.begin() + m_size ? binding->pad_button : 0;
-	}
-
-	[[nodiscard]] uint32_t FindMouseButton(uint8_t mouse_button) const {
-		const auto binding = std::find_if(
-		    m_bindings.begin(), m_bindings.begin() + m_size,
-		    [mouse_button](const auto& item) { return item.mouse_button == mouse_button; });
-		return binding != m_bindings.begin() + m_size ? binding->pad_button : 0;
-	}
-
-private:
-	void Add(const Binding& binding) {
-		for (std::size_t index = 0; index < m_size;) {
-			if (Conflicts(m_bindings[index], binding)) {
-				m_bindings[index] = m_bindings[--m_size];
-			} else {
-				index++;
-			}
-		}
-		EXIT_IF(m_size >= m_bindings.size());
-		m_bindings[m_size++] = binding;
-	}
-
-	std::array<Binding, PAD_BUTTONS.size()> m_bindings {};
-	std::size_t                             m_size = 0;
-	bool                                    m_custom;
-};
-
-const InputMap& GetInputMap() {
-	static const InputMap map;
-	return map;
-}
-
-void SetButton(uint32_t button, bool down) {
-	if (button == Controller::PAD_BUTTON_L2) {
-		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
-		                           Controller::Axis::TriggerLeft, down ? 255 : 0);
-	} else if (button == Controller::PAD_BUTTON_R2) {
-		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
-		                           Controller::Axis::TriggerRight, down ? 255 : 0);
-	} else if (button != 0) {
-		Controller::ControllerButton(Controller::HOST_INPUT_CONTROLLER_ID, button, down);
-	}
-}
-
-uint32_t DefaultKeyboardButton(int key_code) {
-	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
-		case SDLK_UP: return Controller::PAD_BUTTON_UP;
-		case SDLK_LEFT: return Controller::PAD_BUTTON_LEFT;
-		case SDLK_DOWN: return Controller::PAD_BUTTON_DOWN;
-		case SDLK_RIGHT: return Controller::PAD_BUTTON_RIGHT;
-		case SDLK_j: return Controller::PAD_BUTTON_CROSS;
-		case SDLK_i: return Controller::PAD_BUTTON_TRIANGLE;
-		case SDLK_k: return Controller::PAD_BUTTON_SQUARE;
-		case SDLK_l: return Controller::PAD_BUTTON_CIRCLE;
-		case SDLK_q: return Controller::PAD_BUTTON_L1;
-		case SDLK_e: return Controller::PAD_BUTTON_R1;
-		case SDLK_LSHIFT: return Controller::PAD_BUTTON_L3;
-		case SDLK_LCTRL: return Controller::PAD_BUTTON_R3;
-		case SDLK_RETURN:
-		case SDLK_RETURN2: return Controller::PAD_BUTTON_OPTIONS;
-		case SDLK_BACKSPACE:
-		case SDLK_TAB: return Controller::PAD_BUTTON_TOUCH_PAD;
-		default: return 0;
-	}
-}
-
-struct StickKeys {
-	bool left  = false;
-	bool right = false;
-	bool up    = false;
-	bool down  = false;
-};
-
-void SetStickAxis(Controller::Axis axis, bool negative, bool positive) {
-	const int value = negative == positive ? 128 : negative ? 0 : 255;
-	Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID, axis, value);
-}
-
-void DefaultKeyboardInput(int key_code, bool down) {
-	static StickKeys left;
-	static StickKeys right;
-
-	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
-		case SDLK_a:
-			left.left = down;
-			SetStickAxis(Controller::Axis::LeftX, left.left, left.right);
-			return;
-		case SDLK_d:
-			left.right = down;
-			SetStickAxis(Controller::Axis::LeftX, left.left, left.right);
-			return;
-		case SDLK_w:
-			left.up = down;
-			SetStickAxis(Controller::Axis::LeftY, left.up, left.down);
-			return;
-		case SDLK_s:
-			left.down = down;
-			SetStickAxis(Controller::Axis::LeftY, left.up, left.down);
-			return;
-		case SDLK_f:
-			right.left = down;
-			SetStickAxis(Controller::Axis::RightX, right.left, right.right);
-			return;
-		case SDLK_h:
-			right.right = down;
-			SetStickAxis(Controller::Axis::RightX, right.left, right.right);
-			return;
-		case SDLK_t:
-			right.up = down;
-			SetStickAxis(Controller::Axis::RightY, right.up, right.down);
-			return;
-		case SDLK_g:
-			right.down = down;
-			SetStickAxis(Controller::Axis::RightY, right.up, right.down);
-			return;
-		default: SetButton(DefaultKeyboardButton(key_code), down); return;
-	}
-}
-} // namespace
-
-void HostInputInit() {
-	GetInputMap();
-}
-
-void HostInputKey(int key_code, bool down) {
-	const auto& map = GetInputMap();
-	if (map.Custom()) {
-		SetButton(map.FindKey(key_code), down);
-	} else {
-		DefaultKeyboardInput(key_code, down);
-	}
-}
-
-void HostInputMouseButton(uint8_t mouse_button, bool down) {
-	const auto& map = GetInputMap();
-	if (map.Custom() && mouse_button != 0) {
-		SetButton(map.FindMouseButton(mouse_button), down);
-	}
-}
-
-} // namespace Libs::Graphics

src/graphics/presentation/window/hostInput.h

@@ -1,14 +0,0 @@
-#ifndef KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_
-#define KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_
-
-#include <cstdint>
-
-namespace Libs::Graphics {
-
-void HostInputInit();
-void HostInputKey(int key_code, bool down);
-void HostInputMouseButton(uint8_t mouse_button, bool down);
-
-} // namespace Libs::Graphics
-
-#endif /* KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_ */

src/graphics/presentation/window/swapchain.cpp

@@ -789,14 +789,12 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		    [&window] {
 			    window.UpdateIcon();
 			    SDL_ShowWindow(window.window);
-			    SDL_RaiseWindow(window.window);
 		    },
 		    true);
 #else
 		window.UpdateIcon();
 
 		SDL_ShowWindow(window.window);
-		SDL_RaiseWindow(window.window);
 #endif
 
 		window.window_hidden = false;

src/graphics/presentation/window/window.cpp

@@ -32,9 +32,7 @@
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 #include "graphics/presentation/renderDoc.h"
-#include "graphics/presentation/window/hostInput.h"
 #include "graphics/presentation/window/windowInternal.h"
-#include "kytyGitVersion.h"
 #include "libs/controller.h"
 #include "loader/systemContent.h"
 
@@ -60,6 +58,8 @@
 
 namespace Libs::Graphics {
 
+constexpr int KEYBOARD_CONTROLLER_ID = -1000;
+
 struct EventKeyboard {
 	bool     down;
 	bool     up;
@@ -72,6 +72,26 @@ struct EventKeyboard {
 	double   timestamp_seconds;
 };
 
+static uint32_t KeyboardKeyToPadButton(int key_code) {
+	switch (key_code) {
+		case SDLK_w: return Controller::PAD_BUTTON_UP;
+		case SDLK_a: return Controller::PAD_BUTTON_LEFT;
+		case SDLK_s: return Controller::PAD_BUTTON_DOWN;
+		case SDLK_d: return Controller::PAD_BUTTON_RIGHT;
+		case SDLK_j: return Controller::PAD_BUTTON_CROSS;
+		case SDLK_i: return Controller::PAD_BUTTON_TRIANGLE;
+		case SDLK_k: return Controller::PAD_BUTTON_SQUARE;
+		case SDLK_l: return Controller::PAD_BUTTON_CIRCLE;
+		case SDLK_q: return Controller::PAD_BUTTON_L1;
+		case SDLK_e: return Controller::PAD_BUTTON_R1;
+		case SDLK_RETURN:
+		case SDLK_RETURN2: return Controller::PAD_BUTTON_OPTIONS;
+		case SDLK_BACKSPACE:
+		case SDLK_TAB: return Controller::PAD_BUTTON_TOUCH_PAD;
+		default: return 0;
+	}
+}
+
 static uint32_t ControllerButtonToPadButton(int button) {
 	switch (button) {
 		case SDL_CONTROLLER_BUTTON_A: return Controller::PAD_BUTTON_CROSS;
@@ -240,11 +260,16 @@ static void GameEventKeyboard(WindowLoopState& game, const EventKeyboard& key) {
 		}
 	}
 
-#endif
-
-	if ((key.down || key.up) && !key.repeat) {
-		HostInputKey(key.key_code, key.down);
+	const auto button = KeyboardKeyToPadButton(key.key_code);
+	if (button != 0 && (key.down || key.up) && !key.repeat) {
+		static bool keyboard_connected = false;
+		if (!keyboard_connected) {
+			Controller::ControllerConnect(KEYBOARD_CONTROLLER_ID);
+			keyboard_connected = true;
+		}
+		Controller::ControllerButton(KEYBOARD_CONTROLLER_ID, button, key.down);
 	}
+#endif
 }
 
 static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
@@ -266,23 +291,6 @@ static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
 		     mb.x, mb.y);
 	}
 #endif
-
-	if (mb.down || mb.up) {
-		uint8_t mouse_button = 0;
-		if (mb.left) {
-			mouse_button = SDL_BUTTON_LEFT;
-		} else if (mb.middle) {
-			mouse_button = SDL_BUTTON_MIDDLE;
-		} else if (mb.right) {
-			mouse_button = SDL_BUTTON_RIGHT;
-		} else if (mb.x1) {
-			mouse_button = SDL_BUTTON_X1;
-		} else if (mb.x2) {
-			mouse_button = SDL_BUTTON_X2;
-		}
-
-		HostInputMouseButton(mouse_button, mb.down);
-	}
 }
 
 static void GameEventFinger([[maybe_unused]] const EventFinger& f) {
@@ -786,14 +794,10 @@ static void WindowCreate(WindowContext& context) {
 	if (SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0) {
 		EXIT("%s\n", SDL_GetError());
 	}
-	HostInputInit();
 
 	LOGF("WindowCreate(): width = %d, height = %d\n", width, height);
 
 	uint32_t window_flags = KYTY_SDL_WINDOW_FLAGS;
-	if (Config::FullscreenEnabled()) {
-		window_flags |= static_cast<uint32_t>(SDL_WINDOW_FULLSCREEN_DESKTOP);
-	}
 #if defined(__APPLE__)
 	// macOS 26 window chrome (CoreUI asset decode, SwiftUI titlebar) has been observed
 	// throwing NSExceptions under Rosetta during the first CATransaction commit. A
@@ -933,22 +937,6 @@ void WindowContext::UpdateTitle() {
 	static uint64_t fps_frames  = 0;
 	static double   current_fps = 0.0;
 
-#if KYTY_BUILD == KYTY_BUILD_DEBUG
-	static constexpr auto build_type = "Debug";
-#elif KYTY_BUILD == KYTY_BUILD_RELEASE
-	static constexpr auto build_type = "Release";
-#else
-	static constexpr auto build_type = "Unknown";
-#endif
-
-#if defined(KYTY_OFFICIAL_BUILD)
-	static constexpr auto build_label = "Official build " KYTY_RELEASE_TAG;
-#elif defined(KYTY_FORK_BUILD)
-	static constexpr auto build_label = "Fork build " KYTY_BUILD_REPOSITORY " " KYTY_GIT_HASH;
-#else
-	static constexpr auto build_label = "Source build " KYTY_GIT_HASH;
-#endif
-
 	const auto now       = Common::Timer::QueryPerformanceCounter();
 	const auto frequency = Common::Timer::QueryPerformanceFrequency();
 	frame_num++;
@@ -960,11 +948,11 @@ void WindowContext::UpdateTitle() {
 		fps_frames  = 0;
 	}
 
-	auto fps = fmt::format("[{} | {}] {}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", build_label,
-	                       build_type, (has_title ? title : ""), (has_title ? ", " : ""),
-	                       (has_title_id ? title_id : ""), (has_title_id ? ", " : ""),
-	                       (has_app_ver ? app_ver : ""), (has_app_ver ? " " : ""), device_name,
-	                       processor_name, frame_num, current_fps);
+	auto fps =
+	    fmt::format("{}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", (has_title ? title : ""),
+	                (has_title ? ", " : ""), (has_title_id ? title_id : ""),
+	                (has_title_id ? ", " : ""), (has_app_ver ? app_ver : ""),
+	                (has_app_ver ? " " : ""), device_name, processor_name, frame_num, current_fps);
 
 #if defined(__APPLE__)
 	// AppKit traps on title changes off the main thread; fire-and-forget keeps present pacing.

src/graphics/shader/recompiler/ir/ResourceMaterialization.cpp

@@ -200,12 +200,12 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 		if (dimension == Decoder::ImageDimension::Unknown || dimension != image.dimension ||
 		    DescriptorIsCube(descriptor) != image.cube) {
 			if (error != nullptr) {
-				*error =
-				    fmt::format("image descriptor {} no longer matches specialized dimension: "
-				                "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
-				                i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
-				                descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
-				                descriptor.dwords[6], descriptor.dwords[7]);
+				*error = fmt::format(
+				    "image descriptor {} no longer matches specialized dimension: "
+				    "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
+				    i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
+				    descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
+				    descriptor.dwords[6], descriptor.dwords[7]);
 			}
 			return false;
 		}
@@ -224,17 +224,14 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 			const bool raw_sint_storage =
 			    storage && format == Prospero::GpuEnumValue(Prospero::BufferFormat::k32SInt) &&
 			    !image.read && !image.atomic;
-			const bool uint_descriptor = Prospero::IsUintTextureFormat(format) || raw_sint_storage;
-			const auto uint_program    = image.kind == ResourceKind::ImageUint ||
-			                             image.kind == ResourceKind::StorageImageUint;
+			const bool uint_descriptor =
+			    Prospero::IsUintTextureFormat(format) || raw_sint_storage;
+			const auto uint_program = image.kind == ResourceKind::ImageUint ||
+			                          image.kind == ResourceKind::StorageImageUint;
 			if (uint_descriptor != uint_program && !(image.atomic && uint_program)) {
 				if (error != nullptr) {
-					*error = fmt::format(
-					    "image descriptor {} no longer matches specialized format: "
-					    "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
-					    i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
-					    descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
-					    descriptor.dwords[6], descriptor.dwords[7]);
+					*error =
+					    fmt::format("image descriptor {} no longer matches specialized format", i);
 				}
 				return false;
 			}

src/kernel/fileSystem.cpp

@@ -64,7 +64,6 @@ struct File {
 	std::filesystem::path               real_name;
 	std::atomic_bool                    opened;
 	std::atomic_bool                    directory;
-	std::atomic_bool                    writable;
 	std::atomic_bool                    append;
 	std::atomic_bool                    sync_writes;
 	SpecialFile                         special;
@@ -130,7 +129,6 @@ int FileDescriptors::CreateDescriptor() {
 	auto* file        = new File {};
 	file->opened      = false;
 	file->directory   = false;
-	file->writable    = false;
 	file->append      = false;
 	file->sync_writes = false;
 	file->special     = SpecialFile::None;
@@ -276,10 +274,6 @@ static std::filesystem::path ResolvePathIgnoringCase(const std::filesystem::path
 
 	return resolved;
 }
-#else
-static bool HasWindowsForbiddenFilenameCharacter(const std::string& relative_path) {
-	return relative_path.find_first_of("<>:\"|?*") != std::string::npos;
-}
 #endif
 
 std::filesystem::path MountPoints::GetRealFilename(const std::string& mounted_file_name) {
@@ -299,10 +293,6 @@ std::filesystem::path MountPoints::GetRealFilename(const std::string& mounted_fi
 			rel_path = Common::RemoveFirst(rel_path, 1);
 		}
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-		if (HasWindowsForbiddenFilenameCharacter(rel_path)) {
-			::printf("FileSystem: Windows-incompatible guest filename: %s\n",
-			         mounted_file_name.c_str());
-		}
 		return p.dir / rel_path;
 #else
 		return ResolvePathIgnoringCase(p.dir / rel_path);
@@ -418,7 +408,6 @@ int KYTY_SYSV_ABI KernelOpen(const char* path, int flags, uint16_t mode) {
 	EXIT_IF(file == nullptr || file->opened || file->directory);
 
 	file->name        = path;
-	file->writable    = rw_mode != Common::File::Mode::Read;
 	file->append      = append;
 	file->sync_writes = fsync || sync || dsync;
 
@@ -964,47 +953,6 @@ int KYTY_SYSV_ABI KernelFstat(int d, FileStat* sb) {
 	return OK;
 }
 
-int KYTY_SYSV_ABI KernelFtruncate(int d, int64_t length) {
-	PRINT_NAME();
-
-	if (d < DESCRIPTOR_MIN) {
-		return KERNEL_ERROR_EBADF;
-	}
-
-	if (length < 0) {
-		return KERNEL_ERROR_EINVAL;
-	}
-
-	if (::Libs::Network::Net::IsSocket(d)) {
-		return KERNEL_ERROR_EINVAL;
-	}
-
-	auto* file = g_files->GetFile(d);
-
-	if (file == nullptr || !file->opened) {
-		return KERNEL_ERROR_EBADF;
-	}
-
-	if (!file->writable) {
-		return KERNEL_ERROR_EBADF;
-	}
-
-	if (file->directory || file->special != SpecialFile::None) {
-		return KERNEL_ERROR_EINVAL;
-	}
-
-	Common::LockGuard lock(file->mutex);
-
-	if (file->f.IsInvalid() || !file->f.Truncate(static_cast<uint64_t>(length))) {
-		return KERNEL_ERROR_EIO;
-	}
-
-	LOGF("\tFtruncate (size = %" PRId64 ") file: %s\n", length,
-	     Common::PathToString(file->real_name).c_str());
-
-	return OK;
-}
-
 int KYTY_SYSV_ABI KernelUnlink(const char* path) {
 	PRINT_NAME();
 

src/kernel/fileSystem.h

@@ -48,7 +48,6 @@ int64_t KYTY_SYSV_ABI KernelPwrite(int d, const void* buf, size_t nbytes, int64_
 int64_t KYTY_SYSV_ABI KernelLseek(int d, int64_t offset, int whence);
 int KYTY_SYSV_ABI     KernelStat(const char* path, FileStat* sb);
 int KYTY_SYSV_ABI     KernelFstat(int d, FileStat* sb);
-int KYTY_SYSV_ABI     KernelFtruncate(int d, int64_t length);
 int KYTY_SYSV_ABI     KernelUnlink(const char* path);
 int KYTY_SYSV_ABI     KernelRename(const char* from, const char* to);
 int KYTY_SYSV_ABI     KernelGetdirentries(int fd, char* buf, int nbytes, int64_t* basep);

src/kernel/memory.cpp

@@ -65,7 +65,7 @@ constexpr uint64_t PAGE_TABLE_POOL_SIZE   = 4ull * 1024ull * 1024ull * 1024ull;
 constexpr uint64_t PAGE_TABLE_GRANULARITY = 2ull * 1024ull * 1024ull;
 constexpr int      PAGE_TABLE_POOL_ENTRIES =
     static_cast<int>(PAGE_TABLE_POOL_SIZE / PAGE_TABLE_GRANULARITY);
-constexpr uint64_t DEFAULT_FLEXIBLE_MEMORY_SIZE = 1ull * 1024ull * 1024ull * 1024ull;
+constexpr uint64_t DEFAULT_FLEXIBLE_MEMORY_SIZE = 4ull * 1024ull * 1024ull * 1024ull;
 
 static uint64_t                      g_flexible_memory_size        = DEFAULT_FLEXIBLE_MEMORY_SIZE;
 static bool                          g_flexible_memory_size_frozen = false;

src/kernel/pthread.cpp

@@ -876,11 +876,9 @@ bool TestGuestStackOwnerLifecycle(uint64_t* first_address, uint64_t* second_addr
 
 static KYTY_SYSV_ABI void* RunOnGuestStack(void* arg, pthread_entry_func_t func, void* stack_top) {
 #if defined(__x86_64__) || defined(_M_X64)
-	void*      ret = nullptr;
-	const auto aligned_stack_top =
-	    reinterpret_cast<uintptr_t>(stack_top) & ~static_cast<uintptr_t>(0x0f);
-	const auto guest_rsp = aligned_stack_top - 2u * sizeof(uintptr_t);
-	const auto guest_rbp = guest_rsp;
+	void*      ret       = nullptr;
+	const auto guest_rsp = reinterpret_cast<uintptr_t>(stack_top) & ~static_cast<uintptr_t>(0x0f);
+	const auto guest_rbp = guest_rsp - 4u * sizeof(uint64_t);
 
 	auto* guest_root_frame = reinterpret_cast<uintptr_t*>(guest_rbp);
 	guest_root_frame[0]    = 0;
@@ -2296,7 +2294,6 @@ int KYTY_SYSV_ABI PthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedP
 		return KERNEL_ERROR_EINVAL;
 	}
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	KernelSchedParam pparam {};
 	if (param->sched_priority <= 478) {
 		pparam.sched_priority = +2;
@@ -2306,13 +2303,19 @@ int KYTY_SYSV_ABI PthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedP
 		pparam.sched_priority = 0;
 	}
 
-	if (pthread_attr_setschedparam(&attr_value->p, &pparam) != 0) {
-		return KERNEL_ERROR_EINVAL;
-	}
-#endif
+	int result = pthread_attr_setschedparam(&attr_value->p, &pparam);
 
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	if (result == 0) {
+		attr_value->guest_priority = param->sched_priority;
+		return OK;
+	}
+	return KERNEL_ERROR_EINVAL;
+#else
 	attr_value->guest_priority = param->sched_priority;
+	(void)result;
 	return OK;
+#endif
 }
 
 int KYTY_SYSV_ABI PthreadAttrSetschedpolicy(PthreadAttr* attr, int policy) {
@@ -3666,7 +3669,6 @@ int KYTY_SYSV_ABI PthreadSetprio(Pthread thread, int prio) {
 		return KERNEL_ERROR_EINVAL;
 	}
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	if (prio <= 478) {
 		param.sched_priority = +2;
 	} else if (prio >= 733) {
@@ -3675,14 +3677,20 @@ int KYTY_SYSV_ABI PthreadSetprio(Pthread thread, int prio) {
 		param.sched_priority = 0;
 	}
 
-	if (pthread_setschedparam(thread->p, pol, &param) != 0) {
-		return KERNEL_ERROR_EINVAL;
-	}
-#endif
+	result = pthread_setschedparam(thread->p, pol, &param);
 
+	if (result == 0) {
+		thread->attr->guest_priority = prio;
+		LOGF("\t PthreadSetprio: %d, %d\n", thread->unique_id, prio);
+		return OK;
+	}
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	return KERNEL_ERROR_EINVAL;
+#else
 	thread->attr->guest_priority = prio;
-	LOGF("\t PthreadSetprio: %d, %d\n", thread->unique_id, prio);
 	return OK;
+#endif
 }
 
 void KYTY_SYSV_ABI PthreadTestcancel() {

src/kytyGitVersion.h.in

@@ -1,2 +1 @@
-#define KYTY_GIT_VERSION "@KYTY_GIT_VERSION@"
-#define KYTY_GIT_HASH "@KYTY_GIT_HASH@"
+#define KYTY_GIT_VERSION "@KYTY_GIT_VERSION@"

src/launcher/CMakeLists.txt

@@ -16,7 +16,6 @@ file(GLOB launcher_forms
 add_executable(launcher WIN32
 	${launcher_src}
 	${launcher_forms}
-	resources.qrc
 )
 
 
@@ -38,6 +37,7 @@ elseif(LINUX)
 	set_target_properties(launcher PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS}")
 endif()
 
+add_dependencies(launcher KytyGitVersion)  
 add_dependencies(launcher kyty_emulator)
 
 if(KYTY_CLANG_CL)

src/launcher/forms/configuration_edit_dialog.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>560</width>
-    <height>450</height>
+    <height>420</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -78,16 +78,6 @@
            </property>
           </widget>
          </item>
-         <item row="2" column="0">
-          <widget class="QCheckBox" name="checkBox_fullscreen">
-           <property name="toolTip">
-            <string>Run in borderless desktop fullscreen</string>
-           </property>
-           <property name="text">
-            <string>Fullscreen</string>
-           </property>
-          </widget>
-         </item>
         </layout>
        </widget>
       </item>
@@ -129,55 +119,41 @@
        </widget>
       </item>
       <item row="3" column="0">
-       <widget class="QLabel" name="label_console_language">
-        <property name="text">
-         <string>Console language:</string>
-        </property>
-       </widget>
-      </item>
-      <item row="3" column="1">
-       <widget class="QComboBox" name="comboBox_console_language">
-        <property name="toolTip">
-         <string>Language</string>
-        </property>
-       </widget>
-      </item>
-      <item row="4" column="0">
        <widget class="QLabel" name="label_20">
         <property name="text">
          <string>Shader optimization type:</string>
         </property>
        </widget>
       </item>
-      <item row="4" column="1">
+      <item row="3" column="1">
        <widget class="QComboBox" name="comboBox_shader_optimization_type">
         <property name="toolTip">
          <string>Optimize shaders for code size or performance</string>
         </property>
        </widget>
       </item>
-      <item row="5" column="0">
+      <item row="4" column="0">
        <widget class="QLabel" name="label_21">
         <property name="text">
          <string>Shader log direction:</string>
         </property>
        </widget>
       </item>
-      <item row="5" column="1">
+      <item row="4" column="1">
        <widget class="QComboBox" name="comboBox_shader_log_direction">
         <property name="toolTip">
          <string>Dump shaders to file or console window. If enabled may decrease emulator performance</string>
         </property>
        </widget>
       </item>
-      <item row="6" column="0">
+      <item row="5" column="0">
        <widget class="QLabel" name="label_22">
         <property name="text">
          <string>Shader log folder:</string>
         </property>
        </widget>
       </item>
-      <item row="6" column="1">
+      <item row="5" column="1">
        <widget class="MandatoryLineEdit" name="lineEdit_shader_log_folder">
         <property name="toolTip">
          <string>Specify directory to dump shaders</string>
@@ -187,14 +163,14 @@
         </property>
        </widget>
       </item>
-      <item row="7" column="0">
+      <item row="6" column="0">
        <widget class="QLabel" name="label_24">
         <property name="text">
          <string>Command buffer dump folder:</string>
         </property>
        </widget>
       </item>
-      <item row="7" column="1">
+      <item row="6" column="1">
        <widget class="MandatoryLineEdit" name="lineEdit_cmd_dump_folder">
         <property name="toolTip">
          <string>Specify directory to dump command buffers</string>
@@ -204,28 +180,28 @@
         </property>
        </widget>
       </item>
-      <item row="8" column="0">
+      <item row="7" column="0">
        <widget class="QLabel" name="label_25">
         <property name="text">
          <string>Printf direction:</string>
         </property>
        </widget>
       </item>
-      <item row="8" column="1">
+      <item row="7" column="1">
        <widget class="QComboBox" name="comboBox_printf_direction">
         <property name="toolTip">
          <string>Print logs to file or console window. If enabled may decrease emulator performance</string>
         </property>
        </widget>
       </item>
-      <item row="9" column="0">
+      <item row="8" column="0">
        <widget class="QLabel" name="label_26">
         <property name="text">
          <string>Printf output file:</string>
         </property>
        </widget>
       </item>
-      <item row="9" column="1">
+      <item row="8" column="1">
        <widget class="MandatoryLineEdit" name="lineEdit_printf_file">
         <property name="toolTip">
          <string>Specify file to dump logs</string>
@@ -235,14 +211,14 @@
         </property>
        </widget>
       </item>
-      <item row="10" column="0">
+      <item row="9" column="0">
        <widget class="QLabel" name="label_27">
         <property name="text">
          <string>Profiler direction:</string>
         </property>
        </widget>
       </item>
-      <item row="10" column="1">
+      <item row="9" column="1">
        <widget class="QComboBox" name="comboBox_profiler_direction">
         <property name="toolTip">
          <string>Enable or disable profiler. If enabled may decrease emulator performance</string>

src/launcher/forms/configuration_list_widget.ui

@@ -69,31 +69,6 @@
            </property>
           </widget>
          </item>
-         <item>
-          <widget class="QToolButton" name="input_mapping_button">
-           <property name="minimumSize">
-            <size>
-             <width>36</width>
-             <height>36</height>
-            </size>
-           </property>
-           <property name="toolTip">
-            <string>Edit input mapping</string>
-           </property>
-           <property name="text">
-            <string/>
-           </property>
-           <property name="iconSize">
-            <size>
-             <width>32</width>
-             <height>32</height>
-            </size>
-           </property>
-           <property name="autoRaise">
-            <bool>true</bool>
-           </property>
-          </widget>
-         </item>
          <item>
           <widget class="QToolButton" name="edit_button">
            <property name="minimumSize">

src/launcher/icons/edit-configuration.svg

@@ -1,7 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
-  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
-    <path d="M8 4h11l5 5v7M24 9h-5V4M16 27H8a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2"/>
-    <path d="m15 24 1-4 8-8 4 4-8 8-4 1Z"/>
-    <path d="m22 14 4 4" opacity=".8"/>
-  </g>
-</svg>

src/launcher/icons/global-settings.svg

@@ -1,8 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
-  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
-    <path d="M5 8h3M14 8h13M5 16h13M24 16h3M5 24h6M17 24h10"/>
-    <circle cx="11" cy="8" r="3"/>
-    <circle cx="21" cy="16" r="3"/>
-    <circle cx="14" cy="24" r="3"/>
-  </g>
-</svg>

src/launcher/icons/input-mapping.svg

@@ -1,9 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
-  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
-    <path d="M10 10h12c3.6 0 5.8 2.3 6.6 6.8l.9 5.1c.4 2.4-.8 4.1-2.8 4.1-1.4 0-2.5-.7-3.6-2.3L21.3 21H10.7l-1.8 2.7C7.8 25.3 6.7 26 5.3 26c-2 0-3.2-1.7-2.8-4.1l.9-5.1C4.2 12.3 6.4 10 10 10Z"/>
-    <path d="M8 16h6M11 13v6"/>
-    <circle cx="22" cy="15" r="1" fill="#e8f1ff" stroke="none"/>
-    <circle cx="25" cy="18" r="1" fill="#e8f1ff" stroke="none"/>
-    <path d="M13 7h6M16 4v6" opacity=".8"/>
-  </g>
-</svg>

src/launcher/icons/remove-configuration.svg

@@ -1,6 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
-  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
-    <path d="M6 9h20M12 9V5h8v4M9 9l1 18h12l1-18"/>
-    <path d="M14 14v8M18 14v8" opacity=".8"/>
-  </g>
-</svg>

src/launcher/include/configuration.h

@@ -48,9 +48,6 @@ class Configuration: public QObject {
 	Q_OBJECT
 
 public:
-	static constexpr int DEFAULT_CONSOLE_LANGUAGE = 1;
-	static constexpr int MAX_CONSOLE_LANGUAGE     = 29;
-
 	enum class Resolution {
 		R1280X720,
 		R1920X1080,
@@ -85,9 +82,7 @@ public:
 	QString    game_comment;
 
 	Resolution             screen_resolution           = Resolution::R1280X720;
-	bool                   fullscreen_enabled          = false;
 	int                    vblank_frequency            = 60;
-	int                    console_language            = DEFAULT_CONSOLE_LANGUAGE;
 	bool                   vulkan_validation_enabled   = true;
 	bool                   shader_validation_enabled   = true;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::Performance;
@@ -99,15 +94,12 @@ public:
 	QString                printf_output_file          = "_kyty.txt";
 	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   renderdoc_enabled           = false;
-	QStringList            host_input_mapping;
 
 	QString elf = QStringLiteral("eboot.bin");
 
 	void CopyEmulatorSettingsFrom(const Configuration& other) {
 		screen_resolution           = other.screen_resolution;
-		fullscreen_enabled          = other.fullscreen_enabled;
 		vblank_frequency            = other.vblank_frequency;
-		console_language            = other.console_language;
 		vulkan_validation_enabled   = other.vulkan_validation_enabled;
 		shader_validation_enabled   = other.shader_validation_enabled;
 		shader_optimization_type    = other.shader_optimization_type;
@@ -119,7 +111,6 @@ public:
 		printf_output_file          = other.printf_output_file;
 		profiler_direction          = other.profiler_direction;
 		renderdoc_enabled           = other.renderdoc_enabled;
-		host_input_mapping          = other.host_input_mapping;
 	}
 
 	void CopyFrom(const Configuration& other) {
@@ -142,9 +133,7 @@ public:
 		KYTY_CFG_SET(game_path);
 		KYTY_CFG_SET(custom_settings);
 		KYTY_CFG_SET(screen_resolution);
-		KYTY_CFG_SET(fullscreen_enabled);
 		KYTY_CFG_SET(vblank_frequency);
-		KYTY_CFG_SET(console_language);
 		KYTY_CFG_SET(vulkan_validation_enabled);
 		KYTY_CFG_SET(shader_validation_enabled);
 		KYTY_CFG_SET(shader_optimization_type);
@@ -156,7 +145,6 @@ public:
 		KYTY_CFG_SET(printf_output_file);
 		KYTY_CFG_SET(profiler_direction);
 		KYTY_CFG_SET(renderdoc_enabled);
-		s->setValue("host_input_mapping", host_input_mapping);
 		KYTY_CFG_SET(elf);
 	}
 
@@ -166,12 +154,7 @@ public:
 		KYTY_CFG_GET(game_path);
 		KYTY_CFG_GET(custom_settings);
 		KYTY_CFG_GET(screen_resolution);
-		KYTY_CFG_GET(fullscreen_enabled);
 		vblank_frequency = s->value("vblank_frequency", vblank_frequency).toInt();
-		console_language = s->value("console_language", console_language).toInt();
-		if (console_language < 0 || console_language > MAX_CONSOLE_LANGUAGE) {
-			console_language = DEFAULT_CONSOLE_LANGUAGE;
-		}
 		KYTY_CFG_GET(vulkan_validation_enabled);
 		KYTY_CFG_GET(shader_validation_enabled);
 		KYTY_CFG_GET(shader_optimization_type);
@@ -183,8 +166,7 @@ public:
 		KYTY_CFG_GET(printf_output_file);
 		KYTY_CFG_GET(profiler_direction);
 		KYTY_CFG_GET(renderdoc_enabled);
-		host_input_mapping = s->value("host_input_mapping", host_input_mapping).toStringList();
-		elf                = s->value("elf", elf).toString();
+		elf = s->value("elf", elf).toString();
 	}
 };
 

src/launcher/include/configurationListWidget.h

@@ -38,10 +38,7 @@ public:
 
 	[[nodiscard]] const QString&     GetSettingsFile() const { return m_settings_file; }
 	[[nodiscard]] const QStringList& GetGameDirectories() const { return m_game_dirs; }
-	[[nodiscard]] const QStringList& GetHostInputMapping() const {
-		return m_global_info.host_input_mapping;
-	}
-	[[nodiscard]] bool CanViewSelectedTrophies() const;
+	[[nodiscard]] bool               CanViewSelectedTrophies() const;
 
 	bool EnsureGameDirectory();
 	void ScanGameDirectory();
@@ -61,7 +58,6 @@ protected slots:
 	void edit_configuration();
 	void delete_configuartion();
 	void edit_global_settings();
-	void edit_input_mapping();
 	void run_configuration();
 	void list_currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);
 	void list_itemDoubleClicked(QTreeWidgetItem* witem, int column);

src/launcher/include/inputMappingDialog.h

@@ -1,31 +0,0 @@
-#ifndef LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_
-#define LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_
-
-#include <QDialog>
-#include <QStringList>
-
-class QPushButton;
-class QTreeWidget;
-class QTreeWidgetItem;
-class QWidget;
-
-class InputMappingDialog final: public QDialog {
-public:
-	explicit InputMappingDialog(const QStringList& mapping, QWidget* parent = nullptr);
-
-	[[nodiscard]] QStringList Mapping() const;
-
-private:
-	void ChangeBinding();
-	void ClearBinding();
-	void RestoreDefaults();
-	void SetBinding(QTreeWidgetItem* item, const QString& binding);
-	void UpdateButtons();
-
-	QTreeWidget* m_bindings      = nullptr;
-	QPushButton* m_change_button = nullptr;
-	QPushButton* m_clear_button  = nullptr;
-	bool         m_customized    = false;
-};
-
-#endif /* LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_ */

src/launcher/resources.qrc

@@ -1,8 +0,0 @@
-<RCC>
- <qresource prefix="/icons">
-  <file alias="edit-configuration.svg">icons/edit-configuration.svg</file>
-  <file alias="global-settings.svg">icons/global-settings.svg</file>
-  <file alias="input-mapping.svg">icons/input-mapping.svg</file>
-  <file alias="remove-configuration.svg">icons/remove-configuration.svg</file>
- </qresource>
-</RCC>

src/launcher/src/configurationEditDialog.cpp

@@ -30,39 +30,6 @@ constexpr char SETTINGS_CFG_DIALOG[]               = "ConfigurationEditDialog";
 constexpr char SETTINGS_CFG_LAST_GEOMETRY[]        = "geometry";
 constexpr int  GLOBAL_SETTINGS_GAME_DIRS_MIN_WIDTH = 560;
 
-const QStringList CONSOLE_LANGUAGE_NAMES = {
-    "Japanese",
-    "English (United States)",
-    "French (France)",
-    "Spanish (Spain)",
-    "German",
-    "Italian",
-    "Dutch",
-    "Portuguese (Portugal)",
-    "Russian",
-    "Korean",
-    "Chinese (Traditional)",
-    "Chinese (Simplified)",
-    "Finnish",
-    "Swedish",
-    "Danish",
-    "Norwegian",
-    "Polish",
-    "Portuguese (Brazil)",
-    "English (United Kingdom)",
-    "Turkish",
-    "Spanish (Latin America)",
-    "Arabic",
-    "French (Canada)",
-    "Czech",
-    "Hungarian",
-    "Greek",
-    "Romanian",
-    "Thai",
-    "Vietnamese",
-    "Indonesian",
-};
-
 static QString NormalizeGameDirectory(const QString& dir) {
 	const auto trimmed = dir.trimmed();
 	if (trimmed.isEmpty()) {
@@ -153,14 +120,7 @@ static void ListInit(QComboBox* combo, T value) {
 
 void ConfigurationEditDialog::Init(const Configuration& info) {
 	ListInit(m_ui->comboBox_screen_resolution, info.screen_resolution);
-	m_ui->checkBox_fullscreen->setChecked(info.fullscreen_enabled);
 	m_ui->spinBox_vblank_frequency->setValue(info.vblank_frequency);
-	m_ui->comboBox_console_language->clear();
-	m_ui->comboBox_console_language->addItems(CONSOLE_LANGUAGE_NAMES);
-	m_ui->comboBox_console_language->setCurrentIndex(
-	    info.console_language >= 0 && info.console_language < CONSOLE_LANGUAGE_NAMES.size()
-	        ? info.console_language
-	        : Configuration::DEFAULT_CONSOLE_LANGUAGE);
 	m_ui->checkBox_shader_validation->setChecked(info.shader_validation_enabled);
 	m_ui->checkBox_vulkan_validation->setChecked(info.vulkan_validation_enabled);
 	m_ui->checkBox_renderdoc_capture->setChecked(info.renderdoc_enabled);
@@ -280,9 +240,7 @@ void ConfigurationEditDialog::moveEvent(QMoveEvent* event) {
 static void UpdateInfo(Configuration& info, Ui::ConfigurationEditDialog& ui) {
 	info.screen_resolution =
 	    TextToEnum<Configuration::Resolution>(ui.comboBox_screen_resolution->currentText());
-	info.fullscreen_enabled        = ui.checkBox_fullscreen->isChecked();
 	info.vblank_frequency          = ui.spinBox_vblank_frequency->value();
-	info.console_language          = ui.comboBox_console_language->currentIndex();
 	info.vulkan_validation_enabled = ui.checkBox_vulkan_validation->isChecked();
 	info.shader_validation_enabled = ui.checkBox_shader_validation->isChecked();
 	info.renderdoc_enabled         = ui.checkBox_renderdoc_capture->isChecked();

src/launcher/src/configurationListWidget.cpp

@@ -6,7 +6,6 @@
 #include "configurationEditDialog.h"
 #include "configurationItem.h"
 #include "gameListTreeWidget.h"
-#include "inputMappingDialog.h"
 #include "mainDialog.h"
 #include "patchesDialog.h"
 #include "trophyViewerDialog.h"
@@ -170,7 +169,6 @@ static void ApplyGameListStyle(Ui::ConfigurationListWidget* ui) {
 	    "QToolButton:disabled { background: transparent; }"));
 	ui->edit_button->setStyleSheet(ui->global_settings_button->styleSheet());
 	ui->delete_button->setStyleSheet(ui->global_settings_button->styleSheet());
-	ui->input_mapping_button->setStyleSheet(ui->global_settings_button->styleSheet());
 }
 
 static void AddSaveDataDir(QStringList* dirs, QSet<QString>* seen, const QString& root,
@@ -228,12 +226,10 @@ ConfigurationListWidget::ConfigurationListWidget(QWidget* parent)
 	m_ui->setupUi(this);
 	ApplyGameListStyle(m_ui);
 
-	m_ui->global_settings_button->setIcon(QIcon(QStringLiteral(":/icons/global-settings.svg")));
+	m_ui->global_settings_button->setIcon(style()->standardIcon(QStyle::SP_FileDialogDetailedView));
 	m_ui->global_settings_button->setToolTip(tr("Edit global settings and game folders"));
-	m_ui->input_mapping_button->setIcon(QIcon(QStringLiteral(":/icons/input-mapping.svg")));
-	m_ui->input_mapping_button->setToolTip(tr("Edit global input mapping"));
-	m_ui->edit_button->setIcon(QIcon(QStringLiteral(":/icons/edit-configuration.svg")));
-	m_ui->delete_button->setIcon(QIcon(QStringLiteral(":/icons/remove-configuration.svg")));
+	m_ui->edit_button->setIcon(style()->standardIcon(QStyle::SP_FileIcon));
+	m_ui->delete_button->setIcon(style()->standardIcon(QStyle::SP_DialogDiscardButton));
 
 	m_ui->delete_button->setEnabled(false);
 	m_ui->edit_button->setEnabled(false);
@@ -253,8 +249,6 @@ ConfigurationListWidget::ConfigurationListWidget(QWidget* parent)
 
 	connect(m_ui->global_settings_button, &QToolButton::clicked, this,
 	        &ConfigurationListWidget::edit_global_settings);
-	connect(m_ui->input_mapping_button, &QToolButton::clicked, this,
-	        &ConfigurationListWidget::edit_input_mapping);
 	connect(m_ui->edit_button, &QToolButton::clicked, this,
 	        &ConfigurationListWidget::edit_configuration);
 	connect(m_ui->delete_button, &QToolButton::clicked, this,
@@ -723,14 +717,6 @@ void ConfigurationListWidget::edit_global_settings() {
 	}
 }
 
-void ConfigurationListWidget::edit_input_mapping() {
-	InputMappingDialog dialog(m_global_info.host_input_mapping, this);
-	if (dialog.exec() == QDialog::Accepted) {
-		m_global_info.host_input_mapping = dialog.Mapping();
-		WriteSettings();
-	}
-}
-
 void ConfigurationListWidget::ClearCustomSettings(ConfigurationItem* item) {
 	delete m_custom_infos.take(item->GetInfo().game_path);
 }

src/launcher/src/inputMappingDialog.cpp

@@ -1,311 +0,0 @@
-#include "inputMappingDialog.h"
-
-#include <QAbstractItemView>
-#include <QDialogButtonBox>
-#include <QHBoxLayout>
-#include <QHash>
-#include <QHeaderView>
-#include <QKeyEvent>
-#include <QKeySequence>
-#include <QLabel>
-#include <QMouseEvent>
-#include <QPushButton>
-#include <QStringList>
-#include <QTreeWidget>
-#include <QVBoxLayout>
-
-namespace {
-
-constexpr int BINDING_COLUMN = 1;
-
-struct PadButton {
-	const char* id;
-	const char* label;
-	const char* default_binding;
-};
-
-constexpr PadButton PAD_BUTTONS[] = {
-    {"Up", "D-pad Up", "Up"},
-    {"Down", "D-pad Down", "Down"},
-    {"Left", "D-pad Left", "Left"},
-    {"Right", "D-pad Right", "Right"},
-    {"Triangle", "Triangle", "I"},
-    {"Circle", "Circle", "L"},
-    {"Cross", "Cross", "J"},
-    {"Square", "Square", "K"},
-    {"L1", "L1", "Q"},
-    {"R1", "R1", "E"},
-    {"L2", "L2", ""},
-    {"R2", "R2", ""},
-    {"L3", "L3", "Left Shift"},
-    {"R3", "R3", "Left Ctrl"},
-    {"Options", "Options", "Return"},
-    {"TouchPad", "Touch pad", "Backspace"},
-};
-
-QString KeypadName(int key) {
-	if (key >= Qt::Key_0 && key <= Qt::Key_9) {
-		return QStringLiteral("Keypad %1").arg(key - Qt::Key_0);
-	}
-
-	switch (key) {
-		case Qt::Key_Return:
-		case Qt::Key_Enter: return QStringLiteral("Keypad Enter");
-		case Qt::Key_Slash: return QStringLiteral("Keypad /");
-		case Qt::Key_Asterisk: return QStringLiteral("Keypad *");
-		case Qt::Key_Minus: return QStringLiteral("Keypad -");
-		case Qt::Key_Plus: return QStringLiteral("Keypad +");
-		case Qt::Key_Period: return QStringLiteral("Keypad .");
-		case Qt::Key_Equal: return QStringLiteral("Keypad =");
-		case Qt::Key_Comma: return QStringLiteral("Keypad ,");
-		default: return {};
-	}
-}
-
-QString KeyName(const QKeyEvent& event) {
-	const int key = event.key();
-	if (event.modifiers().testFlag(Qt::KeypadModifier)) {
-		return KeypadName(key);
-	}
-	if (key >= Qt::Key_A && key <= Qt::Key_Z) {
-		return QChar(key);
-	}
-	if (key >= Qt::Key_0 && key <= Qt::Key_9) {
-		return QChar(key);
-	}
-	if (key >= Qt::Key_F1 && key <= Qt::Key_F24) {
-		return QStringLiteral("F%1").arg(key - Qt::Key_F1 + 1);
-	}
-
-	switch (key) {
-		case Qt::Key_Return:
-		case Qt::Key_Enter: return QStringLiteral("Return");
-		case Qt::Key_Backspace: return QStringLiteral("Backspace");
-		case Qt::Key_Tab: return QStringLiteral("Tab");
-		case Qt::Key_Shift: return QStringLiteral("Left Shift");
-		case Qt::Key_Control: return QStringLiteral("Left Ctrl");
-		case Qt::Key_Alt: return QStringLiteral("Left Alt");
-		case Qt::Key_Meta: return QStringLiteral("Left GUI");
-		case Qt::Key_Insert: return QStringLiteral("Insert");
-		case Qt::Key_Delete: return QStringLiteral("Delete");
-		case Qt::Key_Home: return QStringLiteral("Home");
-		case Qt::Key_End: return QStringLiteral("End");
-		case Qt::Key_PageUp: return QStringLiteral("PageUp");
-		case Qt::Key_PageDown: return QStringLiteral("PageDown");
-		case Qt::Key_Left: return QStringLiteral("Left");
-		case Qt::Key_Right: return QStringLiteral("Right");
-		case Qt::Key_Up: return QStringLiteral("Up");
-		case Qt::Key_Down: return QStringLiteral("Down");
-		case Qt::Key_CapsLock: return QStringLiteral("CapsLock");
-		case Qt::Key_NumLock: return QStringLiteral("Numlock");
-		case Qt::Key_ScrollLock: return QStringLiteral("ScrollLock");
-		case Qt::Key_Pause: return QStringLiteral("Pause");
-		case Qt::Key_Print: return QStringLiteral("PrintScreen");
-		default: break;
-	}
-
-	if (event.modifiers() != Qt::NoModifier) {
-		return {};
-	}
-	const auto name = QKeySequence(key).toString(QKeySequence::PortableText);
-	return name.size() == 1 ? name : QString();
-}
-
-class InputCaptureDialog final: public QDialog {
-public:
-	explicit InputCaptureDialog(QWidget* parent): QDialog(parent) {
-		setWindowTitle(tr("Set Binding"));
-		setModal(true);
-		setMinimumWidth(360);
-
-		auto* layout = new QVBoxLayout(this);
-		m_label      = new QLabel(
-		    tr("Press a key or mouse button.\nSpace and F1 are reserved; Esc cancels."), this);
-		m_label->setAlignment(Qt::AlignCenter);
-		layout->addWidget(m_label);
-	}
-
-	[[nodiscard]] const QString& Binding() const { return m_binding; }
-
-protected:
-	void keyPressEvent(QKeyEvent* event) override {
-		if (event->isAutoRepeat()) {
-			return;
-		}
-		if (event->key() == Qt::Key_Escape) {
-			reject();
-			return;
-		}
-		if (event->key() == Qt::Key_Space || event->key() == Qt::Key_F1) {
-			m_label->setText(tr("That key is reserved by the emulator."));
-			return;
-		}
-
-		m_binding = KeyName(*event);
-		if (!m_binding.isEmpty()) {
-			accept();
-		} else {
-			m_label->setText(tr("That key is not supported."));
-		}
-	}
-
-	void mousePressEvent(QMouseEvent* event) override {
-		switch (event->button()) {
-			case Qt::LeftButton: m_binding = QStringLiteral("Mouse:Left"); break;
-			case Qt::RightButton: m_binding = QStringLiteral("Mouse:Right"); break;
-			case Qt::MiddleButton: m_binding = QStringLiteral("Mouse:Middle"); break;
-			case Qt::BackButton: m_binding = QStringLiteral("Mouse:X1"); break;
-			case Qt::ForwardButton: m_binding = QStringLiteral("Mouse:X2"); break;
-			default: return;
-		}
-		accept();
-	}
-
-private:
-	QLabel* m_label = nullptr;
-	QString m_binding;
-};
-
-QHash<QString, QString> ParseMapping(const QStringList& mapping) {
-	QHash<QString, QString> result;
-	for (const auto& entry: mapping) {
-		const auto separator = entry.indexOf(QLatin1Char('='));
-		if (separator > 0 && separator + 1 < entry.size()) {
-			const auto binding = entry.mid(separator + 1);
-			for (auto item = result.begin(); item != result.end();) {
-				if (item.value().compare(binding, Qt::CaseInsensitive) == 0) {
-					item = result.erase(item);
-				} else {
-					++item;
-				}
-			}
-			result.insert(entry.left(separator), binding);
-		}
-	}
-	return result;
-}
-
-} // namespace
-
-InputMappingDialog::InputMappingDialog(const QStringList& mapping, QWidget* parent)
-    : QDialog(parent), m_customized(!mapping.isEmpty()) {
-	setWindowTitle(tr("Input Mapping"));
-	resize(440, 520);
-
-	auto* layout = new QVBoxLayout(this);
-	layout->addWidget(new QLabel(tr("Map keyboard or mouse input to DualSense buttons.\n"
-	                                "Defaults: left stick W/A/S/D, right stick T/F/G/H."),
-	                             this));
-
-	m_bindings = new QTreeWidget(this);
-	m_bindings->setColumnCount(2);
-	m_bindings->setHeaderLabels({tr("DualSense button"), tr("Host input")});
-	m_bindings->setRootIsDecorated(false);
-	m_bindings->setSelectionMode(QAbstractItemView::SingleSelection);
-	m_bindings->header()->setSectionResizeMode(0, QHeaderView::Stretch);
-	m_bindings->header()->setSectionResizeMode(1, QHeaderView::Stretch);
-	layout->addWidget(m_bindings);
-
-	const auto parsed = ParseMapping(mapping);
-	for (const auto& button: PAD_BUTTONS) {
-		auto* item = new QTreeWidgetItem(m_bindings);
-		item->setText(0, tr(button.label));
-		item->setData(0, Qt::UserRole, QString::fromLatin1(button.id));
-		SetBinding(item, m_customized ? parsed.value(QString::fromLatin1(button.id))
-		                              : QString::fromLatin1(button.default_binding));
-	}
-	m_bindings->setCurrentItem(m_bindings->topLevelItem(0));
-
-	auto* controls  = new QHBoxLayout;
-	m_change_button = new QPushButton(tr("Change..."), this);
-	m_clear_button  = new QPushButton(tr("Clear"), this);
-	auto* defaults  = new QPushButton(tr("Defaults"), this);
-	controls->addWidget(m_change_button);
-	controls->addWidget(m_clear_button);
-	controls->addWidget(defaults);
-	controls->addStretch();
-	layout->addLayout(controls);
-
-	auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
-	layout->addWidget(buttons);
-
-	connect(m_bindings, &QTreeWidget::itemDoubleClicked, this,
-	        [this](QTreeWidgetItem*, int) { ChangeBinding(); });
-	connect(m_bindings, &QTreeWidget::itemSelectionChanged, this, [this]() { UpdateButtons(); });
-	connect(m_change_button, &QPushButton::clicked, this, [this]() { ChangeBinding(); });
-	connect(m_clear_button, &QPushButton::clicked, this, [this]() { ClearBinding(); });
-	connect(defaults, &QPushButton::clicked, this, [this]() { RestoreDefaults(); });
-	connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
-	connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
-	UpdateButtons();
-}
-
-QStringList InputMappingDialog::Mapping() const {
-	QStringList result;
-	if (!m_customized) {
-		return result;
-	}
-	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
-		const auto* item    = m_bindings->topLevelItem(index);
-		const auto  binding = item->data(BINDING_COLUMN, Qt::UserRole).toString();
-		if (!binding.isEmpty()) {
-			result.append(item->data(0, Qt::UserRole).toString() + QLatin1Char('=') + binding);
-		}
-	}
-	return result;
-}
-
-void InputMappingDialog::ChangeBinding() {
-	auto* item = m_bindings->currentItem();
-	if (item == nullptr) {
-		return;
-	}
-
-	InputCaptureDialog dialog(this);
-	if (dialog.exec() != QDialog::Accepted) {
-		return;
-	}
-
-	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
-		auto* other = m_bindings->topLevelItem(index);
-		if (other != item && other->data(BINDING_COLUMN, Qt::UserRole)
-		                             .toString()
-		                             .compare(dialog.Binding(), Qt::CaseInsensitive) == 0) {
-			SetBinding(other, {});
-		}
-	}
-	SetBinding(item, dialog.Binding());
-	m_customized = true;
-}
-
-void InputMappingDialog::ClearBinding() {
-	SetBinding(m_bindings->currentItem(), {});
-	m_customized = true;
-}
-
-void InputMappingDialog::RestoreDefaults() {
-	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
-		SetBinding(m_bindings->topLevelItem(index),
-		           QString::fromLatin1(PAD_BUTTONS[index].default_binding));
-	}
-	m_customized = false;
-}
-
-void InputMappingDialog::SetBinding(QTreeWidgetItem* item, const QString& binding) {
-	if (item == nullptr) {
-		return;
-	}
-	item->setData(BINDING_COLUMN, Qt::UserRole, binding);
-	item->setText(BINDING_COLUMN, binding.isEmpty() ? tr("None") : binding);
-	UpdateButtons();
-}
-
-void InputMappingDialog::UpdateButtons() {
-	if (m_change_button == nullptr) {
-		return;
-	}
-	const auto* item = m_bindings->currentItem();
-	m_change_button->setEnabled(item != nullptr);
-	m_clear_button->setEnabled(item != nullptr &&
-	                           !item->data(BINDING_COLUMN, Qt::UserRole).toString().isEmpty());
-}

src/launcher/src/mainDialog.cpp

@@ -204,11 +204,7 @@ static QStringList CreateEmulatorArgs(const Configuration& info) {
 
 	args << "--screen-width" << r.at(0);
 	args << "--screen-height" << r.at(1);
-	if (info.fullscreen_enabled) {
-		args << "--fullscreen";
-	}
 	args << "--vblank-frequency" << QString::number(info.vblank_frequency);
-	args << "--console-language" << QString::number(info.console_language);
 	args << "--vulkan-validation" << BoolArg(info.vulkan_validation_enabled);
 	args << "--shader-validation" << BoolArg(info.shader_validation_enabled);
 	args << "--shader-optimization-type" << EnumToText(info.shader_optimization_type);
@@ -220,9 +216,6 @@ static QStringList CreateEmulatorArgs(const Configuration& info) {
 	args << "--printf-output-file" << info.printf_output_file;
 	args << "--profiler-direction" << EnumToText(info.profiler_direction);
 	args << "--spirv-debug-printf" << "false";
-	for (const auto& binding: info.host_input_mapping) {
-		args << "--keymap" << binding;
-	}
 	if (info.renderdoc_enabled) {
 		args << "--rd";
 	}
@@ -441,10 +434,7 @@ void MainDialogPrivate::Run() {
 
 	m_running_item->SetRunning(true);
 
-	Configuration info;
-	info.CopyFrom(m_running_item->GetInfo());
-	info.host_input_mapping = m_ui->widget->GetHostInputMapping();
-	m_main_dialog->RunInterpreter(&m_process, info);
+	m_main_dialog->RunInterpreter(&m_process, m_running_item->GetInfo());
 
 	Update();
 }

src/libs/controller.cpp

@@ -85,6 +85,8 @@ private:
 
 static GameController* g_controller = nullptr;
 
+static constexpr int KEYBOARD_CONTROLLER_ID = -1000;
+
 static uint8_t pad_connected_count_to_u8(int connected_count) {
 	return static_cast<uint8_t>(connected_count > 255 ? 255 : connected_count);
 }
@@ -115,7 +117,7 @@ KYTY_SUBSYSTEM_INIT(Controller) {
 	EXIT_IF(g_controller != nullptr);
 
 	g_controller = new GameController;
-	g_controller->Connect(HOST_INPUT_CONTROLLER_ID);
+	g_controller->Connect(KEYBOARD_CONTROLLER_ID);
 }
 
 KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Controller) {}
@@ -153,7 +155,7 @@ void GameController::CheckActive() {
 	if (!m_connected_ids.empty()) {
 		new_active_id = m_connected_ids[0];
 		for (const auto id: m_connected_ids) {
-			if (id != HOST_INPUT_CONTROLLER_ID) {
+			if (id != KEYBOARD_CONTROLLER_ID) {
 				new_active_id = id;
 				break;
 			}

src/libs/controller.h

@@ -9,8 +9,6 @@ namespace Libs::Controller {
 
 KYTY_SUBSYSTEM_DEFINE(Controller);
 
-constexpr int HOST_INPUT_CONTROLLER_ID = -1000;
-
 constexpr uint32_t PAD_BUTTON_L3        = 0x00000002;
 constexpr uint32_t PAD_BUTTON_R3        = 0x00000004;
 constexpr uint32_t PAD_BUTTON_OPTIONS   = 0x00000008;

src/libs/libKernel.cpp

@@ -2021,12 +2021,6 @@ int64_t KYTY_SYSV_ABI fstat(int d, LibKernel::FileSystem::FileStat* sb) {
 	return POSIX_N_CALL(LibKernel::FileSystem::KernelFstat(d, sb));
 }
 
-int KYTY_SYSV_ABI ftruncate(int d, int64_t length) {
-	PRINT_NAME();
-
-	return POSIX_CALL(LibKernel::FileSystem::KernelFtruncate(d, length));
-}
-
 int KYTY_SYSV_ABI socket(int family, int type, int protocol) {
 	PRINT_NAME();
 	return Network::Net::Socket(family, type, protocol);
@@ -2165,7 +2159,6 @@ LIB_DEFINE(InitLibKernel_1_Posix) {
 	LIB_FUNC("yS8U2TGCe1A", nanosleep);
 	LIB_FUNC("E6ao34wPw+U", stat);
 	LIB_FUNC("JGMio+21L4c", mkdir);
-	LIB_FUNC("ih4CD9-gghM", Posix::ftruncate);
 	LIB_FUNC("pDuPEf3m4fI", Posix::sem_init);
 	LIB_FUNC("cDW233RAwWo", Posix::sem_destroy);
 	LIB_FUNC("YCV5dGGBcCo", Posix::sem_wait);

src/libs/libSystemService.cpp

@@ -1,7 +1,6 @@
 #include "common/abi.h"
 #include "common/assert.h"
 #include "common/common.h"
-#include "common/emulatorConfig.h"
 #include "common/logging/log.h"
 #include "common/stringUtils.h"
 #include "libs/errno.h"
@@ -26,6 +25,37 @@ namespace SystemService {
 [[maybe_unused]] constexpr int PARAM_ID_SCREEN_READER       = 208;
 [[maybe_unused]] constexpr int PARAM_ID_ENTER_BUTTON_ASSIGN = 1000;
 
+[[maybe_unused]] constexpr int PARAM_LANG_JAPANESE      = 0;
+[[maybe_unused]] constexpr int PARAM_LANG_ENGLISH_US    = 1;
+[[maybe_unused]] constexpr int PARAM_LANG_FRENCH        = 2;
+[[maybe_unused]] constexpr int PARAM_LANG_SPANISH       = 3;
+[[maybe_unused]] constexpr int PARAM_LANG_GERMAN        = 4;
+[[maybe_unused]] constexpr int PARAM_LANG_ITALIAN       = 5;
+[[maybe_unused]] constexpr int PARAM_LANG_DUTCH         = 6;
+[[maybe_unused]] constexpr int PARAM_LANG_PORTUGUESE_PT = 7;
+[[maybe_unused]] constexpr int PARAM_LANG_RUSSIAN       = 8;
+[[maybe_unused]] constexpr int PARAM_LANG_KOREAN        = 9;
+[[maybe_unused]] constexpr int PARAM_LANG_CHINESE_T     = 10;
+[[maybe_unused]] constexpr int PARAM_LANG_CHINESE_S     = 11;
+[[maybe_unused]] constexpr int PARAM_LANG_FINNISH       = 12;
+[[maybe_unused]] constexpr int PARAM_LANG_SWEDISH       = 13;
+[[maybe_unused]] constexpr int PARAM_LANG_DANISH        = 14;
+[[maybe_unused]] constexpr int PARAM_LANG_NORWEGIAN     = 15;
+[[maybe_unused]] constexpr int PARAM_LANG_POLISH        = 16;
+[[maybe_unused]] constexpr int PARAM_LANG_PORTUGUESE_BR = 17;
+[[maybe_unused]] constexpr int PARAM_LANG_ENGLISH_GB    = 18;
+[[maybe_unused]] constexpr int PARAM_LANG_TURKISH       = 19;
+[[maybe_unused]] constexpr int PARAM_LANG_SPANISH_LA    = 20;
+[[maybe_unused]] constexpr int PARAM_LANG_ARABIC        = 21;
+[[maybe_unused]] constexpr int PARAM_LANG_FRENCH_CA     = 22;
+[[maybe_unused]] constexpr int PARAM_LANG_CZECH         = 23;
+[[maybe_unused]] constexpr int PARAM_LANG_HUNGARIAN     = 24;
+[[maybe_unused]] constexpr int PARAM_LANG_GREEK         = 25;
+[[maybe_unused]] constexpr int PARAM_LANG_ROMANIAN      = 26;
+[[maybe_unused]] constexpr int PARAM_LANG_THAI          = 27;
+[[maybe_unused]] constexpr int PARAM_LANG_VIETNAMESE    = 28;
+[[maybe_unused]] constexpr int PARAM_LANG_INDONESIAN    = 29;
+
 [[maybe_unused]] constexpr int PARAM_DATE_FORMAT_YYYYMMDD = 0;
 [[maybe_unused]] constexpr int PARAM_DATE_FORMAT_DDMMYYYY = 1;
 [[maybe_unused]] constexpr int PARAM_DATE_FORMAT_MMDDYYYY = 2;
@@ -91,7 +121,7 @@ static int KYTY_SYSV_ABI SystemServiceParamGetInt(int param_id, int* value) {
 	int v = 0;
 
 	switch (param_id) {
-		case PARAM_ID_LANG: v = static_cast<int>(Config::GetConsoleLanguage()); break;
+		case PARAM_ID_LANG: v = PARAM_LANG_ENGLISH_US; break;
 		case PARAM_ID_DATE_FORMAT: v = PARAM_DATE_FORMAT_DDMMYYYY; break;
 		case PARAM_ID_TIME_FORMAT: v = PARAM_TIME_FORMAT_24HOUR; break;
 		case PARAM_ID_TIME_ZONE: v = +180; break;

src/loader/runtimeLinker.cpp

@@ -360,10 +360,9 @@ static KYTY_SYSV_ABI void RunEntry(uint64_t addr, EntryParams* params, atexit_fu
 	auto* func = reinterpret_cast<entry_func_t>(addr);
 
 	if (stack_top != nullptr) {
-		const auto aligned_stack_top =
+		const auto guest_rsp =
 		    reinterpret_cast<uintptr_t>(stack_top) & ~static_cast<uintptr_t>(0x0f);
-		const auto guest_rsp = aligned_stack_top - 2u * sizeof(uintptr_t);
-		const auto guest_rbp = guest_rsp;
+		const auto guest_rbp = guest_rsp - 4u * sizeof(uint64_t);
 
 		auto* guest_root_frame = reinterpret_cast<uintptr_t*>(guest_rbp);
 		guest_root_frame[0]    = 0;
@@ -508,13 +507,6 @@ struct MainEntryStackTestState {
 static KYTY_SYSV_ABI void TestMainEntryStackCallback(EntryParams* params,
                                                      atexit_func_t /*atexit_func*/) {
 	auto* state = reinterpret_cast<MainEntryStackTestState*>(const_cast<char*>(params->argv[0]));
-	asm volatile("pushq %%r15\n\t"
-	             "pushq %%r14\n\t"
-	             "popq %%r14\n\t"
-	             "popq %%r15\n\t"
-	             :
-	             :
-	             : "memory");
 	asm volatile("movq %%rsp, %0" : "=r"(state->rsp) : : "memory");
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	asm volatile("movq %%gs:0x08, %0\n\t"
@@ -537,8 +529,6 @@ bool TestMainEntryUsesGuestStack() {
 	MainEntryStackTestState state {};
 	EntryParams             params {};
 	params.argv[0] = reinterpret_cast<const char*>(&state);
-	std::memset(reinterpret_cast<void*>(stack_base), 0xcd, stack_size);
-	auto* root_frame = reinterpret_cast<const uintptr_t*>(stack_base + stack_size) - 2;
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	uintptr_t original_teb_stack_base  = 0;
@@ -568,10 +558,9 @@ bool TestMainEntryUsesGuestStack() {
 	constexpr bool teb_ok = true;
 #endif
 
-	const bool rsp_ok  = state.rsp >= stack_base && state.rsp < stack_base + stack_size;
-	const bool root_ok = root_frame[0] == 0 && root_frame[1] == 0;
-	const bool freed   = Libs::LibKernel::Memory::FreeGuestMemory(stack_base, stack_size);
-	return state.called && rsp_ok && root_ok && teb_ok && freed;
+	const bool rsp_ok = state.rsp >= stack_base && state.rsp < stack_base + stack_size;
+	const bool freed  = Libs::LibKernel::Memory::FreeGuestMemory(stack_base, stack_size);
+	return state.called && rsp_ok && teb_ok && freed;
 }
 
 bool TestModuleRelocationUsesWritableHostMapping() {

src/main.cpp

@@ -10,7 +10,6 @@
 #include "emulator.h"
 #include "kytyGitVersion.h"
 
-#include <charconv>
 #include <cstdio>
 #include <fmt/format.h>
 
@@ -47,9 +46,7 @@ static void PrintUsage() {
 	    "  --game-patch <json>                  Validated patch plan to apply before entry.\n");
 	::printf("  --screen-width <num>                 Window width. Default: 1280.\n");
 	::printf("  --screen-height <num>                Window height. Default: 720.\n");
-	::printf("  --fullscreen                         Run in borderless desktop fullscreen.\n");
 	::printf("  --vblank-frequency <num>             Virtual vblank frequency. Default: 60.\n");
-	::printf("  --console-language <0-29>            Console language. Default: 1 (English US).\n");
 	::printf("  --vulkan-validation <true|false>     Enable Vulkan validation.\n");
 	::printf("  --shader-validation <true|false>     Enable shader validation.\n");
 	::printf("  --shader-optimization-type <value>   None, Size, or Performance.\n");
@@ -64,7 +61,6 @@ static void PrintUsage() {
 	::printf("  --spirv-debug-printf <true|false>    Enable SPIR-V debug printf.\n");
 	::printf(
 	    "  --readback-linear-images <true|false> Read back writable linear images on submit.\n");
-	::printf("  --keymap <Pad=Key>                   DualSense mapping; may be repeated.\n");
 	::printf("  --rd                                 Enable RenderDoc capture.\n");
 }
 
@@ -105,17 +101,6 @@ static bool ParseEnum(const std::string& value, E& out) {
 	return true;
 }
 
-static bool ParseConsoleLanguage(const std::string& value, uint32_t& out) {
-	uint32_t language = 0;
-	auto [end, error] = std::from_chars(value.data(), value.data() + value.size(), language);
-	if (error != std::errc {} || end != value.data() + value.size() ||
-	    language > Config::MAX_CONSOLE_LANGUAGE) {
-		return false;
-	}
-	out = language;
-	return true;
-}
-
 static bool ParseArgs(int argc, char* argv[], RunOptions& options, bool& show_help) {
 	show_help = false;
 
@@ -133,11 +118,6 @@ static bool ParseArgs(int argc, char* argv[], RunOptions& options, bool& show_he
 			continue;
 		}
 
-		if (arg == "--fullscreen") {
-			options.config.fullscreen_enabled = true;
-			continue;
-		}
-
 		if (!Common::StartsWith(arg, "--")) {
 			::printf("game input must be provided with --game\n");
 			return false;
@@ -187,11 +167,6 @@ static bool ParseArgs(int argc, char* argv[], RunOptions& options, bool& show_he
 			const int32_t vblank_frequency = Common::ToInt32(value);
 			options.config.vblank_frequency =
 			    static_cast<uint32_t>(vblank_frequency < 0 ? 0 : vblank_frequency);
-		} else if (arg == "--console-language") {
-			if (!ParseConsoleLanguage(value, options.config.console_language)) {
-				::printf("invalid console language: %s\n", value.c_str());
-				return false;
-			}
 		} else if (arg == "--vulkan-validation") {
 			if (!ParseBool(value, options.config.vulkan_validation_enabled)) {
 				::printf("invalid boolean for %s: %s\n", arg.c_str(), value.c_str());
@@ -248,13 +223,6 @@ static bool ParseArgs(int argc, char* argv[], RunOptions& options, bool& show_he
 				::printf("invalid boolean for %s: %s\n", arg.c_str(), value.c_str());
 				return false;
 			}
-		} else if (arg == "--keymap") {
-			const auto split = value.find('=');
-			if (split == std::string::npos || split == 0 || split + 1 == value.size()) {
-				::printf("invalid keymap: %s\n", value.c_str());
-				return false;
-			}
-			options.config.keymap.push_back(value);
 		} else {
 			::printf("unknown option: %s\n", arg.c_str());
 			return false;

tests/ImagePageTableTests.cpp

@@ -3,15 +3,13 @@
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
-#include <utility>
 #include <vector>
 
 namespace {
 
 using Owners     = std::vector<uint32_t>;
 using Table      = Libs::Graphics::MultiLevelPageTable<Owners>;
-using PageOwners = Libs::Graphics::InlinePageOwnerList<uint32_t, 16>;
-using OwnerTable = Libs::Graphics::MultiLevelPageTable<PageOwners, 20, 40, 10>;
+using OwnerIndex = Libs::Graphics::MultiRangePageOwnerIndex<uint32_t>;
 
 void Check(bool value, const char* text) {
 	if (!value) {
@@ -79,93 +77,76 @@ void TestAddressSpaceBoundaries() {
 	      "final page supports allocating and nonallocating access");
 }
 
-void TestInlineOwnerStorageAndOverflow() {
-	PageOwners owners;
-	for (uint32_t owner = 1; owner <= 18; ++owner) {
-		owners.push_back(owner);
-	}
-	Check(owners.size() == 18 && owners.front() == 1,
-	      "inline owner storage grows past its 16-owner capacity");
-	uint32_t expected = 1;
-	for (const uint32_t owner: owners) {
-		Check(owner == expected++, "overflow preserves registration order");
-	}
-	Check(owners.Erase(5) && owners.size() == 17 && !owners.Contains(5),
-	      "overflow erase removes only the requested owner");
-	Check(owners.Erase(18) && owners.size() == 16,
-	      "overflow storage shrinks back to inline capacity");
-	const std::vector<uint32_t> remaining {1, 2, 3, 4, 6, 7, 8, 9,
-	                                       10, 11, 12, 13, 14, 15, 16, 17};
-	size_t                      remaining_index = 0;
-	for (const uint32_t owner: owners) {
-		Check(owner == remaining[remaining_index++],
-		      "overflow-to-inline shrink preserves every owner");
-	}
-	Check(!owners.Erase(99), "missing inline owner is reported without mutation");
+void TestMultiRangeRegistrationDeduplicatesPages() {
+	OwnerIndex index;
+	// Depth and stencil-like planes overlap tracking pages and share one 1 MiB bucket.
+	Check(index.Register(7, {{0x101000, 0x2800}, {0x102000, 0x3000}}),
+	      "multi-range owner registers");
+	Check(index.CoarseMembershipCount(1) == 1,
+	      "one owner is inserted once in a shared 1 MiB bucket");
+	Check(index.TrackingMembershipCount(0x102) == 1,
+	      "overlapping planes insert one 4 KiB membership");
+	Check(!index.Register(7, {{0x101000, 0x1000}}), "duplicate owner registration hard-fails");
 
-	PageOwners moved = std::move(owners);
-	Check(owners.empty() && moved.size() == remaining.size() && moved.front() == 1,
-	      "moving a full inline owner list leaves the source empty");
-	PageOwners partial;
-	partial.push_back(41);
-	partial.push_back(42);
-	PageOwners partial_moved = std::move(partial);
-	Check(partial.empty() && partial_moved.size() == 2 && partial_moved[1] == 42,
-	      "moving a partially populated list copies only live owners");
-	PageOwners assigned;
-	assigned.push_back(99);
-	assigned = std::move(partial_moved);
-	Check(partial_moved.empty() && assigned.size() == 2 && assigned.front() == 41,
-	      "move assignment replaces an inline list without reading inactive slots");
-	PageOwners empty;
-	PageOwners empty_moved = std::move(empty);
-	Check(empty.empty() && empty_moved.empty(), "moving an empty owner list is safe");
+	const auto owners = index.Query(0x100000, 0x10000);
+	Check(owners.size() == 1 && owners.front() == 7, "multi-page query returns an owner once");
 }
 
-void TestOneMiBRegistrationGranularity() {
-	static_assert(OwnerTable::kPageBits == 20);
-	OwnerTable            table;
-	OwnerTable::PageRange pages {};
-	constexpr uint64_t    range_size = 64ull * 1024 * 1024;
-	Check(OwnerTable::TryGetPageRange(0, range_size, pages), "large owner range is valid");
-	Check(pages.first == 0 && pages.last_exclusive == 64,
-	      "64 MiB registration touches exactly 64 one-MiB entries");
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		table[page].push_back(7);
-	}
-	Check(table.AllocatedBucketCount() == 1,
-	      "large registration uses one sparse second-level bucket");
-	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-		auto* owners = table.Find(page);
-		Check(owners != nullptr && owners->size() == 1 && owners->front() == 7,
-		      "each touched one-MiB entry retains the owner once");
-		Check(owners->Erase(7), "large owner unregisters by coarse page");
-	}
+void TestSharedPageUnregisterLifecycle() {
+	OwnerIndex                               index;
+	const std::vector<OwnerIndex::ByteRange> ranges {{0x202000, 0x2000}};
+	Check(index.Register(11, ranges) && index.Register(22, ranges),
+	      "two owners register on identical pages");
+	Check(index.CoarseMembershipCount(2) == 2 && index.TrackingMembershipCount(0x202) == 2,
+	      "coarse and tracking pages retain both owners");
+
+	std::vector<OwnerIndex::ByteRange> releases;
+	Check(index.Unregister(11, releases), "first owner unregisters");
+	Check(releases.empty(), "shared tracking pages are not released with one owner remaining");
+	Check(index.Query(0x202000, 1).size() == 1 && index.Query(0x202000, 1).front() == 22,
+	      "unregistering one owner preserves the other");
+	Check(!index.Unregister(11, releases), "missing membership hard-fails without mutation");
+
+	Check(index.Unregister(22, releases), "final owner unregisters");
+	Check(releases.size() == 1 && releases.front().address == 0x202000 &&
+	          releases.front().size == 0x2000,
+	      "adjacent final-owner tracking pages return one contiguous release");
 }
 
-void TestSharedCoarsePageLifecycle() {
-	OwnerTable table;
-	auto&      owners = table[2];
-	owners.push_back(11);
-	owners.push_back(22);
-	Check(owners.size() == 2, "two images share one coarse page");
-	Check(owners.Erase(11) && owners.size() == 1 && owners.front() == 22,
-	      "unregistering one image preserves its coarse-page neighbor");
-	Check(!owners.Erase(11), "double unregister is rejected without mutation");
-	Check(owners.Erase(22) && owners.empty(), "final coarse-page owner unregisters");
+void TestStrictByteFilteringAndPredicate() {
+	OwnerIndex index;
+	Check(index.Register(31, {{0x300100, 0x100}}), "first byte-disjoint owner registers");
+	Check(index.Register(32, {{0x300800, 0x100}}), "second byte-disjoint owner registers");
+	Check(index.Register(33, {{0x30f000, 0x100}}), "coarse-only owner registers");
+	Check(index.TrackingMembershipCount(0x300) == 2,
+	      "byte-disjoint owners share one tracking page");
+	Check(index.CoarseMembershipCount(3) == 3,
+	      "all owners share one coarse candidate bucket");
+	Check(index.Query(0x300400, 0x40).empty(), "page hit without byte overlap is filtered out");
+	const auto page_candidates = index.QueryCandidates(0x300400, 0x40);
+	Check(page_candidates.size() == 2,
+	      "fault candidate query retains touched-page owners and rejects coarse-only owners");
+	const auto first = index.Query(0x300180, 0x10);
+	Check(first.size() == 1 && first.front() == 31,
+	      "strict byte overlap selects only the matching owner");
+	const auto predicate_filtered =
+	    index.Query(0x300000, 0x1000, [](uint32_t owner) { return owner == 32; });
+	Check(predicate_filtered.size() == 1 && predicate_filtered.front() == 32,
+	      "supplied predicate filters query owners");
 }
 
-void TestOneMiBBoundaries() {
-	OwnerTable::PageRange range {};
-	Check(OwnerTable::TryGetPageRange(0x0fffff, 2, range),
-	      "range crossing a one-MiB boundary is valid");
-	Check(range.first == 0 && range.last_exclusive == 2,
-	      "cross-boundary registration touches both coarse pages");
-	Check(OwnerTable::TryGetPageRange(OwnerTable::kAddressSpaceSize - 1, 1, range),
-	      "final guest byte maps to a coarse owner page");
-	Check(range.first == OwnerTable::kPageCount - 1 &&
-	          range.last_exclusive == OwnerTable::kPageCount,
-	      "final guest byte uses the final one-MiB page");
+void TestOwnerIndexAddressSpaceBoundary() {
+	OwnerIndex         index;
+	constexpr uint64_t last_byte = OwnerIndex::CoarseTable::kAddressSpaceSize - 1;
+	Check(index.Register(41, {{last_byte, 1}}), "final guest byte registers");
+	const auto exact = index.Query(last_byte, 1);
+	Check(exact.size() == 1 && exact.front() == 41,
+	      "strict query finds an exact overlap at the final guest byte");
+	Check(index.Query(last_byte - 1, 1).empty(),
+	      "strict query preserves half-open overlap boundaries");
+	const auto page_candidates = index.QueryCandidates(last_byte - 1, 1);
+	Check(page_candidates.size() == 1 && page_candidates.front() == 41,
+	      "page candidate query retains a byte-disjoint owner on the final tracking page");
 }
 
 } // namespace
@@ -175,10 +156,10 @@ int main() {
 	TestCrossBucketRange();
 	TestQueriesDoNotAllocate();
 	TestAddressSpaceBoundaries();
-	TestInlineOwnerStorageAndOverflow();
-	TestOneMiBRegistrationGranularity();
-	TestSharedCoarsePageLifecycle();
-	TestOneMiBBoundaries();
+	TestMultiRangeRegistrationDeduplicatesPages();
+	TestSharedPageUnregisterLifecycle();
+	TestStrictByteFilteringAndPredicate();
+	TestOwnerIndexAddressSpaceBoundary();
 	std::printf("ImagePageTableTests: all cases passed\n");
 	return 0;
 }

tests/MemoryTrackerTests.cpp

@@ -6,9 +6,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <semaphore>
 #include <string>
-#include <thread>
 #include <vector>
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
@@ -267,7 +265,6 @@ void TestRangeInvalidation() {
     flushes++;
     tracker.ForEachDownloadRange<true>(address + 16, size - 32,
                                        [](uint64_t, uint64_t) noexcept {});
-    tracker.MarkRegionAsCpuModified(address + 16, size - 32);
   });
   Check(flushes == 1 && !tracker.IsRegionGpuModified(address, size) &&
             tracker.IsRegionCpuModified(address, size) && IsWritable(memory) &&
@@ -280,53 +277,6 @@ void TestRangeInvalidation() {
   Release(page_manager, memory, size);
 }
 
-void TestGpuReacquisitionAfterInvalidation() {
-  TrackerHarness harness;
-  auto &tracker = harness.tracker;
-  auto &page_manager = harness.page_manager;
-  const auto page_size = page_manager.GetPageSize();
-  auto *memory = Allocate(page_manager, 1);
-  const auto address = reinterpret_cast<uint64_t>(memory);
-
-  tracker.ForEachUploadRange(
-      address, page_size, true, [](uint64_t, uint64_t) noexcept {},
-      []() noexcept {});
-  Check(tracker.IsRegionGpuModified(address, page_size) &&
-            !tracker.IsRegionCpuModified(address, page_size),
-        "reacquisition setup did not establish GPU ownership");
-
-  uint32_t flushes = 0;
-  uint32_t uploads = 0;
-  std::binary_semaphore reacquire{0};
-  std::binary_semaphore reacquired{0};
-  std::jthread publisher([&] {
-    reacquire.acquire();
-    tracker.ForEachUploadRange(
-        address + 16, 32, true,
-        [&](uint64_t, uint64_t) noexcept { uploads++; }, []() noexcept {});
-    reacquired.release();
-  });
-  tracker.InvalidateRegion(address + 16, 32, [&] {
-    flushes++;
-    tracker.ForEachDownloadRange<true>(address + 16, 32,
-                                       [](uint64_t, uint64_t) noexcept {});
-    tracker.MarkRegionAsCpuModified(address + 16, 32);
-    reacquire.release();
-    reacquired.acquire();
-  });
-  publisher.join();
-  Check(flushes == 1 && uploads == 1 &&
-            tracker.IsRegionGpuModified(address, page_size) &&
-            !tracker.IsRegionCpuModified(address, page_size) &&
-            !IsWritable(memory),
-        "invalidation rejected a new generation of GPU ownership");
-
-  tracker.UnmarkRegionAsGpuModified(address, page_size);
-  tracker.MarkRegionAsCpuModified(address, page_size);
-  tracker.UntrackMemory(address, page_size);
-  Release(page_manager, memory, page_size);
-}
-
 void TestGpuDirtyBits() {
   TrackerHarness harness;
   auto &tracker = harness.tracker;
@@ -685,7 +635,6 @@ int main(int argc, char **argv) {
   TestQueriesDoNotRequireMappedOwnership();
   TestCpuDirtyUpload();
   TestRangeInvalidation();
-  TestGpuReacquisitionAfterInvalidation();
   TestGpuDirtyBits();
   TestExactDirtyIntervalsSharingTrackerPage();
   TestGpuDownloadProtectionMirrors();

tests/ResourceMutexTests.cpp

@@ -35,50 +35,171 @@ void YieldMany() {
 	}
 }
 
-void TestOwnership() {
-	ResourceMutex mutex;
-	Check(!mutex.IsOwnedByCurrentThread(), "fresh mutex reported an owner");
+void TestFaultBlocksPublisher() {
+	ResourceMutex    mutex;
+	std::atomic_bool publisher_started {false};
+	std::atomic_bool publisher_entered {false};
+	std::thread      publisher;
 	{
-		std::lock_guard lock(mutex);
-		Check(mutex.IsOwnedByCurrentThread(), "owner tracking was not installed");
+		ResourceMutex::FaultScope fault(mutex);
+		publisher = std::thread([&] {
+			publisher_started.store(true, std::memory_order_release);
+			std::lock_guard lock(mutex);
+			publisher_entered.store(true, std::memory_order_release);
+		});
+		while (!publisher_started.load(std::memory_order_acquire)) {
+			std::this_thread::yield();
+		}
+		YieldMany();
+		Check(!publisher_entered.load(std::memory_order_acquire),
+		      "publisher entered during active fault transaction");
 	}
-	Check(!mutex.IsOwnedByCurrentThread(), "owner tracking survived unlock");
+	publisher.join();
+	Check(publisher_entered.load(std::memory_order_acquire),
+	      "publisher did not resume after fault transaction");
 }
 
-void TestSerializesTransactions() {
+void TestFaultDrainsExistingOwner() {
 	ResourceMutex    mutex;
 	std::unique_lock owner(mutex);
-	std::atomic_bool contender_started {false};
-	std::atomic_bool contender_entered {false};
-	std::thread      contender([&] {
-		contender_started.store(true, std::memory_order_release);
-		std::lock_guard lock(mutex);
-		contender_entered.store(true, std::memory_order_release);
+	std::atomic_bool fault_started {false};
+	std::atomic_bool fault_entered {false};
+	std::atomic_bool release_fault {false};
+	std::atomic_bool publisher_started {false};
+	std::atomic_bool publisher_entered {false};
+	std::thread      fault([&] {
+		fault_started.store(true, std::memory_order_release);
+		ResourceMutex::FaultScope scope(mutex);
+		fault_entered.store(true, std::memory_order_release);
+		while (!release_fault.load(std::memory_order_acquire)) {
+			std::this_thread::yield();
+		}
 	});
-	while (!contender_started.load(std::memory_order_acquire)) {
+	while (!fault_started.load(std::memory_order_acquire)) {
 		std::this_thread::yield();
 	}
 	YieldMany();
-	Check(!contender_entered.load(std::memory_order_acquire),
-	      "contender entered an active resource transaction");
+	Check(!fault_entered.load(std::memory_order_acquire),
+	      "fault transaction did not wait for existing owner");
 	owner.unlock();
-	contender.join();
-	Check(contender_entered.load(std::memory_order_acquire),
-	      "contender did not resume after resource transaction");
+	while (!fault_entered.load(std::memory_order_acquire)) {
+		std::this_thread::yield();
+	}
+	std::thread publisher([&] {
+		publisher_started.store(true, std::memory_order_release);
+		std::lock_guard lock(mutex);
+		publisher_entered.store(true, std::memory_order_release);
+	});
+	while (!publisher_started.load(std::memory_order_acquire)) {
+		std::this_thread::yield();
+	}
+	YieldMany();
+	Check(!publisher_entered.load(std::memory_order_acquire),
+	      "publisher entered before drained fault completed");
+	release_fault.store(true, std::memory_order_release);
+	fault.join();
+	publisher.join();
+	Check(publisher_entered.load(std::memory_order_acquire),
+	      "publisher did not resume after drained fault");
+}
+
+void TestFaultScopesSerialize() {
+	ResourceMutex    mutex;
+	std::atomic_bool first_entered {false};
+	std::atomic_bool second_started {false};
+	std::atomic_bool second_entered {false};
+	std::atomic_bool release_first {false};
+	std::atomic_bool release_second {false};
+	std::atomic_bool publisher_entered {false};
+	std::thread      first([&] {
+		ResourceMutex::FaultScope scope(mutex);
+		first_entered.store(true, std::memory_order_release);
+		while (!release_first.load(std::memory_order_acquire)) {
+			std::this_thread::yield();
+		}
+	});
+	while (!first_entered.load(std::memory_order_acquire)) {
+		std::this_thread::yield();
+	}
+	std::thread second([&] {
+		second_started.store(true, std::memory_order_release);
+		ResourceMutex::FaultScope scope(mutex);
+		second_entered.store(true, std::memory_order_release);
+		while (!release_second.load(std::memory_order_acquire)) {
+			std::this_thread::yield();
+		}
+	});
+	while (!second_started.load(std::memory_order_acquire)) {
+		std::this_thread::yield();
+	}
+	YieldMany();
+	Check(!second_entered.load(std::memory_order_acquire),
+	      "second fault transaction entered before first completed");
+	release_first.store(true, std::memory_order_release);
+	while (!second_entered.load(std::memory_order_acquire)) {
+		std::this_thread::yield();
+	}
+	std::thread publisher([&] {
+		std::lock_guard lock(mutex);
+		publisher_entered.store(true, std::memory_order_release);
+	});
+	YieldMany();
+	Check(!publisher_entered.load(std::memory_order_acquire),
+	      "publisher entered during second fault transaction");
+	release_second.store(true, std::memory_order_release);
+	first.join();
+	second.join();
+	publisher.join();
+	Check(publisher_entered.load(std::memory_order_acquire),
+	      "publisher did not resume after serialized faults");
+}
+
+void TestPreownedFaultKeepsResourceTransaction() {
+	ResourceMutex    mutex;
+	std::atomic_bool publisher_started {false};
+	std::atomic_bool publisher_entered {false};
+	std::thread      publisher;
+	std::unique_lock owner(mutex);
+	{
+		ResourceMutex::FaultScope fault(mutex);
+		publisher = std::thread([&] {
+			publisher_started.store(true, std::memory_order_release);
+			std::lock_guard lock(mutex);
+			publisher_entered.store(true, std::memory_order_release);
+		});
+		while (!publisher_started.load(std::memory_order_acquire)) {
+			std::this_thread::yield();
+		}
+		YieldMany();
+		Check(!publisher_entered.load(std::memory_order_acquire),
+		      "publisher entered during preowned fault transaction");
+	}
+	YieldMany();
+	Check(!publisher_entered.load(std::memory_order_acquire),
+	      "preowned fault released its outer resource transaction");
+	owner.unlock();
+	publisher.join();
+	Check(publisher_entered.load(std::memory_order_acquire),
+	      "publisher did not resume after outer transaction");
 }
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-[[noreturn]] void RunDeathCase() {
+[[noreturn]] void RunDeathCase(const char* name) {
 	ResourceMutex mutex;
-	std::lock_guard first(mutex);
-	std::lock_guard second(mutex);
+	if (std::strcmp(name, "recursive-lock") == 0) {
+		std::lock_guard first(mutex);
+		std::lock_guard second(mutex);
+	} else if (std::strcmp(name, "nested-fault") == 0) {
+		ResourceMutex::FaultScope first(mutex);
+		ResourceMutex::FaultScope second(mutex);
+	}
 	std::_Exit(0x7f);
 }
 
-void CheckDeathCase() {
+void CheckDeathCase(const char* name) {
 	char path[MAX_PATH] {};
 	Check(GetModuleFileNameA(nullptr, path, MAX_PATH) != 0, "GetModuleFileName failed");
-	std::string       command = std::string("\"") + path + "\" --death";
+	std::string       command = std::string("\"") + path + "\" --death " + name;
 	std::vector<char> mutable_command(command.begin(), command.end());
 	mutable_command.push_back('\0');
 	STARTUPINFOA        startup {sizeof(startup)};
@@ -103,17 +224,20 @@ void CheckDeathCase() {
 
 int main(int argc, char** argv) {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	if (argc == 2 && std::strcmp(argv[1], "--death") == 0) {
-		RunDeathCase();
+	if (argc == 3 && std::strcmp(argv[1], "--death") == 0) {
+		RunDeathCase(argv[2]);
 	}
 #else
 	(void)argc;
 	(void)argv;
 #endif
-	TestOwnership();
-	TestSerializesTransactions();
+	TestFaultBlocksPublisher();
+	TestFaultDrainsExistingOwner();
+	TestFaultScopesSerialize();
+	TestPreownedFaultKeepsResourceTransaction();
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
-	CheckDeathCase();
+	CheckDeathCase("recursive-lock");
+	CheckDeathCase("nested-fault");
 #endif
 	std::puts("ResourceMutexTests: all cases passed");
 	return 0;

tests/ShaderRecompilerComputeTests.cpp

@@ -58,7 +58,6 @@
 
 #include <algorithm>
 #include <array>
-#include <atomic>
 #include <bit>
 #include <chrono>
 #include <cinttypes>
@@ -164,10 +163,6 @@ struct TileManagerTestAccess {
 };
 
 struct TextureCacheTestAccess {
-	static_assert(TextureCache::ImagePageTable::kPageBits == 20);
-	static_assert(TextureCache::ImagePageTable::kAddressSpaceBits == 40);
-	static_assert(TextureCache::ImagePageTable::kFirstLevelBits == 10);
-
 	static void ConfigureGarbageCollection(TextureCache& cache, std::span<const ImageId> oldest,
 	                                       uint64_t tick, uint64_t pressure) {
 		cache.m_trigger_gc_memory  = 0;
@@ -202,75 +197,6 @@ struct TextureCacheTestAccess {
 		return owner != nullptr && owner->registered;
 	}
 
-	static std::vector<ImageId> FindImages(TextureCache& cache, uint64_t address, uint64_t size,
-	                                       bool page_overlap) {
-		std::lock_guard      lock(cache.m_lock);
-		const auto           found = cache.FindImagesInRegion(address, size, page_overlap);
-		std::vector<ImageId> result;
-		result.reserve(found.size());
-		for (const auto id: found) {
-			result.push_back(id);
-		}
-		return result;
-	}
-
-	static size_t PageOwnerCount(TextureCache& cache, uint64_t address) {
-		std::lock_guard lock(cache.m_lock);
-		const auto*     owners = cache.m_image_page_table.Find(
-		    static_cast<size_t>(address >> TextureCache::ImagePageTable::kPageBits));
-		return owners == nullptr ? 0 : owners->size();
-	}
-
-	static size_t OwnedPageCount(TextureCache& cache, uint64_t address, uint64_t size, ImageId id) {
-		std::lock_guard                  lock(cache.m_lock);
-		TextureCache::ImagePageTable::PageRange pages {};
-		if (!TextureCache::ImagePageTable::TryGetPageRange(address, size, pages)) {
-			return 0;
-		}
-		size_t count = 0;
-		for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
-			const auto* owners = cache.m_image_page_table.Find(page);
-			count += owners != nullptr && owners->Contains(id) ? 1 : 0;
-		}
-		return count;
-	}
-
-	static void AddPageOwner(TextureCache& cache, uint64_t address, ImageId id) {
-		std::lock_guard lock(cache.m_lock);
-		cache.m_image_page_table[static_cast<size_t>(
-		    address >> TextureCache::ImagePageTable::kPageBits)]
-		    .push_back(id);
-	}
-
-	static bool RemovePageOwner(TextureCache& cache, uint64_t address, ImageId id) {
-		std::lock_guard lock(cache.m_lock);
-		auto*           owners = cache.m_image_page_table.Find(
-		    static_cast<size_t>(address >> TextureCache::ImagePageTable::kPageBits));
-		return owners != nullptr && owners->Erase(id);
-	}
-
-	static void SetQueryEpoch(TextureCache& cache, uint32_t epoch) {
-		std::lock_guard lock(cache.m_lock);
-		cache.m_image_query_epoch = epoch;
-	}
-
-	static uint32_t QueryEpoch(TextureCache& cache) {
-		std::lock_guard lock(cache.m_lock);
-		return cache.m_image_query_epoch;
-	}
-
-	static ImageId InsertImage(TextureCache& cache, const ImageInfo& info) {
-		std::lock_guard transaction(cache.m_resource_mutex);
-		std::lock_guard lock(cache.m_lock);
-		return cache.InsertImage(info);
-	}
-
-	static void DeleteImage(TextureCache& cache, ImageId id) {
-		std::lock_guard transaction(cache.m_resource_mutex);
-		std::lock_guard lock(cache.m_lock);
-		cache.DeleteImage(id);
-	}
-
 	static std::shared_ptr<Image> Owner(const TextureCache& cache, ImageId id) {
 		return cache.ResolveOwner(id);
 	}
@@ -1373,14 +1299,12 @@ public:
 
 	void CheckGpuMappedRangeLifecycle() {
 		EnsureRuntimeContext();
-		auto&            context = Renderer();
-		CommandScheduler scheduler(context, m_runtime_context);
+		CommandScheduler scheduler(Renderer(), m_runtime_context);
 		HW::Context      registers {};
 		HW::UserConfig   user_config {};
 		HW::Shader       shaders {};
 		scheduler.Begin(registers, user_config, shaders);
-		context.InitializeGpu(nullptr);
-		auto&              gpu = context.GetGpu();
+		Gpu                gpu(Renderer());
 		GpuResourceManager resources(m_runtime_context, scheduler);
 		resources.SetGpu(&gpu);
 
@@ -1419,7 +1343,6 @@ public:
 
 		resources.SetGpu(nullptr);
 		scheduler.Finish();
-		context.ShutdownGpu();
 		std::printf("[host]    %-32s ok\n", "GpuMappedRangeLifecycle");
 	}
 
@@ -1571,73 +1494,21 @@ public:
 			gpu_thread = std::this_thread::get_id();
 			Require("GpuCommandLane", "FIFO", order == 1,
 			        "synchronous command overtook an older host command");
-			Require("GpuCommandLane", "GPU context", Gpu::IsGpuThread(),
-			        "host command did not run on the GPU thread");
+			Require("GpuCommandLane", "generic context",
+			        !Gpu::IsCommandProcessorThread() && Gpu::CurrentCommandProcessor() == nullptr,
+			        "generic host command manufactured a PM4 processor context");
 			gpu.SendCommandSync([&nested_thread] { nested_thread = std::this_thread::get_id(); });
 			order = 2;
 		});
+		gpu.SendCommandSyncWithProcessor([&](CommandProcessor& processor) {
+			Require("GpuCommandLane", "processor context",
+			        Gpu::IsCommandProcessorThread() && Gpu::CurrentCommandProcessor() == &processor,
+			        "resource command did not receive its explicit processor context");
+		});
 		Require("GpuCommandLane", "dispatch thread",
 		        order == 2 && gpu_thread != caller_thread && nested_thread == gpu_thread,
 		        "host command did not run on the GPU thread or nested sync deadlocked");
 
-		alignas(uint32_t) uint32_t packet_marker_a = 0;
-		alignas(uint32_t) uint32_t packet_marker_b = 0;
-		const auto write_packet = [](uint32_t* packet, uint32_t* destination, uint32_t value) {
-			const auto destination_address = reinterpret_cast<uint64_t>(destination);
-			packet[0] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
-			packet[1] = 0;
-			packet[2] = static_cast<uint32_t>(destination_address);
-			packet[3] = static_cast<uint32_t>(destination_address >> 32u);
-			packet[4] = value;
-		};
-		std::array<uint32_t, 1024> polling_loop {};
-		for (size_t i = 0; i < polling_loop.size() - 4; i += 2) {
-			polling_loop[i]     = KYTY_PM4(2, Pm4::IT_NOP, Pm4::R_ZERO);
-			polling_loop[i + 1] = 0;
-		}
-		const auto loop_address = reinterpret_cast<uint64_t>(polling_loop.data());
-		polling_loop[1020] = KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0);
-		polling_loop[1021] = static_cast<uint32_t>(loop_address);
-		polling_loop[1022] = static_cast<uint32_t>(loop_address >> 32u);
-		polling_loop[1023] = 0x0f200000u | static_cast<uint32_t>(polling_loop.size());
-
-		std::array<uint32_t, 14> polling_commands {};
-		write_packet(polling_commands.data(), &packet_marker_a, 11);
-		polling_commands[5] = KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0);
-		polling_commands[6] = static_cast<uint32_t>(loop_address);
-		polling_commands[7] = static_cast<uint32_t>(loop_address >> 32u);
-		polling_commands[8] = 0x0f200000u | static_cast<uint32_t>(polling_loop.size());
-		write_packet(polling_commands.data() + 9, &packet_marker_b, 22);
-		std::binary_semaphore stream_gate_entered {0};
-		std::binary_semaphore stream_gate_release {0};
-		gpu.SendCommand([&] {
-			stream_gate_entered.release();
-			stream_gate_release.acquire();
-		});
-		gpu.Submit(polling_commands.data(), polling_commands.size(), nullptr, 0);
-		stream_gate_entered.acquire();
-		stream_gate_release.release();
-		uint32_t packet_marker_a_at_callback = UINT32_MAX;
-		uint32_t packet_marker_b_at_callback = UINT32_MAX;
-		for (uint32_t attempt = 0; attempt < 8 && packet_marker_a_at_callback != 11; attempt++) {
-			gpu.SendCommandSync([&] {
-				if (packet_marker_a == 11 && packet_marker_b == 0) {
-					packet_marker_a_at_callback = packet_marker_a;
-					packet_marker_b_at_callback = packet_marker_b;
-					polling_loop[1020] = KYTY_PM4(2, Pm4::IT_NOP, Pm4::R_ZERO);
-					polling_loop[1021] = 0;
-					polling_loop[1022] = KYTY_PM4(2, Pm4::IT_NOP, Pm4::R_ZERO);
-					polling_loop[1023] = 0;
-				}
-			});
-			std::this_thread::yield();
-		}
-		gpu.Done();
-		Require("GpuCommandLane", "packet-boundary command polling",
-		        packet_marker_a_at_callback == 11 && packet_marker_b_at_callback == 0 &&
-		            packet_marker_a == 11 && packet_marker_b == 22,
-		        "host command waited for an entire non-suspended PM4 stream");
-
 		uint32_t   label   = 0;
 		uint32_t   prefix  = 0;
 		uint32_t   suffix  = 0;
@@ -1816,7 +1687,7 @@ public:
 		gpu.Submit(dma_commands.data(), static_cast<uint32_t>(dma_commands.size()), nullptr, 0);
 		gpu.Done();
 		constexpr uint32_t clean_fill_value = 0xdecafbad;
-		gpu.SendCommandSync([&] {
+		gpu.SendCommandSyncWithProcessor([&](CommandProcessor&) {
 			auto& buffer_cache = resources.GetBufferCache();
 			Require("GpuCommandLane", "clean cached setup",
 			        buffer_cache.HasPageOverlap(clean_cached_fill, sizeof(source_words)) &&
@@ -1896,116 +1767,14 @@ public:
 		                                                       clean_copy_words[1]},
 		        "host-memory fill/copy did not update the clean cached mirror");
 
-		gpu.SendCommandSync([&] {
-			Require("GpuCommandLane", "GPU memory invalidation",
+		gpu.SendCommandSyncWithProcessor([&](CommandProcessor& processor) {
+			Require("GpuCommandLane", "processor fault context",
+			        Gpu::CurrentCommandProcessor() == &processor,
+			        "processor resource test lost its command context");
+			Require("GpuCommandLane", "processor memory invalidation",
 			        resources.InvalidateMemory(fault_base, sizeof(uint32_t)),
-			        "GPU memory invalidation did not find its mapped range");
+			        "processor memory invalidation did not find its mapped range");
 		});
-
-		auto& buffer_cache = resources.GetBufferCache();
-		Require("GpuCommandLane", "clean tracked fault setup",
-		        buffer_cache.HasPageOverlap(immediate_dst, sizeof(uint32_t)) &&
-		            !buffer_cache.HasGpuDirtyBytes(immediate_dst, sizeof(uint32_t)),
-		        "clean write-fault test address is not backed by a clean cached Buffer");
-		constexpr uint64_t dirty_fault_address = fault_base + 0xd000;
-		constexpr uint32_t dirty_fault_value   = 0x5a17c0deu;
-		constexpr uint32_t dirty_fault_stale   = 0x0ddba11u;
-		std::memcpy(reinterpret_cast<void*>(dirty_fault_address), &dirty_fault_stale,
-		            sizeof(dirty_fault_stale));
-		gpu.SendCommandSync([&] {
-			auto dirty = buffer_cache.ObtainBuffer(scheduler.Current(), dirty_fault_address,
-			                                       sizeof(dirty_fault_value), true, false);
-			Require("GpuCommandLane", "dirty tracked fault setup", dirty.owner != nullptr,
-			        "dirty write-fault test could not create a cached Buffer");
-			scheduler.Current().RetainResourceUntilFence(dirty.owner);
-			buffer_cache.FillBuffer(dirty_fault_address, sizeof(dirty_fault_value),
-			                        dirty_fault_value);
-		});
-		Require("GpuCommandLane", "dirty tracked fault ownership",
-		        buffer_cache.HasGpuDirtyBytes(dirty_fault_address, sizeof(dirty_fault_value)),
-		        "dirty write-fault test address did not acquire GPU ownership");
-
-		std::binary_semaphore block_entered {0};
-		std::binary_semaphore block_release {0};
-		std::binary_semaphore clean_fault_complete {0};
-		bool                  clean_fault_handled = false;
-		gpu.SendCommand([&] {
-			block_entered.release();
-			block_release.acquire();
-		});
-		block_entered.acquire();
-		std::jthread clean_fault_thread([&] {
-			clean_fault_handled = resources.HandleFault(PageFaultAccess::Write, immediate_dst);
-			clean_fault_complete.release();
-		});
-		const bool clean_fault_was_direct =
-		    clean_fault_complete.try_acquire_for(std::chrono::seconds(1));
-		if (!clean_fault_was_direct) {
-			block_release.release();
-			clean_fault_complete.acquire();
-		}
-		clean_fault_thread.join();
-		Require("GpuCommandLane", "clean fault direct path",
-		        clean_fault_was_direct && clean_fault_handled,
-		        "a clean CPU write fault waited for the blocked GPU command lane");
-
-		std::binary_semaphore dirty_fault_complete {0};
-		bool                  dirty_fault_handled = false;
-		std::jthread dirty_fault_thread([&] {
-			dirty_fault_handled =
-			    resources.HandleFault(PageFaultAccess::Write, dirty_fault_address);
-			dirty_fault_complete.release();
-		});
-		const bool dirty_fault_bypassed_lane =
-		    dirty_fault_complete.try_acquire_for(std::chrono::milliseconds(200));
-		block_release.release();
-		if (!dirty_fault_bypassed_lane) {
-			dirty_fault_complete.acquire();
-		}
-		dirty_fault_thread.join();
-		uint32_t dirty_fault_backing = 0;
-		std::memcpy(&dirty_fault_backing, reinterpret_cast<const void*>(dirty_fault_address),
-		            sizeof(dirty_fault_backing));
-		Require("GpuCommandLane", "dirty fault synchronization",
-		        !dirty_fault_bypassed_lane && dirty_fault_handled &&
-		            dirty_fault_backing == dirty_fault_value &&
-		            !buffer_cache.HasGpuDirtyBytes(dirty_fault_address, sizeof(dirty_fault_value)),
-		        "a GPU-dirty write fault bypassed synchronization or lost the published bytes");
-
-		constexpr uint64_t empty_copy_fault_address = fault_base + 0xe000;
-		constexpr uint32_t empty_copy_fault_value   = 0x6b28d1efu;
-		gpu.SendCommandSync([&] {
-			auto dirty = buffer_cache.ObtainBuffer(scheduler.Current(), empty_copy_fault_address,
-			                                       sizeof(empty_copy_fault_value), true, false);
-			Require("GpuCommandLane", "empty-copy write setup", dirty.owner != nullptr,
-			        "empty-copy write test could not create a cached Buffer");
-			scheduler.Current().RetainResourceUntilFence(dirty.owner);
-			buffer_cache.FillBuffer(empty_copy_fault_address, sizeof(empty_copy_fault_value),
-			                        empty_copy_fault_value);
-			buffer_cache.ReadMemory(empty_copy_fault_address, sizeof(empty_copy_fault_value));
-			const bool gpu_owned = buffer_cache.IsRegionGpuModified(
-			    empty_copy_fault_address, sizeof(empty_copy_fault_value));
-			const bool cpu_owned = buffer_cache.IsRegionCpuModified(
-			    empty_copy_fault_address, sizeof(empty_copy_fault_value));
-			Require("GpuCommandLane", "empty-copy read ownership",
-			        !gpu_owned && !cpu_owned,
-			        "readback did not leave clean ownership for the queued write invalidation");
-			buffer_cache.ReadMemory(empty_copy_fault_address, sizeof(empty_copy_fault_value), true);
-		});
-		uint32_t empty_copy_fault_backing = 0;
-		std::memcpy(&empty_copy_fault_backing, reinterpret_cast<const void*>(empty_copy_fault_address),
-		            sizeof(empty_copy_fault_backing));
-		const bool empty_copy_cpu_owned = buffer_cache.IsRegionCpuModified(
-		    empty_copy_fault_address, sizeof(empty_copy_fault_value));
-		const bool empty_copy_gpu_owned = buffer_cache.IsRegionGpuModified(
-		    empty_copy_fault_address, sizeof(empty_copy_fault_value));
-		const bool empty_copy_dirty =
-		    buffer_cache.HasGpuDirtyBytes(empty_copy_fault_address, sizeof(empty_copy_fault_value));
-		Require("GpuCommandLane", "empty-copy write ownership",
-		        empty_copy_fault_backing == empty_copy_fault_value &&
-		            empty_copy_cpu_owned && !empty_copy_gpu_owned && !empty_copy_dirty,
-		        "write invalidation without a remaining copy did not establish CPU ownership");
-
 		resources.UnmapMemory(fault_base, fault_size);
 		Require("GpuCommandLane", "processor fault unmap",
 		        Libs::LibKernel::Memory::KernelMunmap(fault_base, fault_size) == 0,
@@ -2231,14 +2000,12 @@ public:
 		constexpr uint32_t    ring_fault_second_value       = 0x4e5f6071u;
 
 		EnsureRuntimeContext();
-		auto&            context = Renderer();
-		CommandScheduler scheduler(context, m_runtime_context);
+		CommandScheduler scheduler(Renderer(), m_runtime_context);
 		HW::Context      registers {};
 		HW::UserConfig   user_config {};
 		HW::Shader       shaders {};
 		scheduler.Begin(registers, user_config, shaders);
-		context.InitializeGpu(nullptr);
-		auto& gpu = context.GetGpu();
+		Gpu gpu(Renderer());
 
 		int64_t direct_offset = -1;
 		Require(name, "direct allocation",
@@ -2631,7 +2398,7 @@ public:
 			resources.UnmapMemory(base, allocation_size);
 			scheduler.Finish();
 		}
-		context.ShutdownGpu();
+		gpu.Shutdown();
 		Require(name, "unmap direct backing",
 		        Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
 		        "dirty-GC direct-memory mapping release failed");
@@ -2648,14 +2415,12 @@ public:
 		constexpr uint64_t    allocation_size      = 0x2800000;
 		constexpr uint64_t    allocation_alignment = 0x200000;
 		EnsureRuntimeContext();
-		auto&            context = Renderer();
-		CommandScheduler scheduler(context, m_runtime_context);
+		CommandScheduler scheduler(Renderer(), m_runtime_context);
 		HW::Context      registers {};
 		HW::UserConfig   user_config {};
 		HW::Shader       shaders {};
 		scheduler.Begin(registers, user_config, shaders);
-		context.InitializeGpu(nullptr);
-		auto&   gpu = context.GetGpu();
+		Gpu     gpu(Renderer());
 		int64_t direct_offset = -1;
 		Require(name, "direct allocation",
 		        Libs::LibKernel::Memory::KernelAllocateDirectMemory(
@@ -2723,110 +2488,6 @@ public:
 			                vk::Format::eR8G8B8A8Srgb,
 			        "registered compatible backing did not reuse one ImageId");
 
-			const auto IsOnlyImage = [](const std::vector<ImageId>& ids, ImageId expected) {
-				return ids.size() == 1 && ids.front() == expected;
-			};
-			const auto exact_byte_miss =
-			    TextureCacheTestAccess::FindImages(texture_cache, base + 8, 1, false);
-			const auto touched_page_hit =
-			    TextureCacheTestAccess::FindImages(texture_cache, base + 8, 1, true);
-			const auto next_page_miss =
-			    TextureCacheTestAccess::FindImages(texture_cache, base + 0x1000, 1, true);
-			Require(name, "exact and 4-KiB page filtering",
-			        exact_byte_miss.empty() && IsOnlyImage(touched_page_hit, first) &&
-			            next_page_miss.empty(),
-			        "coarse candidates did not preserve exact-byte and touched-page semantics");
-
-			const auto MakeOwnershipInfo = [](uint64_t address, uint64_t size) {
-				ImageInfo info {};
-				info.data      = {address, size};
-				info.extent    = {1, 1, 1};
-				info.resources = {1, 1};
-				info.samples   = 1;
-				return info;
-			};
-			const auto spanning_info = MakeOwnershipInfo(base + 0x1ff000, 0x2000);
-			const auto spanning = TextureCacheTestAccess::InsertImage(texture_cache, spanning_info);
-			const auto spanning_results = TextureCacheTestAccess::FindImages(
-			    texture_cache, spanning_info.data.address, spanning_info.data.size, false);
-			Require(name, "one-MiB cross-page deduplication",
-			        spanning && IsOnlyImage(spanning_results, spanning) &&
-			            TextureCacheTestAccess::PageOwnerCount(texture_cache,
-			                                                       spanning_info.data.address) == 1 &&
-			            TextureCacheTestAccess::PageOwnerCount(
-			                texture_cache, spanning_info.data.End() - 1) == 1,
-			        "an image spanning two coarse pages was missing or returned more than once");
-			TextureCacheTestAccess::DeleteImage(texture_cache, spanning);
-			Require(name, "cross-page owner cleanup",
-			        TextureCacheTestAccess::PageOwnerCount(texture_cache,
-			                                               spanning_info.data.address) == 0 &&
-			            TextureCacheTestAccess::PageOwnerCount(
-			                texture_cache, spanning_info.data.End() - 1) == 0 &&
-			            TextureCacheTestAccess::FindImages(texture_cache,
-			                                               spanning_info.data.address,
-			                                               spanning_info.data.size, false)
-			                .empty(),
-			        "cross-page unregister left a stale coarse-page membership");
-
-			const auto shared_info = MakeOwnershipInfo(base + 0x500100, 0x100);
-			const auto shared_first =
-			    TextureCacheTestAccess::InsertImage(texture_cache, shared_info);
-			const auto shared_second =
-			    TextureCacheTestAccess::InsertImage(texture_cache, shared_info);
-			const auto shared_results = TextureCacheTestAccess::FindImages(
-			    texture_cache, shared_info.data.address, shared_info.data.size, false);
-			Require(name, "shared coarse-page registration",
-			        shared_results.size() == 2 &&
-			            std::find(shared_results.begin(), shared_results.end(), shared_first) !=
-			                shared_results.end() &&
-			            std::find(shared_results.begin(), shared_results.end(), shared_second) !=
-			                shared_results.end(),
-			        "two registered owners were not retained in one coarse page");
-			TextureCacheTestAccess::DeleteImage(texture_cache, shared_first);
-			const auto shared_survivor = TextureCacheTestAccess::FindImages(
-			    texture_cache, shared_info.data.address, shared_info.data.size, false);
-			Require(name, "shared coarse-page unregister",
-			        IsOnlyImage(shared_survivor, shared_second) &&
-			            TextureCacheTestAccess::PageOwnerCount(texture_cache,
-			                                                       shared_info.data.address) == 1,
-			        "unregistering one owner removed its coarse-page neighbor");
-			TextureCacheTestAccess::DeleteImage(texture_cache, shared_second);
-			Require(name, "final shared coarse-page unregister",
-			        TextureCacheTestAccess::PageOwnerCount(texture_cache,
-			                                               shared_info.data.address) == 0,
-			        "the final shared owner remained registered");
-
-			constexpr uint64_t large_owner_size = 64ull * 1024 * 1024;
-			const auto large_info = MakeOwnershipInfo(base + 0x800000, large_owner_size);
-			const auto large_owner =
-			    TextureCacheTestAccess::InsertImage(texture_cache, large_info);
-			Require(name, "production one-MiB registration granularity",
-			        TextureCacheTestAccess::OwnedPageCount(
-			            texture_cache, large_info.data.address, large_info.data.size, large_owner) == 64,
-			        "64 MiB image registration did not create exactly 64 coarse memberships");
-			TextureCacheTestAccess::DeleteImage(texture_cache, large_owner);
-			Require(name, "production one-MiB unregister granularity",
-			        TextureCacheTestAccess::OwnedPageCount(
-			            texture_cache, large_info.data.address, large_info.data.size, large_owner) == 0,
-			        "large image unregister left coarse memberships behind");
-
-			const ImageId stale {first.index, first.generation + 1};
-			TextureCacheTestAccess::AddPageOwner(texture_cache, base, stale);
-			const auto stale_filtered =
-			    TextureCacheTestAccess::FindImages(texture_cache, base, sizeof(initial), false);
-			Require(name, "stale page owner filtering",
-			        IsOnlyImage(stale_filtered, first) &&
-			            TextureCacheTestAccess::RemovePageOwner(texture_cache, base, stale),
-			        "a stale generation escaped the direct page-owner lookup");
-
-			TextureCacheTestAccess::SetQueryEpoch(texture_cache, UINT32_MAX);
-			const auto wrap_results =
-			    TextureCacheTestAccess::FindImages(texture_cache, base, sizeof(initial), false);
-			Require(name, "page-owner query epoch wrap",
-			        IsOnlyImage(wrap_results, first) &&
-			            TextureCacheTestAccess::QueryEpoch(texture_cache) == 1,
-			        "query deduplication failed while wrapping its epoch");
-
 			auto&              image               = texture_cache.GetImage(first);
 			constexpr uint32_t final_sampled_value = 0x88776655u;
 			Require(name, "sampled write between discovery and acquisition",
@@ -5111,7 +4772,7 @@ public:
 			resources.UnmapMemory(base, allocation_size);
 			scheduler.Finish();
 		}
-		context.ShutdownGpu();
+		gpu.Shutdown();
 		Require(name, "unmap direct backing",
 		        Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
 		        "cache direct-memory mapping release failed");