Implement ftruncate abi

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

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: Build KytyPS5
+name: Build and Release KytyPS5
 
 on:
   workflow_dispatch:
@@ -7,7 +7,8 @@ on:
   pull_request:
 
 jobs:
-  build:
+  windows:
+    name: Build KytyPS5 (Windows)
     runs-on: windows-2022
 
     steps:
@@ -22,11 +23,31 @@ jobs:
       - name: Setup Ninja
         uses: seanmiddleditch/gha-setup-ninja@v5
 
-      - name: Install glslang
+      - name: Locate vcpkg
+        id: vcpkg
         shell: pwsh
         run: |
           $vcpkgRoot = Split-Path (Get-Command vcpkg).Source
-          vcpkg install glslang[tools,opt]:x64-windows
+          $portHash = (Get-FileHash "$vcpkgRoot\ports\glslang\vcpkg.json" -Algorithm SHA256).Hash
+          "root=$vcpkgRoot" |
+            Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+          "port_hash=$($portHash.ToLowerInvariant())" |
+            Out-File -FilePath $env:GITHUB_OUTPUT -Encoding utf8 -Append
+
+      - name: Cache glslang
+        id: glslang_cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ steps.vcpkg.outputs.root }}\installed\x64-windows
+          key: glslang-${{ runner.os }}-${{ runner.arch }}-${{ steps.vcpkg.outputs.port_hash }}-tools-opt
+
+      - name: Install glslang
+        shell: pwsh
+        run: |
+          $vcpkgRoot = "${{ steps.vcpkg.outputs.root }}"
+          if ("${{ steps.glslang_cache.outputs.cache-hit }}" -ne "true") {
+            vcpkg install glslang[tools,opt]:x64-windows
+          }
           "$vcpkgRoot\installed\x64-windows\tools\glslang" |
             Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
@@ -52,7 +73,7 @@ jobs:
       - name: Configure
         shell: cmd
         run: |
-          cmake -S src -B _Build/windows ^
+          cmake -S . -B _Build/windows ^
             -G Ninja ^
             -DCMAKE_BUILD_TYPE=Release ^
             -DCMAKE_C_COMPILER=clang-cl ^
@@ -62,52 +83,323 @@ jobs:
       - name: Build
         shell: cmd
         run: |
-          cmake --build _Build/windows --target launcher --parallel
+          cmake --build _Build/windows --target launcher audio_out2_port_tests virtual_memory_allocation_tests --parallel
+
+      - name: Test
+        shell: cmd
+        run: |
+          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|virtual_memory_allocation)$"
 
       - name: Install
         shell: cmd
         run: |
           cmake --install _Build/windows --prefix _Build/windows/install
 
-      - name: Upload Artifacts
+      - name: Upload Windows artifacts
         uses: actions/upload-artifact@v4
         with:
-          name: KytyPS5
+          name: KytyPS5-Windows-x64
           path: _Build/windows/install/**
           if-no-files-found: error
 
+  macos:
+    name: Build KytyPS5 (macOS)
+    runs-on: macos-15
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Select Xcode 26
+        shell: bash
+        run: |
+          xcode_path="$(ls -d /Applications/Xcode_26*.app | tail -n 1)"
+          test -n "$xcode_path"
+          sudo xcode-select --switch "$xcode_path/Contents/Developer"
+          xcodebuild -version
+
+      - name: Install build dependencies
+        shell: bash
+        run: brew install glslang ninja
+
+      - name: Install Qt 6.10.3
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: "6.10.3"
+          host: mac
+          target: desktop
+          arch: clang_64
+          cache: true
+
+      - name: Verify toolchain
+        shell: bash
+        run: |
+          git --version
+          cmake --version
+          ninja --version
+          clang++ --version
+          glslangValidator --version
+          echo "Host architecture: $(uname -m)"
+          echo "QT_ROOT_DIR=$QT_ROOT_DIR"
+
+      - name: Configure
+        shell: bash
+        run: |
+          cmake -S . -B _Build/macos \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+            -DCMAKE_C_COMPILER=clang \
+            -DCMAKE_CXX_COMPILER=clang++ \
+            -DCMAKE_PREFIX_PATH="$QT_ROOT_DIR"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build _Build/macos \
+            --target launcher audio_out2_port_tests virtual_memory_allocation_tests \
+            --parallel
+
+      - name: Test
+        shell: bash
+        run: |
+          ctest --test-dir _Build/macos --output-on-failure \
+            -R '^(audio_out2_port|virtual_memory_allocation)$'
+
+      - name: Install
+        shell: bash
+        run: |
+          cmake --install _Build/macos --prefix _Build/macos/install
+
+      - name: Bundle MoltenVK
+        shell: bash
+        env:
+          MOLTENVK_VERSION: v1.4.2
+          MOLTENVK_SHA256: f95765a6229cb7b915990a2890ce12ebe36a730b021545d3d52ae69ce4c4024e
+        run: |
+          archive="$RUNNER_TEMP/MoltenVK-macos.tar"
+          package="$RUNNER_TEMP/MoltenVK"
+          curl --fail --location --retry 3 \
+            --output "$archive" \
+            "https://github.com/KhronosGroup/MoltenVK/releases/download/$MOLTENVK_VERSION/MoltenVK-macos.tar"
+          echo "$MOLTENVK_SHA256  $archive" | shasum -a 256 --check
+          tar -xf "$archive" -C "$RUNNER_TEMP"
+          install -m 755 \
+            "$package/MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib" \
+            _Build/macos/install/libMoltenVK.dylib
+          install -m 644 "$package/LICENSE" _Build/macos/install/LICENSE.MoltenVK
+          codesign --force --sign - --timestamp=none _Build/macos/install/libMoltenVK.dylib
+
+      - name: Verify artifacts
+        shell: bash
+        run: |
+          file _Build/macos/install/launcher
+          file _Build/macos/install/kyty_emulator
+          file _Build/macos/install/libMoltenVK.dylib
+          lipo _Build/macos/install/launcher -verify_arch x86_64
+          lipo _Build/macos/install/kyty_emulator -verify_arch x86_64
+          lipo _Build/macos/install/libMoltenVK.dylib -verify_arch x86_64
+          codesign --verify --strict _Build/macos/install/kyty_emulator
+          codesign --verify --strict _Build/macos/install/libMoltenVK.dylib
+
+      - name: Upload macOS artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: KytyPS5-macOS-x86_64
+          path: _Build/macos/install/**
+          if-no-files-found: error
+
+  linux:
+    name: Build KytyPS5 (Linux)
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install build dependencies
+        shell: bash
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends --yes \
+            clang \
+            glslang-tools \
+            libasound2-dev \
+            libdbus-1-dev \
+            libgl1-mesa-dev \
+            libpulse-dev \
+            libudev-dev \
+            libwayland-dev \
+            libx11-dev \
+            libxcursor-dev \
+            libxext-dev \
+            libxfixes-dev \
+            libxi-dev \
+            libxkbcommon-dev \
+            libxrandr-dev \
+            libxss-dev \
+            lld \
+            ninja-build \
+            wayland-protocols
+
+      - name: Install Qt 6.10.3
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: "6.10.3"
+          host: linux
+          target: desktop
+          arch: linux_gcc_64
+          cache: true
+
+      - name: Verify toolchain
+        shell: bash
+        run: |
+          git --version
+          cmake --version
+          ninja --version
+          clang++ --version
+          ld.lld --version
+          glslangValidator --version
+          echo "Qt6_DIR=$Qt6_DIR"
+
+      - name: Configure
+        shell: bash
+        run: |
+          mkdir -p _Build
+          cmake -S . -B _Build/linux \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_C_COMPILER=clang \
+            -DCMAKE_CXX_COMPILER=clang++ \
+            -DCMAKE_PREFIX_PATH="$Qt6_DIR" 2>&1 | tee _Build/configure.log
+          exit "${PIPESTATUS[0]}"
+
+      - name: Verify SDL2 backends
+        shell: bash
+        run: |
+          status=0
+          for feature in SDL_ALSA SDL_PULSEAUDIO SDL_WAYLAND SDL_X11 SDL_LIBUDEV SDL_DBUS; do
+            if grep -qE "^--   ${feature} +\\(Wanted: ON\\): ON" _Build/configure.log; then
+              echo "ok   ${feature}"
+            else
+              echo "FAIL ${feature} is not enabled"
+              status=1
+            fi
+          done
+          exit "$status"
+
+      - name: Build
+        shell: bash
+        run: |
+          cmake --build _Build/linux \
+            --target launcher page_manager_tests memory_tracker_tests \
+              audio_out2_port_tests virtual_memory_allocation_tests \
+            --parallel
+
+      - name: Test
+        shell: bash
+        run: |
+          ctest --test-dir _Build/linux --output-on-failure \
+            -R '^(audio_out2_port|page_manager|memory_tracker|virtual_memory_allocation)$'
+
+      - name: Install
+        shell: bash
+        run: |
+          cmake --install _Build/linux --prefix _Build/linux/install
+
+      - name: Verify artifacts
+        shell: bash
+        run: |
+          file _Build/linux/install/launcher
+          file _Build/linux/install/kyty_emulator
+          file _Build/linux/install/kyty_emulator | grep -q "ELF 64-bit LSB .*x86-64"
+          ldd _Build/linux/install/kyty_emulator > /dev/null
+          readelf -d _Build/linux/install/launcher | grep -q 'RPATH.*\$ORIGIN/lib'
+          while IFS= read -r -d '' binary; do
+            while read -r dependency; do
+              test -e "_Build/linux/install/lib/$dependency"
+            done < <(
+              readelf -d "$binary" |
+                sed -n 's/.*Shared library: \[\(libQt6[^]]*\|libicu[^]]*\)\].*/\1/p'
+            )
+          done < <(
+            find _Build/linux/install/launcher _Build/linux/install/plugins \
+              -type f \( -name launcher -o -name '*.so' \) -print0
+          )
+          _Build/linux/install/kyty_emulator --help > /dev/null
+
+      - name: Upload Linux artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: KytyPS5-Linux-x86_64
+          path: _Build/linux/install/**
+          if-no-files-found: error
+
   release:
-    if: github.event_name == 'push'
+    name: Release KytyPS5
-    needs: build
+    if: github.event_name == 'push' && github.repository == 'KytyPS5/KytyPS5'
+    needs: [windows, macos, linux]
     runs-on: ubuntu-latest
     permissions:
       contents: write
 
     steps:
-      - name: Download build
+      - name: Download builds
         uses: actions/download-artifact@v4
         with:
-          name: KytyPS5
+          path: artifacts
-          path: KytyPS5
 
       - name: Set release name
         shell: bash
         run: |
           echo "RELEASE_NAME=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_ENV"
 
-      - name: Package build
+      - name: Package builds
         shell: bash
-        run: zip -r "$RELEASE_NAME.zip" KytyPS5
+        run: |
+          windows_dir="artifacts/KytyPS5-Windows-x64"
+          macos_dir="artifacts/KytyPS5-macOS-x86_64"
+          linux_dir="artifacts/KytyPS5-Linux-x86_64"
+          test -d "$windows_dir"
+          test -d "$macos_dir"
+          test -d "$linux_dir"
+          chmod a+x \
+            "$macos_dir/launcher" \
+            "$macos_dir/kyty_emulator" \
+            "$macos_dir/libMoltenVK.dylib" \
+            "$linux_dir/launcher" \
+            "$linux_dir/kyty_emulator"
+          (
+            cd "$windows_dir"
+            zip -r "$GITHUB_WORKSPACE/$RELEASE_NAME-Windows-x64.zip" .
+          )
+          (
+            cd "$macos_dir"
+            zip -r "$GITHUB_WORKSPACE/$RELEASE_NAME-macOS-x86_64.zip" .
+          )
+          tar -C "$linux_dir" -czf \
+            "$GITHUB_WORKSPACE/$RELEASE_NAME-Linux-x86_64.tar.gz" .
 
       - name: Create release
         shell: bash
         env:
           GH_TOKEN: ${{ github.token }}
         run: |
+          assets=(
+            "$RELEASE_NAME-Windows-x64.zip"
+            "$RELEASE_NAME-macOS-x86_64.zip"
+            "$RELEASE_NAME-Linux-x86_64.tar.gz"
+          )
           if gh release view "$RELEASE_NAME" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then
-            gh release upload "$RELEASE_NAME" "$RELEASE_NAME.zip" --clobber --repo "$GITHUB_REPOSITORY"
+            gh release upload "$RELEASE_NAME" "${assets[@]}" \
+              --clobber \
+              --repo "$GITHUB_REPOSITORY"
           else
-            gh release create "$RELEASE_NAME" "$RELEASE_NAME.zip" \
+            gh release create "$RELEASE_NAME" "${assets[@]}" \
               --generate-notes \
               --repo "$GITHUB_REPOSITORY" \
               --target "$GITHUB_SHA" \

.gitignore

@@ -2,4 +2,6 @@
 .vs/
 .idea/
 build/
-_Build/vscode-clang/
+_Build/vscode-clang/
+_Build/
+cmake-build-debug/

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-    "cmake.sourceDirectory": "${workspaceFolder}/src",
+    "cmake.sourceDirectory": "${workspaceFolder}",
     "cmake.buildDirectory": "${workspaceFolder}/_Build/vscode-clang",
     "cmake.generator": "Ninja",
     "cmake.environment": {

3rdparty/CMakeLists.txt

@@ -44,7 +44,17 @@ set(SPDLOG_NO_EXCEPTIONS ON CACHE BOOL "" FORCE)
 add_subdirectory(spdlog EXCLUDE_FROM_ALL)
 
 if (NOT TARGET FFmpeg::ffmpeg)
-	if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
+	# On macOS the target arch is driven by CMAKE_OSX_ARCHITECTURES, not the host
+	# CMAKE_SYSTEM_PROCESSOR (which reports arm64 even for an x86_64/Rosetta build).
+	if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+		if(CMAKE_OSX_ARCHITECTURES MATCHES "^(x86_64)$")
+			set(ARCHITECTURE x86_64)
+		elseif(CMAKE_OSX_ARCHITECTURES MATCHES "^(arm64)$")
+			set(ARCHITECTURE arm64)
+		else()
+			set(ARCHITECTURE x86_64 arm64) # universal
+		endif()
+	elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|ARM64)$")
 		set(ARCHITECTURE arm64)
 	else()
 		set(ARCHITECTURE x86_64)

3rdparty/cpuinfo/CMakeLists.txt

@@ -5,7 +5,14 @@ set(cpuinfo_src
 	deps/clog/src/clog.c
 )
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(i[3-6]86|AMD64|x86(_64)?)$")
+# On Apple the target arch is driven by CMAKE_OSX_ARCHITECTURES, not the host
+# CMAKE_SYSTEM_PROCESSOR (which is arm64 even for an x86_64/Rosetta build).
+set(CPUINFO_TARGET_PROC "${CMAKE_SYSTEM_PROCESSOR}")
+if(APPLE AND CMAKE_OSX_ARCHITECTURES)
+	list(GET CMAKE_OSX_ARCHITECTURES 0 CPUINFO_TARGET_PROC)
+endif()
+
+if(CPUINFO_TARGET_PROC MATCHES "^(i[3-6]86|AMD64|x86(_64)?)$")
 	list(APPEND cpuinfo_src
 		src/x86/init.c
 		src/x86/info.c
@@ -19,11 +26,13 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(i[3-6]86|AMD64|x86(_64)?)$")
 		src/x86/cache/deterministic.c)
 	if(LINUX OR ANDROID)
 		list(APPEND cpuinfo_src src/x86/linux/init.c src/x86/linux/cpuinfo.c)
+	elseif(APPLE)
+		list(APPEND cpuinfo_src src/x86/mach/init.c src/mach/topology.c)
 	else()
 		list(APPEND cpuinfo_src src/x86/windows/init.c)
 	endif()
-	
+
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv[5-8].*|aarch64|arm64)$")
+elseif(CPUINFO_TARGET_PROC MATCHES "^(armv[5-8].*|aarch64|arm64)$")
 	list(APPEND cpuinfo_src src/arm/uarch.c src/arm/cache.c)
 	
 	if(LINUX OR ANDROID)

CMakeLists.txt

@@ -0,0 +1,586 @@
+cmake_minimum_required(VERSION 3.12...4.3)
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
+	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
+endif()
+
+project(Kyty)
+
+set(KYTY_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
+set(KYTY_TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests")
+set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/3rdparty")
+
+if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")
+	set(LINUX TRUE)
+endif()
+
+if (NOT (WIN32 OR LINUX OR APPLE))
+    message(FATAL_ERROR "only Windows, Linux, and macOS builds are supported")
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_SCAN_FOR_MODULES OFF)
+
+include("${KYTY_SOURCE_DIR}/utils.cmake")
+include(CTest)
+
+option(KYTY_ENABLE_CLANG_TIDY "Run clang-tidy checks during builds" OFF)
+
+set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+include(TestBigEndian)
+
+if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+	message(FATAL_ERROR "only 64-bit builds are supported")
+endif()
+
+test_big_endian(BIG_ENDIAN)
+if(BIG_ENDIAN)
+	set(KYTY_ENDIAN KYTY_ENDIAN_BIG)
+else()
+	set(KYTY_ENDIAN KYTY_ENDIAN_LITTLE)
+endif()
+
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+	set(KYTY_BUILD KYTY_BUILD_DEBUG)
+else()
+	set(KYTY_BUILD KYTY_BUILD_RELEASE)
+endif()
+
+if(LINUX OR APPLE)
+	# macOS rides the POSIX/Linux code paths until it gets a dedicated platform
+	set(KYTY_PLATFORM KYTY_PLATFORM_LINUX)
+else()
+	set(KYTY_PLATFORM KYTY_PLATFORM_WINDOWS)
+endif()
+
+set(CLANG FALSE)
+set(GCC FALSE)
+set(KYTY_CLANG_CL FALSE)
+get_filename_component(KYTY_CXX_COMPILER_NAME "${CMAKE_CXX_COMPILER}" NAME_WE)
+string(TOLOWER "${KYTY_CXX_COMPILER_NAME}" KYTY_CXX_COMPILER_NAME)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
+	set(CLANG TRUE)
+	set(KYTY_COMPILER CLANG)
+	if(WIN32 AND KYTY_CXX_COMPILER_NAME STREQUAL "clang-cl")
+		set(KYTY_CLANG_CL TRUE)
+		set(KYTY_LINKER LLD_LINK)
+	elseif(APPLE)
+		set(KYTY_LINKER LD64) # Apple's default linker; lld flags don't apply
+	else()
+		set(KYTY_LINKER LLD)
+	endif()
+	if ((CMAKE_AR MATCHES "llvm") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0.0) AND (CMAKE_CXX_COMPILER MATCHES "winlibs"))
+		string(REPLACE "llvm-ar.exe" "ar.exe" CMAKE_AR ${CMAKE_AR}) # llvm-ar.exe 11.0.0 from winlibs is broken
+	endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+	set(GCC TRUE)
+	set(KYTY_COMPILER GCC)
+	set(KYTY_LINKER LD)
+else()
+	message(FATAL_ERROR "only Clang and GCC are supported; found ${CMAKE_CXX_COMPILER_ID}")
+endif()
+
+set(KYTY_PROJECT_NAME "Emulator" CACHE STRING "Project name suffix")
+
+string(TOLOWER ${KYTY_COMPILER} KYTY_COMPILER_ID)
+string(TOLOWER ${KYTY_LINKER} KYTY_LINKER_ID)
+
+if (CLANG AND (KYTY_LINKER STREQUAL LLD))
+	set(KYTY_LD_OPTIONS "-fuse-ld=lld")
+endif()
+
+if (KYTY_LINKER STREQUAL LD AND NOT LINUX)
+	set(KYTY_LD_OPTIONS "-Wl,--image-base=0x100000000000")
+endif()
+
+project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.2.2)
+
+include_directories(
+	${KYTY_THIRD_PARTY_DIR}/gtest/include
+	${KYTY_THIRD_PARTY_DIR}/gtest
+	${KYTY_THIRD_PARTY_DIR}/fmt/include
+	${KYTY_THIRD_PARTY_DIR}/magic_enum/include/magic_enum
+	${PROJECT_BINARY_DIR}
+	${KYTY_SOURCE_DIR}
+)
+
+set(KYTY_VERSION "${PROJECT_VERSION}")
+
+configure_file(
+  ${KYTY_SOURCE_DIR}/cmake_config.h.in
+  ${PROJECT_BINARY_DIR}/cmake_config.h
+  )
+
+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
+	COMMENT "Generate kytyGitVersion.h"
+)
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
+	list(APPEND KYTY_IWYU
+		kyty_emulator
+		common
+		#launcher
+	)
+	list(APPEND KYTY_CLANG_TIDY
+		kyty_emulator
+		#common
+		launcher
+	)
+endif()
+
+option(KYTY_BUILD_LAUNCHER "Build Qt launcher" ON)
+
+config_compiler_and_linker()
+
+add_subdirectory("${KYTY_THIRD_PARTY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/3rdparty")
+add_subdirectory("${KYTY_SOURCE_DIR}/common" "${CMAKE_CURRENT_BINARY_DIR}/common")
+
+file(GLOB kyty_emulator_src CONFIGURE_DEPENDS
+	"${KYTY_SOURCE_DIR}/libs/*.cpp"
+	"${KYTY_SOURCE_DIR}/libs/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/command_processor/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/command_processor/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/image/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/image/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/pipeline/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/pipeline/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/cfg/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/cfg/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/decompiler/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/decompiler/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/emitter/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/emitter/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/*.h"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/window/*.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/presentation/window/*.h"
+	"${KYTY_SOURCE_DIR}/kernel/*.cpp"
+	"${KYTY_SOURCE_DIR}/kernel/*.h"
+	"${KYTY_SOURCE_DIR}/loader/*.cpp"
+	"${KYTY_SOURCE_DIR}/loader/*.h"
+)
+
+find_program(KYTY_GLSLANG_VALIDATOR glslangValidator REQUIRED)
+set(gpu_tiler_shader_dir "${KYTY_SOURCE_DIR}/graphics/host_gpu/shaders")
+set(gpu_tiler_generated_dir "${PROJECT_BINARY_DIR}/gpu_tiler_shaders")
+set(gpu_tiler_shader_names
+	standard256
+	standard4
+	standard4_3d
+	standard64
+	standard64_3d
+	prt
+	prt_3d
+	render_target
+	depth
+	promote_d16
+	demote_d16
+	swap_bgra16
+)
+file(GLOB gpu_tiler_shader_includes CONFIGURE_DEPENDS "${gpu_tiler_shader_dir}/gpu_tiler_*.inc")
+foreach(shader_name IN LISTS gpu_tiler_shader_names)
+	set(shader_source "${gpu_tiler_shader_dir}/gpu_tiler_${shader_name}.comp")
+	set(shader_spv "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}.spv")
+	set(shader_header "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}_spv.h")
+	string(TOUPPER "GPU_TILER_${shader_name}_SPV" shader_symbol)
+	add_custom_command(
+		OUTPUT "${shader_header}"
+		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
+		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
+		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
+		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+		DEPENDS "${shader_source}" ${gpu_tiler_shader_includes}
+		VERBATIM
+	)
+	list(APPEND gpu_tiler_shader_headers "${shader_header}")
+endforeach()
+list(APPEND kyty_emulator_src ${gpu_tiler_shader_headers})
+
+set(gpu_blit_generated_dir "${PROJECT_BINARY_DIR}/gpu_blit_shaders")
+set(gpu_blit_shader_sources
+	"${gpu_tiler_shader_dir}/gpu_blit_fs_triangle.vert"
+	"${gpu_tiler_shader_dir}/gpu_blit_color_to_ms_depth.frag"
+)
+foreach(shader_source IN LISTS gpu_blit_shader_sources)
+	get_filename_component(shader_name "${shader_source}" NAME_WE)
+	set(shader_spv "${gpu_blit_generated_dir}/${shader_name}.spv")
+	set(shader_header "${gpu_blit_generated_dir}/${shader_name}_spv.h")
+	string(TOUPPER "${shader_name}_SPV" shader_symbol)
+	add_custom_command(
+		OUTPUT "${shader_header}"
+		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_blit_generated_dir}"
+		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
+		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
+		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
+		        -DSYMBOL=${shader_symbol} -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+		DEPENDS "${shader_source}"
+		VERBATIM
+	)
+	list(APPEND gpu_blit_shader_headers "${shader_header}")
+endforeach()
+list(APPEND kyty_emulator_src ${gpu_blit_shader_headers})
+
+list(APPEND kyty_emulator_src
+	"${KYTY_SOURCE_DIR}/emulator.h"
+	"${KYTY_SOURCE_DIR}/emulator.cpp"
+)
+list(REMOVE_DUPLICATES kyty_emulator_src)
+
+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)
+
+# Linux system libraries required by the static FFmpeg archive.
+if(LINUX)
+	find_package(Threads REQUIRED)
+	list(APPEND kyty_emulator_link_libraries m ${CMAKE_DL_LIBS} Threads::Threads)
+
+	# Optional FFmpeg dependencies.
+	find_package(ZLIB)
+	if(ZLIB_FOUND)
+		list(APPEND kyty_emulator_link_libraries ZLIB::ZLIB)
+	endif()
+	find_library(KYTY_BZ2_LIBRARY bz2)
+	if(KYTY_BZ2_LIBRARY)
+		list(APPEND kyty_emulator_link_libraries ${KYTY_BZ2_LIBRARY})
+	endif()
+	find_library(KYTY_LZMA_LIBRARY lzma)
+	if(KYTY_LZMA_LIBRARY)
+		list(APPEND kyty_emulator_link_libraries ${KYTY_LZMA_LIBRARY})
+	endif()
+endif()
+
+set(inc_headers
+	${KYTY_SOURCE_DIR}
+	${KYTY_THIRD_PARTY_DIR}/SDL2/include
+	${KYTY_THIRD_PARTY_DIR}/VulkanMemoryAllocator/include
+	${KYTY_THIRD_PARTY_DIR}/SPIRV-Tools/include
+	${KYTY_THIRD_PARTY_DIR}/fmt/include
+	${KYTY_THIRD_PARTY_DIR}/xxhash
+	${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
+	${KYTY_THIRD_PARTY_DIR}/stb
+)
+
+if (KYTY_CLANG_CL)
+	list(APPEND kyty_emulator_link_libraries winpthread)
+	list(APPEND inc_headers
+		${KYTY_THIRD_PARTY_DIR}/winpthread/include
+	)
+endif()
+
+list(APPEND check_headers
+	${KYTY_SOURCE_DIR}
+)
+
+function(add_kyty_full_emulator_test target source)
+	add_executable(${target} EXCLUDE_FROM_ALL ${source} ${kyty_emulator_src})
+	target_link_libraries(${target} ${kyty_emulator_link_libraries})
+	target_include_directories(${target} PRIVATE ${inc_headers})
+	if (WIN32)
+		target_link_libraries(${target} iphlpapi)
+	endif()
+	if (KYTY_CLANG_CL)
+		target_link_libraries(${target} onecore)
+		add_custom_command(TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:${target}>/libwinpthread-1.dll)
+	endif()
+	# The macOS x86_64 guest address space needs its .zerofill segments anchored
+	# by linker flags, or the kernel kills the binary on load (posix_spawn EIO).
+	configure_macos_guest_address_space(${target})
+endfunction()
+
+function(configure_macos_guest_address_space target)
+	if(APPLE AND (CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64" OR
+			(NOT CMAKE_OSX_ARCHITECTURES AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")))
+		target_sources(${target} PRIVATE "${KYTY_SOURCE_DIR}/kernel/macosGuestAddressSpace.cpp")
+		target_compile_definitions(${target} PRIVATE KYTY_LINKED_GUEST_ADDRESS_SPACE=1)
+		target_link_options(${target} PRIVATE
+			-Wl,-ld_classic,-no_pie,-no_fixup_chains,-no_huge,-pagezero_size,0x40000,-segaddr,SYSTEM_MANAGED,0x40000,-segaddr,SYSTEM_RESERVED,0x7ffffc000,-segaddr,USER_AREA,0x7000000000,-image_base,0x700000000000)
+	endif()
+endfunction()
+
+add_kyty_full_emulator_test(shader_cfg_tests "${KYTY_TESTS_DIR}/shaderCfgTests.cpp")
+
+add_executable(scalar_provenance_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ScalarProvenanceTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ReadLaneElimination.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ScalarProvenance.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtWalker.cpp"
+)
+target_link_libraries(scalar_provenance_tests fmt::fmt)
+target_include_directories(scalar_provenance_tests PRIVATE ${inc_headers})
+
+add_executable(page_manager_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/PageManagerTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
+)
+target_include_directories(page_manager_tests PRIVATE ${inc_headers})
+
+add_executable(bit_array_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/BitArrayTests.cpp"
+)
+target_include_directories(bit_array_tests PRIVATE ${inc_headers})
+
+add_executable(memory_tracker_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/MemoryTrackerTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/memoryTracker.cpp"
+)
+target_link_libraries(memory_tracker_tests fmt::fmt common)
+target_include_directories(memory_tracker_tests PRIVATE ${inc_headers})
+
+add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ShaderVertexMetadataTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/shaderVertexMetadata.cpp"
+)
+target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})
+
+add_executable(shader_stage_runtime_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ShaderStageRuntimeTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/shaderStageRuntime.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ResourceMaterialization.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ScalarProvenance.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtWalker.cpp"
+)
+target_link_libraries(shader_stage_runtime_tests fmt::fmt)
+target_include_directories(shader_stage_runtime_tests PRIVATE ${inc_headers})
+
+add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ResourceTrackingTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/guest_gpu/gpu_format.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/hostMemory.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ScalarProvenance.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtWalker.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/SrtPatcher.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ResourceTracking.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ResourceMaterialization.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/ShaderInfoCollection.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/shader/recompiler/ir/BindingLayout.cpp"
+)
+target_link_libraries(resource_tracking_tests fmt::fmt)
+target_include_directories(resource_tracking_tests PRIVATE ${inc_headers})
+
+add_executable(resource_mutex_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ResourceMutexTests.cpp"
+	"${KYTY_SOURCE_DIR}/graphics/host_gpu/renderer/cache/resourceMutex.cpp"
+)
+target_link_libraries(resource_mutex_tests common)
+target_include_directories(resource_mutex_tests PRIVATE ${inc_headers})
+
+add_executable(audio_out2_port_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/AudioOut2PortTests.cpp"
+	"${KYTY_SOURCE_DIR}/libs/libAudio2.cpp"
+	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+)
+target_link_libraries(audio_out2_port_tests common fmt::fmt)
+target_include_directories(audio_out2_port_tests PRIVATE ${inc_headers})
+
+add_executable(event_queue_lifetime_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/EventQueueLifetimeTests.cpp"
+	"${KYTY_SOURCE_DIR}/kernel/eventQueue.cpp"
+	"${KYTY_SOURCE_DIR}/loader/timer.cpp"
+)
+target_link_libraries(event_queue_lifetime_tests common fmt::fmt)
+target_include_directories(event_queue_lifetime_tests PRIVATE ${inc_headers})
+
+add_executable(image_page_table_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ImagePageTableTests.cpp"
+)
+target_link_libraries(image_page_table_tests common fmt::fmt)
+target_include_directories(image_page_table_tests PRIVATE ${inc_headers})
+
+add_kyty_full_emulator_test(shader_recompiler_compute_tests "${KYTY_TESTS_DIR}/ShaderRecompilerComputeTests.cpp")
+
+set(gpu_test_generated_dir "${PROJECT_BINARY_DIR}/gpu_test_shaders")
+set(gpu_test_ms_depth_source
+	"${gpu_tiler_shader_dir}/gpu_test_ms_depth.comp")
+set(gpu_test_ms_depth_spv
+	"${gpu_test_generated_dir}/gpu_test_ms_depth.spv")
+set(gpu_test_ms_depth_header
+	"${gpu_test_generated_dir}/gpu_test_ms_depth_spv.h")
+add_custom_command(
+	OUTPUT "${gpu_test_ms_depth_header}"
+	COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_test_generated_dir}"
+	COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
+	        -o "${gpu_test_ms_depth_spv}" "${gpu_test_ms_depth_source}"
+	COMMAND ${CMAKE_COMMAND} -DINPUT=${gpu_test_ms_depth_spv}
+	        -DOUTPUT=${gpu_test_ms_depth_header} -DSYMBOL=GPU_TEST_MS_DEPTH_SPV
+	        -P "${KYTY_SOURCE_DIR}/embed_spirv.cmake"
+	DEPENDS "${gpu_test_ms_depth_source}"
+	VERBATIM
+)
+target_sources(shader_recompiler_compute_tests PRIVATE
+	"${gpu_test_ms_depth_header}")
+
+add_kyty_full_emulator_test(virtual_memory_allocation_tests "${KYTY_TESTS_DIR}/VirtualMemoryAllocationTests.cpp")
+target_compile_definitions(virtual_memory_allocation_tests PRIVATE
+	KYTY_VIRTUAL_MEMORY_ALLOCATION_TESTS=1)
+
+# These tests use exceptions.
+if(NOT KYTY_CLANG_CL)
+	foreach(kyty_exception_test scalar_provenance_tests resource_tracking_tests
+			virtual_memory_allocation_tests)
+		target_compile_options(${kyty_exception_test} PRIVATE -fexceptions)
+	endforeach()
+endif()
+
+if(BUILD_TESTING)
+	add_test(NAME shader_cfg COMMAND $<TARGET_FILE:shader_cfg_tests>)
+	add_test(NAME scalar_provenance COMMAND $<TARGET_FILE:scalar_provenance_tests>)
+	add_test(NAME image_page_table COMMAND $<TARGET_FILE:image_page_table_tests>)
+	add_test(NAME memory_tracker COMMAND $<TARGET_FILE:memory_tracker_tests>)
+	add_test(NAME page_manager COMMAND $<TARGET_FILE:page_manager_tests>)
+	add_test(NAME bit_array COMMAND $<TARGET_FILE:bit_array_tests>)
+	add_test(NAME shader_vertex_metadata COMMAND $<TARGET_FILE:shader_vertex_metadata_tests>)
+	add_test(NAME shader_stage_runtime COMMAND $<TARGET_FILE:shader_stage_runtime_tests>)
+	add_test(NAME resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
+	add_test(NAME resource_mutex COMMAND $<TARGET_FILE:resource_mutex_tests>)
+	add_test(NAME event_queue_lifetime COMMAND $<TARGET_FILE:event_queue_lifetime_tests>)
+	add_test(NAME audio_out2_port COMMAND $<TARGET_FILE:audio_out2_port_tests>)
+	add_test(NAME shader_recompiler_compute COMMAND $<TARGET_FILE:shader_recompiler_compute_tests>)
+	add_test(NAME virtual_memory_allocation
+		COMMAND $<TARGET_FILE:virtual_memory_allocation_tests>)
+	add_test(NAME command_scheduler_timeline
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --scheduler-only)
+	add_test(NAME stream_buffer_ring
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --stream-buffer-only)
+	add_test(NAME gpu_command_lane
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-command-lane-only)
+	add_test(NAME gpu_tiler
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-tiler-only)
+
+	add_test(NAME texture_cache_layered_image
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --layered-image-only)
+	add_test(NAME texture_cache_image_views
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-view-cache-only)
+	add_test(NAME texture_cache_storage_sampled
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --storage-sampled-only)
+	add_test(NAME texture_cache_depth_readback
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --depth-readback-only)
+	add_test(NAME buffer_cache_dirty_gc
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-gc-only)
+
+	if(WIN32)
+		# These tests still depend on the Windows multisample-depth path.
+		add_test(NAME texture_cache_image_overlap
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --image-overlap-only)
+		add_test(NAME texture_cache_htile_clear
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --htile-clear-only)
+		add_test(NAME buffer_cache_ranges
+			COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --buffer-cache-range-only)
+	endif()
+
+	add_custom_target(kyty_tests DEPENDS
+		shader_cfg_tests
+		scalar_provenance_tests
+		image_page_table_tests
+		memory_tracker_tests
+		page_manager_tests
+		bit_array_tests
+		shader_vertex_metadata_tests
+		shader_stage_runtime_tests
+		resource_tracking_tests
+		resource_mutex_tests
+		event_queue_lifetime_tests
+		shader_recompiler_compute_tests
+		virtual_memory_allocation_tests
+	)
+endif()
+
+
+add_executable(kyty_emulator "${KYTY_SOURCE_DIR}/main.cpp" ${kyty_emulator_src})
+configure_macos_guest_address_space(kyty_emulator)
+
+target_link_libraries(kyty_emulator ${kyty_emulator_link_libraries})
+if (WIN32)
+	target_link_libraries(kyty_emulator opengl32)
+	target_link_libraries(kyty_emulator iphlpapi)
+	target_link_libraries(kyty_emulator setupapi)
+	target_link_libraries(kyty_emulator ws2_32)
+endif()
+if (KYTY_CLANG_CL)
+	target_link_libraries(kyty_emulator onecore)
+endif()
+if (CLANG AND NOT KYTY_CLANG_CL)
+	target_link_libraries(kyty_emulator pthread)
+endif()
+# dlopen/dlsym/dladdr for RenderDoc.
+target_link_libraries(kyty_emulator ${CMAKE_DL_LIBS})
+target_include_directories(kyty_emulator PRIVATE ${inc_headers})
+
+clang_tidy_check(kyty_emulator "" "${check_headers}" "${inc_headers}")
+
+include_what_you_use(kyty_emulator "${inc_headers}")
+
+set(KYTY_EMULATOR_MAP_NAME "kyty_emulator_${KYTY_COMPILER_ID}_${KYTY_LINKER_ID}.map")
+
+set(KYTY_EMULATOR_MAP_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/${KYTY_EMULATOR_MAP_NAME}")
+set(KYTY_EMULATOR_PDB_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/kyty_emulator.pdb")
+
+if(KYTY_CLANG_CL)
+	target_link_options(kyty_emulator PRIVATE
+		"/DYNAMICBASE:NO"
+		"/DEBUG:FULL"
+		"/PDB:${KYTY_EMULATOR_PDB_LINK_PATH}"
+		"/lldmap:${KYTY_EMULATOR_MAP_LINK_PATH}"
+	)
+	add_custom_command(TARGET kyty_emulator POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:kyty_emulator>/libwinpthread-1.dll)
+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
+	# entitlements, so re-sign the binary after every link (an unsigned/relinked binary
+	# reverts to the hardened defaults and aborts when it first executes written code).
+	add_custom_command(TARGET kyty_emulator POST_BUILD
+		COMMAND codesign -s - --force --options runtime
+			--entitlements "${KYTY_SOURCE_DIR}/macos_jit.entitlements"
+			$<TARGET_FILE:kyty_emulator>
+		COMMENT "Codesign kyty_emulator with JIT entitlements (macOS)")
+endif()
+
+install(TARGETS kyty_emulator DESTINATION .)
+if(KYTY_BUILD_LAUNCHER)
+	add_subdirectory("${KYTY_SOURCE_DIR}/launcher" "${CMAKE_CURRENT_BINARY_DIR}/launcher")
+endif()
+if(KYTY_CLANG_CL)
+	install(FILES "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" DESTINATION .)
+endif()

README.md

@@ -1,13 +1,16 @@
 # KytyPS5
 
-[![Platform](https://img.shields.io/badge/platform-Windows%20x64-0078D4.svg)](#system-requirements)
+[![Build KytyPS5 (Windows)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28Windows%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (Linux)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28Linux%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Build KytyPS5 (macOS)](https://img.shields.io/github/actions/workflow/status/KytyPS5/KytyPS5/build.yml?branch=main&event=push&label=Build%20KytyPS5%20%28macOS%29)](https://github.com/KytyPS5/KytyPS5/actions/workflows/build.yml)
+[![Platform](https://img.shields.io/badge/platform-Windows%20x64%20%7C%20Linux%20x64%20%7C%20macOS%20x86__64-0078D4.svg)](#system-requirements)
 [![Status](https://img.shields.io/badge/status-early%20development-orange.svg)](#current-status)
 [![License](https://img.shields.io/badge/license-GPL--2.0-blue.svg)](LICENSE)
 
-KytyPS5 is a free and open-source PlayStation 5 emulator written in C++ for Windows. It is based on
+KytyPS5 is a free and open-source PlayStation 5 emulator written in C++ for Windows and Linux,
-a heavily modified version of [Kyty](https://github.com/InoriRus/Kyty). The project is in an early
+with experimental macOS support. It is based on a heavily modified version of
-stage of development, so compatibility is limited and behavior may change significantly between
+[Kyty](https://github.com/InoriRus/Kyty). The project is in an early stage of development, so
-builds.
+compatibility is limited and behavior may change significantly between builds.
 
 > [!IMPORTANT]
 > KytyPS5 is not affiliated with Sony Interactive Entertainment or PlayStation. The project does
@@ -21,7 +24,12 @@ KytyPS5 can boot 2D games and a selection of 3D games, including titles built wi
 
 Development is focused on compatibility and boot reliability.
 
-Linux support is planned, but Windows is the only supported platform at this time.
+Windows is the primary platform and receives the most testing. Linux builds and runs; see
+[Building on Linux](#building-on-linux).
+
+macOS support is experimental. The emulator is built for x86-64 and runs on Apple Silicon under
+Rosetta 2, with Vulkan provided by MoltenVK. A small number of titles have been verified in-game
+on Apple Silicon hardware; see [Building on macOS](#building-on-macos).
 
 ## Bugs and Issues
 
@@ -43,7 +51,7 @@ graphical glitches, low compatibility, and poor performance.
   </tr>
   <tr>
     <td align="center">
-      <strong>Minecraft Legends</strong><br>
+      <strong>Neptunia ReVerse</strong><br>
       <img src="docs/screenshots/ps5-04.png" width="300" alt="Minecraft Legends running in KytyPS5">
     </td>
     <td align="center">
@@ -51,15 +59,28 @@ graphical glitches, low compatibility, and poor performance.
       <img src="docs/screenshots/ps5-05.png" width="300" alt="SILENT HILL: The Short Message running in KytyPS5">
     </td>
   </tr>
+  <tr>
+    <td align="center">
+      <strong>Hellboy</strong><br>
+      <img src="docs/screenshots/ps5-02.png" width="300" alt="Disgaea 6 running in KytyPS5">
+    </td>
+    <td align="center">
+      <strong>Paleo Pines</strong><br>
+      <img src="docs/screenshots/ps5-06.png" width="300" alt="Dreaming Sarah running in KytyPS5">
+    </td>
+  </tr>
 </table>
 
+<p align="center"><em>And many more...</em></p>
+
 ## Contributing
 
 Testing games and submitting detailed bug reports are useful ways to contribute. Search existing
 issues first, then use the **Game Emulation Bug Report** template and attach the complete log file.
 
-Code contributions should be focused, build successfully on Windows, and include relevant tests
+Code contributions should be focused, build successfully on the platforms they touch, and include
-where practical. Because KytyPS5 is still evolving quickly, consider opening an issue before
+relevant tests where practical. Windows is the primary target, so a change that alters shared code
+should not regress it; changes confined to a platform's own code paths only need to build there. Because KytyPS5 is still evolving quickly, consider opening an issue before
 starting a large change.
 
 ### Formatting
@@ -94,11 +115,12 @@ the Vulkan/SPIR-V validation rules.
 
 ### System requirements
 
-- Windows 10 version 1803
+- Windows 10 version 1803, a current Linux distribution, or macOS on Apple Silicon
-- A 64-bit x86 processor
+- A 64-bit x86 processor (on macOS, an Apple Silicon processor with Rosetta 2)
-- A Vulkan 1.3-capable GPU with current drivers
+- A Vulkan 1.3-capable GPU with current drivers (on macOS, Vulkan is provided by the bundled
+  MoltenVK)
 
-### Build requirements
+### Build requirements (Windows)
 
 - Git
 - CMake 3.12 or newer
@@ -119,7 +141,7 @@ git submodule update --init --recursive
 Configure the project. Replace the Qt path with the version installed on your system:
 
 ```powershell
-cmake -S src -B _Build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_PREFIX_PATH="C:/Qt/6.x.x/msvc2022_64"
+cmake -S . -B _Build/windows -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_PREFIX_PATH="C:/Qt/6.x.x/msvc2022_64"
 ```
 
 Build the launcher and stage a runnable installation:
@@ -132,11 +154,98 @@ cmake --install _Build/windows --prefix _Build/windows/install
 The finished application and its runtime dependencies will be placed in
 `_Build/windows/install`.
 
+### Building on Linux
+
+Install the toolchain and the libraries the bundled SDL2 needs. Without the audio, Wayland and
+udev development packages SDL2 quietly configures itself without those backends, and the resulting
+build has no working sound and no gamepad hotplug:
+
+```bash
+sudo apt-get install --no-install-recommends \
+  clang lld ninja-build cmake git glslang-tools \
+  libgl1-mesa-dev libx11-dev libxcursor-dev libxext-dev libxfixes-dev \
+  libxi-dev libxrandr-dev libxss-dev libxkbcommon-dev \
+  libasound2-dev libpulse-dev libudev-dev libdbus-1-dev libwayland-dev wayland-protocols
+```
+
+Qt 6 (Concurrent, Network, Widgets) is also required — either the distribution packages
+(`qt6-base-dev`) or an official Qt installation.
+
+```bash
+git submodule update --init --recursive
+
+cmake -S . -B _Build/linux -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
+  -DCMAKE_PREFIX_PATH="$Qt6_DIR"
+
+cmake --build _Build/linux --target launcher --parallel
+cmake --install _Build/linux --prefix _Build/linux/install
+```
+
+The install step copies the Qt libraries and plugins next to the binaries, so
+`_Build/linux/install` runs without a matching system Qt.
+
+As on Windows, the MSVC compiler is not used; Clang is required. `cl.exe` is rejected at configure
+time.
+
+The CMake source root is the repository root.
+
+### Building on macOS
+
+macOS builds target x86-64 and run under Rosetta 2 on Apple Silicon, so the PS5's x86-64 game
+code executes through the same translation layer as the emulator itself. Prebuilt archives are
+attached to releases; the steps below are for building from source.
+
+Requirements:
+
+- An Apple Silicon Mac with Rosetta 2 installed (`softwareupdate --install-rosetta`)
+- Xcode (or the Command Line Tools)
+- Homebrew packages: `brew install cmake ninja glslang`
+- Qt 6 (Concurrent, Network, Widgets) with x86-64 support. The official Qt installation is
+  universal and works; Homebrew's Qt is arm64-only and will not link
+
+```bash
+git submodule update --init --recursive
+
+cmake -S . -B _Build/macos -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_OSX_ARCHITECTURES=x86_64 \
+  -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ \
+  -DCMAKE_PREFIX_PATH="$Qt6_DIR"
+
+cmake --build _Build/macos --target launcher --parallel
+cmake --install _Build/macos --prefix _Build/macos/install
+```
+
+The build re-signs `kyty_emulator` with the JIT entitlements it needs to execute translated
+guest code; no manual signing step is required.
+
+Vulkan comes from MoltenVK. Download `MoltenVK-macos.tar` from the
+[MoltenVK releases](https://github.com/KhronosGroup/MoltenVK/releases), then copy
+`MoltenVK/dynamic/dylib/macOS/libMoltenVK.dylib` next to `kyty_emulator` and ad-hoc sign it:
+
+```bash
+codesign --force --sign - _Build/macos/install/libMoltenVK.dylib
+```
+
+Release archives already include a signed `libMoltenVK.dylib`.
+
+### Regression tests
+
+Build every regression executable and run the registered tests with:
+
+```powershell
+cmake --build _Build/windows --target kyty_tests
+ctest --test-dir _Build/windows --output-on-failure
+```
+
+Use `_Build/linux` instead of `_Build/windows` for a Linux build.
+
 ### Visual Studio Code
 
 A ready-made Visual Studio Code setup is included in [`.vscode`](.vscode). It configures CMake
 Tools to build the project with Ninja and `clang-cl` and provides launch profiles for both
-`launcher.exe` and `kyty_emulator.exe`.
+`launcher.exe` and `kyty_emulator.exe`. It is Windows-only: VS Code settings cannot select a
+compiler per platform, so on Linux configure from the command line as shown above.
 
 Before using it:
 
@@ -158,6 +267,10 @@ To use the graphical launcher:
 .\_Build\windows\install\launcher.exe
 ```
 
+```bash
+./_Build/linux/install/launcher
+```
+
 On first launch, add one or more game folders in the global settings. The launcher searches those
 folders recursively for game directories containing `eboot.bin`. Select a detected game and run it
 from the game list.
@@ -168,7 +281,19 @@ The emulator can also be started directly with a legally obtained game directory
 .\_Build\windows\install\kyty_emulator.exe --game "D:\Games\ExampleGame"
 ```
 
-Run `kyty_emulator.exe --help` to see the available graphics, logging, validation, profiling, and
+```bash
+./_Build/linux/install/kyty_emulator --game "/games/ExampleGame"
+```
+
+On macOS, point SDL at the MoltenVK library explicitly; the hardened runtime prevents it from
+being picked up from the executable's directory:
+
+```bash
+cd _Build/macos/install
+SDL_VULKAN_LIBRARY="$PWD/libMoltenVK.dylib" ./kyty_emulator --game "/games/ExampleGame"
+```
+
+Run `kyty_emulator --help` to see the available graphics, logging, validation, profiling, and
 debugging options.
 
 ### AI Use

src/CMakeLists.txt

@@ -1,374 +0,0 @@
-cmake_minimum_required(VERSION 3.12...4.3)
-
-if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
-	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
-endif()
-
-project(Kyty)
-
-if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")
-	set(LINUX TRUE)
-endif()
-
-if (NOT (WIN32 OR LINUX))
-    message(FATAL_ERROR "only Windows and Linux builds are supported")
-endif()
-
-set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-include(utils.cmake)
-
-set(KYTY_THIRD_PARTY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty")
-
-set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
-
-include(TestBigEndian)
-
-if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-	message(FATAL_ERROR "only 64-bit builds are supported")
-endif()
-
-test_big_endian(BIG_ENDIAN)
-if(BIG_ENDIAN)
-	set(KYTY_ENDIAN KYTY_ENDIAN_BIG)
-else()
-	set(KYTY_ENDIAN KYTY_ENDIAN_LITTLE)
-endif()
-
-if(CMAKE_BUILD_TYPE MATCHES Debug)
-	set(KYTY_BUILD KYTY_BUILD_DEBUG)
-else()
-	set(KYTY_BUILD KYTY_BUILD_RELEASE)
-endif()
-
-if(LINUX)
-	set(KYTY_PLATFORM KYTY_PLATFORM_LINUX)	
-else()
-	set(KYTY_PLATFORM KYTY_PLATFORM_WINDOWS)
-endif()
-
-set(CLANG FALSE)
-set(GCC FALSE)
-set(KYTY_CLANG_CL FALSE)
-get_filename_component(KYTY_CXX_COMPILER_NAME "${CMAKE_CXX_COMPILER}" NAME_WE)
-string(TOLOWER "${KYTY_CXX_COMPILER_NAME}" KYTY_CXX_COMPILER_NAME)
-
-if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
-	set(CLANG TRUE)
-	set(KYTY_COMPILER CLANG)
-	if(WIN32 AND KYTY_CXX_COMPILER_NAME STREQUAL "clang-cl")
-		set(KYTY_CLANG_CL TRUE)
-		set(KYTY_LINKER LLD_LINK)
-	else()
-		set(KYTY_LINKER LLD)
-	endif()
-	if ((CMAKE_AR MATCHES "llvm") AND (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0.0) AND (CMAKE_CXX_COMPILER MATCHES "winlibs"))
-		string(REPLACE "llvm-ar.exe" "ar.exe" CMAKE_AR ${CMAKE_AR}) # llvm-ar.exe 11.0.0 from winlibs is broken
-	endif()
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-	set(GCC TRUE)
-	set(KYTY_COMPILER GCC)
-	set(KYTY_LINKER LD)
-else()
-	message(FATAL_ERROR "only Clang and GCC are supported; found ${CMAKE_CXX_COMPILER_ID}")
-endif()
-
-set(KYTY_PROJECT_NAME "Emulator" CACHE STRING "Project name suffix")
-
-string(TOLOWER ${KYTY_COMPILER} KYTY_COMPILER_ID)
-string(TOLOWER ${KYTY_LINKER} KYTY_LINKER_ID)
-
-if (CLANG AND (KYTY_LINKER STREQUAL LLD))
-	set(KYTY_LD_OPTIONS "-fuse-ld=lld")
-endif()
-
-if (KYTY_LINKER STREQUAL LD AND NOT LINUX)
-	set(KYTY_LD_OPTIONS "-Wl,--image-base=0x100000000000")
-endif()
-
-project(Kyty${KYTY_PROJECT_NAME}${CMAKE_BUILD_TYPE}${KYTY_COMPILER} VERSION 0.2.2)
-
-include_directories(	
-	${KYTY_THIRD_PARTY_DIR}/gtest/include
-	${KYTY_THIRD_PARTY_DIR}/gtest
-	${KYTY_THIRD_PARTY_DIR}/fmt/include
-	${KYTY_THIRD_PARTY_DIR}/magic_enum/include/magic_enum
-	${PROJECT_BINARY_DIR}
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-set(KYTY_VERSION "${PROJECT_VERSION}")
-
-configure_file(
-  ${PROJECT_SOURCE_DIR}/cmake_config.h.in
-  ${PROJECT_BINARY_DIR}/cmake_config.h
-  )
-
-find_package(Git)
-  
-add_custom_target( KytyGitVersion
-    COMMAND ${CMAKE_COMMAND} 
-	-D INPUT_FILE=${CMAKE_CURRENT_SOURCE_DIR}/kytyGitVersion.h.in
-    -D OUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/kytyGitVersion.h
-	-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
-	-P ${CMAKE_CURRENT_SOURCE_DIR}/generate_version.cmake
-	COMMENT "Generate kytyGitVersion.h"
-)
-
-if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
-	list(APPEND KYTY_IWYU 
-		kyty_emulator
-		common
-		#launcher
-	)
-	list(APPEND KYTY_CLANG_TYDY 
-		kyty_emulator
-		#common
-		launcher
-	)
-endif()
-
-option(KYTY_BUILD_LAUNCHER "Build Qt launcher" ON)
-  
-config_compiler_and_linker()  
-  
-add_subdirectory("${KYTY_THIRD_PARTY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}/3rdparty")
-add_subdirectory(common)
-
-file(GLOB kyty_emulator_src CONFIGURE_DEPENDS
-	libs/*.cpp
-	libs/*.h
-	graphics/*.cpp
-	graphics/*.h
-	graphics/guest_gpu/*.cpp
-	graphics/guest_gpu/*.h
-	graphics/guest_gpu/command_processor/*.cpp
-	graphics/guest_gpu/command_processor/*.h
-	graphics/host_gpu/*.cpp
-	graphics/host_gpu/*.h
-	graphics/host_gpu/renderer/*.cpp
-	graphics/host_gpu/renderer/*.h
-	graphics/shader/*.cpp
-	graphics/shader/*.h
-	graphics/shader/recompiler/*.cpp
-	graphics/shader/recompiler/*.h
-	graphics/shader/recompiler/shaderIR/*.cpp
-	graphics/shader/recompiler/shaderIR/*.h
-	graphics/shader/recompiler/spirvEmitter/*.cpp
-	graphics/shader/recompiler/spirvEmitter/*.h
-	graphics/host_gpu/objects/*.cpp
-	graphics/host_gpu/objects/*.h
-	graphics/presentation/*.cpp
-	graphics/presentation/*.h
-	graphics/presentation/window/*.cpp
-	graphics/presentation/window/*.h
-	kernel/*.cpp
-	kernel/*.h
-	loader/*.cpp
-	loader/*.h
-)
-
-find_program(KYTY_GLSLANG_VALIDATOR glslangValidator REQUIRED)
-set(gpu_tiler_shader_dir "${CMAKE_CURRENT_SOURCE_DIR}/graphics/host_gpu/shaders")
-set(gpu_tiler_generated_dir "${PROJECT_BINARY_DIR}/gpu_tiler_shaders")
-set(gpu_tiler_shader_names
-	standard256
-	standard4
-	standard4_3d
-	standard64
-	standard64_3d
-	prt
-	prt_3d
-	render_target
-	depth
-)
-file(GLOB gpu_tiler_shader_includes CONFIGURE_DEPENDS "${gpu_tiler_shader_dir}/gpu_tiler_*.inc")
-foreach(shader_name IN LISTS gpu_tiler_shader_names)
-	set(shader_source "${gpu_tiler_shader_dir}/gpu_tiler_${shader_name}.comp")
-	set(shader_spv "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}.spv")
-	set(shader_header "${gpu_tiler_generated_dir}/gpu_tiler_${shader_name}_spv.h")
-	string(TOUPPER "GPU_TILER_${shader_name}_SPV" shader_symbol)
-	add_custom_command(
-		OUTPUT "${shader_header}"
-		COMMAND ${CMAKE_COMMAND} -E make_directory "${gpu_tiler_generated_dir}"
-		COMMAND "${KYTY_GLSLANG_VALIDATOR}" -V --target-env vulkan1.0 -Os
-		        "-I${gpu_tiler_shader_dir}" -o "${shader_spv}" "${shader_source}"
-		COMMAND ${CMAKE_COMMAND} -DINPUT=${shader_spv} -DOUTPUT=${shader_header}
-		        -DSYMBOL=${shader_symbol} -P "${CMAKE_CURRENT_SOURCE_DIR}/embed_spirv.cmake"
-		DEPENDS "${shader_source}" ${gpu_tiler_shader_includes}
-		VERBATIM
-	)
-	list(APPEND gpu_tiler_shader_headers "${shader_header}")
-endforeach()
-list(APPEND kyty_emulator_src ${gpu_tiler_shader_headers})
-
-list(APPEND kyty_emulator_src
-	emulator.h
-	emulator.cpp
-)
-list(REMOVE_DUPLICATES kyty_emulator_src)
-
-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)
-
-set(inc_headers
-	${CMAKE_CURRENT_SOURCE_DIR}
-	${KYTY_THIRD_PARTY_DIR}/SDL2/include
-	${KYTY_THIRD_PARTY_DIR}/VulkanMemoryAllocator/include
-	${KYTY_THIRD_PARTY_DIR}/SPIRV-Tools/include
-	${KYTY_THIRD_PARTY_DIR}/fmt/include
-	${KYTY_THIRD_PARTY_DIR}/xxhash
-	${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
-	${KYTY_THIRD_PARTY_DIR}/stb
-)
-
-if (KYTY_CLANG_CL)
-	list(APPEND kyty_emulator_link_libraries winpthread)
-	list(APPEND inc_headers 
-		${KYTY_THIRD_PARTY_DIR}/winpthread/include
-	)
-endif()
-
-list(APPEND check_headers
-	${CMAKE_CURRENT_SOURCE_DIR}
-)
-
-function(add_kyty_full_emulator_test target source)
-	add_executable(${target} EXCLUDE_FROM_ALL ${source} ${kyty_emulator_src})
-	target_link_libraries(${target} ${kyty_emulator_link_libraries})
-	target_include_directories(${target} PRIVATE ${inc_headers})
-	if (WIN32)
-		target_link_libraries(${target} iphlpapi)
-	endif()
-	if (KYTY_CLANG_CL)
-		target_link_libraries(${target} onecore)
-		add_custom_command(TARGET ${target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:${target}>/libwinpthread-1.dll)
-	endif()
-endfunction()
-
-add_kyty_full_emulator_test(shader_cfg_tests ../tests/shaderCfgTests.cpp)
-
-add_executable(scalar_provenance_tests EXCLUDE_FROM_ALL
-	../tests/ScalarProvenanceTests.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/recompiler/ScalarProvenance.cpp
-	graphics/shader/recompiler/SrtWalker.cpp
-)
-target_link_libraries(scalar_provenance_tests fmt::fmt)
-target_include_directories(scalar_provenance_tests PRIVATE ${inc_headers})
-
-add_executable(page_manager_tests EXCLUDE_FROM_ALL
-	../tests/PageManagerTests.cpp
-	graphics/host_gpu/pageManager.cpp
-)
-target_include_directories(page_manager_tests PRIVATE ${inc_headers})
-
-add_executable(memory_tracker_tests EXCLUDE_FROM_ALL
-	../tests/MemoryTrackerTests.cpp
-	graphics/host_gpu/pageManager.cpp
-	graphics/host_gpu/memoryTracker.cpp
-)
-target_link_libraries(memory_tracker_tests fmt::fmt common)
-target_include_directories(memory_tracker_tests PRIVATE ${inc_headers})
-target_compile_definitions(memory_tracker_tests PRIVATE KYTY_MEMORY_TRACKER_TESTS=1)
-
-add_executable(shader_vertex_metadata_tests EXCLUDE_FROM_ALL
-	../tests/ShaderVertexMetadataTests.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/shaderVertexMetadata.cpp
-)
-target_include_directories(shader_vertex_metadata_tests PRIVATE ${inc_headers})
-
-add_executable(shader_stage_runtime_tests EXCLUDE_FROM_ALL
-	../tests/ShaderStageRuntimeTests.cpp
-	graphics/guest_gpu/gpu_format.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/shaderStageRuntime.cpp
-	graphics/shader/recompiler/ResourceMaterialization.cpp
-	graphics/shader/recompiler/ScalarProvenance.cpp
-	graphics/shader/recompiler/SrtWalker.cpp
-)
-target_link_libraries(shader_stage_runtime_tests fmt::fmt)
-target_include_directories(shader_stage_runtime_tests PRIVATE ${inc_headers})
-
-add_executable(resource_tracking_tests EXCLUDE_FROM_ALL
-	../tests/ResourceTrackingTests.cpp
-	graphics/guest_gpu/gpu_format.cpp
-	graphics/host_gpu/hostMemory.cpp
-	graphics/shader/recompiler/ScalarProvenance.cpp
-	graphics/shader/recompiler/SrtWalker.cpp
-	graphics/shader/recompiler/SrtPatcher.cpp
-	graphics/shader/recompiler/ResourceTracking.cpp
-	graphics/shader/recompiler/ResourceMaterialization.cpp
-	graphics/shader/recompiler/ShaderInfoCollection.cpp
-	graphics/shader/recompiler/BindingLayout.cpp
-)
-target_link_libraries(resource_tracking_tests fmt::fmt)
-target_include_directories(resource_tracking_tests PRIVATE ${inc_headers})
-
-add_executable(resource_mutex_tests EXCLUDE_FROM_ALL
-	../tests/ResourceMutexTests.cpp
-	graphics/host_gpu/renderer/resourceMutex.cpp
-)
-target_link_libraries(resource_mutex_tests common)
-target_include_directories(resource_mutex_tests PRIVATE ${inc_headers})
-
-add_executable(image_page_table_tests EXCLUDE_FROM_ALL
-	../tests/ImagePageTableTests.cpp
-)
-target_include_directories(image_page_table_tests PRIVATE ${inc_headers})
-
-add_kyty_full_emulator_test(shader_recompiler_compute_tests ../tests/ShaderRecompilerComputeTests.cpp)
-
-add_kyty_full_emulator_test(virtual_memory_allocation_tests ../tests/VirtualMemoryAllocationTests.cpp)
-target_compile_definitions(virtual_memory_allocation_tests PRIVATE
-	KYTY_VIRTUAL_MEMORY_ALLOCATION_TESTS=1)
-
-
-add_executable(kyty_emulator main.cpp ${kyty_emulator_src})
-
-target_link_libraries(kyty_emulator ${kyty_emulator_link_libraries})
-if (WIN32)
-	target_link_libraries(kyty_emulator opengl32)
-	target_link_libraries(kyty_emulator iphlpapi)
-	target_link_libraries(kyty_emulator setupapi)
-	target_link_libraries(kyty_emulator ws2_32)
-endif()
-if (KYTY_CLANG_CL)
-	target_link_libraries(kyty_emulator onecore)
-endif()
-if (CLANG AND NOT KYTY_CLANG_CL)
-	target_link_libraries(kyty_emulator pthread)
-endif()
-target_include_directories(kyty_emulator PRIVATE ${inc_headers})
-
-clang_tidy_check(kyty_emulator "" "${check_headers}" "${inc_headers}")
-
-include_what_you_use(kyty_emulator "${inc_headers}")
-
-set(KYTY_EMULATOR_MAP_NAME "kyty_emulator_${KYTY_COMPILER_ID}_${KYTY_LINKER_ID}.map")
-
-set(KYTY_EMULATOR_MAP_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/${KYTY_EMULATOR_MAP_NAME}")
-set(KYTY_EMULATOR_PDB_LINK_PATH "${CMAKE_CURRENT_BINARY_DIR}/kyty_emulator.pdb")
-
-if(KYTY_CLANG_CL)
-	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "/DYNAMICBASE:NO /DEBUG:FULL /PDB:${KYTY_EMULATOR_PDB_LINK_PATH} /lldmap:${KYTY_EMULATOR_MAP_LINK_PATH}")
-	add_custom_command(TARGET kyty_emulator POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" $<TARGET_FILE_DIR:kyty_emulator>/libwinpthread-1.dll)
-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)
-
-install(TARGETS kyty_emulator DESTINATION .)
-if(KYTY_BUILD_LAUNCHER)
-	add_subdirectory(launcher)
-endif()
-if(KYTY_CLANG_CL)
-	install(FILES "${KYTY_THIRD_PARTY_DIR}/winpthread/bin/libwinpthread-1.dll" DESTINATION .)
-endif()

src/common/CMakeLists.txt

@@ -13,7 +13,7 @@ endif()
 add_library(common STATIC ${common_src} ${common_headers})
 
 target_include_directories(common
-	PUBLIC ${PROJECT_SOURCE_DIR}
+	PUBLIC ${KYTY_SOURCE_DIR}
 	PRIVATE
 		${KYTY_THIRD_PARTY_DIR}/cpuinfo/include
 )

src/common/bitArray.h

@@ -0,0 +1,260 @@
+#ifndef EMULATOR_SRC_COMMON_BITARRAY_H_
+#define EMULATOR_SRC_COMMON_BITARRAY_H_
+
+#include <array>
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <utility>
+
+namespace Common {
+
+template <size_t N>
+class BitArray final {
+	static_assert(N != 0, "BitArray size must be nonzero");
+	static_assert(N % 64 == 0, "BitArray size must be a multiple of 64 bits");
+
+	static constexpr size_t BITS_PER_WORD = 64;
+	static constexpr size_t WORD_COUNT    = N / BITS_PER_WORD;
+
+public:
+	using Range = std::pair<size_t, size_t>;
+
+	class Iterator final {
+	public:
+		using iterator_category = std::forward_iterator_tag;
+		using value_type        = Range;
+		using difference_type   = std::ptrdiff_t;
+		using pointer           = const Range*;
+		using reference         = const Range&;
+
+		Iterator(const BitArray& bits, size_t start)
+		    : m_bits(bits), m_range(bits.FirstRangeFrom(start)) {}
+
+		Iterator& operator++() {
+			m_range = m_bits.FirstRangeFrom(m_range.second);
+			return *this;
+		}
+
+		[[nodiscard]] bool operator==(const Iterator& other) const {
+			return &m_bits == &other.m_bits && m_range == other.m_range;
+		}
+
+		[[nodiscard]] bool operator!=(const Iterator& other) const { return !(*this == other); }
+
+		[[nodiscard]] reference operator*() const { return m_range; }
+		[[nodiscard]] pointer   operator->() const { return &m_range; }
+
+	private:
+		const BitArray& m_bits;
+		Range           m_range;
+	};
+
+	using const_iterator = Iterator;
+
+	constexpr BitArray() = default;
+
+	constexpr BitArray(const BitArray& other, size_t start, size_t end) {
+		if (start >= end || end > N) {
+			return;
+		}
+
+		const auto first_word = start / BITS_PER_WORD;
+		const auto last_word  = (end - 1) / BITS_PER_WORD;
+		const auto start_bit  = start % BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto start_mask = ~uint64_t {0} << start_bit;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
+
+		if (first_word == last_word) {
+			m_data[first_word] = other.m_data[first_word] & start_mask & end_mask;
+			return;
+		}
+
+		m_data[first_word] = other.m_data[first_word] & start_mask;
+		for (auto word = first_word + 1; word < last_word; word++) {
+			m_data[word] = other.m_data[word];
+		}
+		m_data[last_word] = other.m_data[last_word] & end_mask;
+	}
+
+	[[nodiscard]] constexpr bool Get(size_t index) const {
+		return (m_data[index / BITS_PER_WORD] & (uint64_t {1} << (index % BITS_PER_WORD))) != 0;
+	}
+
+	constexpr void Set(size_t index) {
+		m_data[index / BITS_PER_WORD] |= uint64_t {1} << (index % BITS_PER_WORD);
+	}
+
+	constexpr void Unset(size_t index) {
+		m_data[index / BITS_PER_WORD] &= ~(uint64_t {1} << (index % BITS_PER_WORD));
+	}
+
+	constexpr void SetRange(size_t start, size_t end) {
+		if (start >= end || end > N) {
+			return;
+		}
+
+		const auto first_word = start / BITS_PER_WORD;
+		const auto last_word  = (end - 1) / BITS_PER_WORD;
+		const auto start_bit  = start % BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto start_mask = ~uint64_t {0} << start_bit;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
+
+		if (first_word == last_word) {
+			m_data[first_word] |= start_mask & end_mask;
+			return;
+		}
+
+		m_data[first_word] |= start_mask;
+		for (auto word = first_word + 1; word < last_word; word++) {
+			m_data[word] = ~uint64_t {0};
+		}
+		m_data[last_word] |= end_mask;
+	}
+
+	constexpr void UnsetRange(size_t start, size_t end) {
+		if (start >= end || end > N) {
+			return;
+		}
+
+		const auto first_word = start / BITS_PER_WORD;
+		const auto last_word  = (end - 1) / BITS_PER_WORD;
+		const auto start_bit  = start % BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto start_mask = (uint64_t {1} << start_bit) - 1;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? uint64_t {0} : ~((uint64_t {1} << (end_bit + 1)) - 1);
+
+		if (first_word == last_word) {
+			m_data[first_word] &= start_mask | end_mask;
+			return;
+		}
+
+		m_data[first_word] &= start_mask;
+		for (auto word = first_word + 1; word < last_word; word++) {
+			m_data[word] = 0;
+		}
+		m_data[last_word] &= end_mask;
+	}
+
+	constexpr void Clear() { m_data.fill(0); }
+	constexpr void Fill() { m_data.fill(~uint64_t {0}); }
+
+	[[nodiscard]] constexpr bool None() const {
+		uint64_t combined = 0;
+		for (const auto word: m_data) {
+			combined |= word;
+		}
+		return combined == 0;
+	}
+
+	[[nodiscard]] constexpr bool Any() const { return !None(); }
+
+	[[nodiscard]] constexpr Range FirstRangeFrom(size_t start) const {
+		if (start >= N) {
+			return {N, N};
+		}
+
+		auto word_index = start / BITS_PER_WORD;
+		auto word       = m_data[word_index] & (~uint64_t {0} << (start % BITS_PER_WORD));
+		while (word == 0) {
+			word_index++;
+			if (word_index == WORD_COUNT) {
+				return {N, N};
+			}
+			word = m_data[word_index];
+		}
+
+		const auto first     = word_index * BITS_PER_WORD + std::countr_zero(word);
+		const auto first_bit = first % BITS_PER_WORD;
+		const auto first_ones =
+		    static_cast<size_t>(std::countr_one(m_data[word_index] >> first_bit));
+		if (first_bit + first_ones < BITS_PER_WORD) {
+			return {first, first + first_ones};
+		}
+
+		for (word_index++; word_index < WORD_COUNT; word_index++) {
+			word = m_data[word_index];
+			if (word != ~uint64_t {0}) {
+				return {first, word_index * BITS_PER_WORD + std::countr_one(word)};
+			}
+		}
+		return {first, N};
+	}
+
+	[[nodiscard]] constexpr Range FirstRange() const { return FirstRangeFrom(0); }
+
+	[[nodiscard]] constexpr Range LastRangeFrom(size_t end) const {
+		if (end == 0) {
+			return {0, 0};
+		}
+		if (end > N) {
+			end = N;
+		}
+
+		auto       word_index = (end - 1) / BITS_PER_WORD;
+		const auto end_bit    = (end - 1) % BITS_PER_WORD;
+		const auto end_mask =
+		    end_bit == BITS_PER_WORD - 1 ? ~uint64_t {0} : (uint64_t {1} << (end_bit + 1)) - 1;
+		auto word = m_data[word_index] & end_mask;
+		while (word == 0) {
+			if (word_index == 0) {
+				return {0, 0};
+			}
+			word = m_data[--word_index];
+		}
+
+		const auto empty_bits = static_cast<size_t>(std::countl_zero(word));
+		const auto ones       = static_cast<size_t>(std::countl_one(word << empty_bits));
+		const auto last       = (word_index + 1) * BITS_PER_WORD - empty_bits;
+		if (empty_bits + ones < BITS_PER_WORD) {
+			return {last - ones, last};
+		}
+
+		while (word_index != 0) {
+			word = m_data[--word_index];
+			if (word != ~uint64_t {0}) {
+				return {(word_index + 1) * BITS_PER_WORD - std::countl_one(word), last};
+			}
+		}
+		return {0, last};
+	}
+
+	[[nodiscard]] constexpr Range LastRange() const { return LastRangeFrom(N); }
+
+	[[nodiscard]] const_iterator begin() const { return Iterator(*this, 0); }
+	[[nodiscard]] const_iterator end() const { return Iterator(*this, N); }
+
+	constexpr BitArray& operator^=(const BitArray& other) {
+		for (size_t word = 0; word < WORD_COUNT; word++) {
+			m_data[word] ^= other.m_data[word];
+		}
+		return *this;
+	}
+
+	[[nodiscard]] constexpr BitArray operator^(const BitArray& other) const {
+		auto result = *this;
+		result ^= other;
+		return result;
+	}
+
+	[[nodiscard]] constexpr BitArray operator~() const {
+		auto result = *this;
+		for (auto& word: result.m_data) {
+			word = ~word;
+		}
+		return result;
+	}
+
+private:
+	std::array<uint64_t, WORD_COUNT> m_data {};
+};
+
+} // namespace Common
+
+#endif // EMULATOR_SRC_COMMON_BITARRAY_H_

src/common/byteBuffer.h

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cstddef> // IWYU pragma: export
+#include <cstring>
 #include <utility>
 #include <vector>
 

src/common/debug.h

@@ -5,6 +5,7 @@
 #include "common/stringUtils.h"
 
 #include <array>
+#include <cstring>
 
 namespace Common {
 

src/common/emulatorConfig.cpp

@@ -37,6 +37,10 @@ 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;
 }
@@ -89,8 +93,8 @@ bool RenderDocEnabled() {
 	return g_config->renderdoc_enabled;
 }
 
-bool NggRectlistDrawEnabled() {
+bool ReadbackLinearImagesEnabled() {
-	return g_config->ngg_rectlist_draw_enabled;
+	return g_config->readback_linear_images;
 }
 
 } // namespace Config

src/common/emulatorConfig.h

@@ -18,10 +18,14 @@ enum class ProfilerDirection { None, Network };
 
 enum class OutputDirection { Silent, Console, File };
 
+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;
 	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;
@@ -35,7 +39,7 @@ struct ConfigOptions {
 	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   spirv_debug_printf_enabled  = false;
 	bool                   renderdoc_enabled           = false;
-	bool                   ngg_rectlist_draw_enabled   = true;
+	bool                   readback_linear_images      = false;
 };
 
 void Load(const ConfigOptions& cfg);
@@ -43,6 +47,7 @@ void Load(const ConfigOptions& cfg);
 uint32_t GetScreenWidth();
 uint32_t GetScreenHeight();
 uint32_t GetVblankFrequency();
+uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();
 
 bool                   ShaderValidationEnabled();
@@ -63,7 +68,7 @@ ProfilerDirection GetProfilerDirection();
 bool SpirvDebugPrintfEnabled();
 
 bool RenderDocEnabled();
-bool NggRectlistDrawEnabled();
+bool ReadbackLinearImagesEnabled();
 
 } // namespace Config
 

src/common/hostException.cpp

@@ -6,6 +6,14 @@
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 #include <windows.h> // IWYU pragma: keep
+#elif defined(__APPLE__)
+#include <csignal>
+#include <sys/ucontext.h>
+#else
+#include <csignal>
+#include <initializer_list>
+#include <ucontext.h> // IWYU pragma: keep
+#include <unistd.h>
 #endif
 
 // IWYU pragma: no_include <errhandlingapi.h>
@@ -16,7 +24,7 @@
 
 namespace Common::HostException {
 
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+#if !defined(__APPLE__)
 
 static std::atomic<Handler> g_handler {nullptr};
 static std::atomic_uint32_t g_install_state {0};
@@ -30,7 +38,9 @@ static_assert(decltype(g_install_state)::is_always_lock_free);
 	std::fputs(reason != nullptr ? reason : "unspecified", stderr);
 	std::fputc('\n', stderr);
 	std::fflush(stderr);
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	TerminateProcess(GetCurrentProcess(), static_cast<UINT>(EXCEPTION_NONCONTINUABLE_EXCEPTION));
+#endif
 	std::_Exit(321);
 }
 
@@ -48,6 +58,21 @@ public:
 	KYTY_CLASS_NO_COPY(FilterScope);
 };
 
+static Handler LoadInstalledHandler() noexcept {
+	if (g_install_state.load(std::memory_order_acquire) == 0) {
+		FailFast("host exception handler is not installed");
+	}
+
+	const auto handler = g_handler.load(std::memory_order_acquire);
+	if (handler == nullptr) {
+		FailFast("host exception callback is null");
+	}
+	return handler;
+}
+#endif
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+
 static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) {
 	FilterScope filter_scope;
 
@@ -106,22 +131,176 @@ static LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS exception) {
 	info.r14 = exception->ContextRecord->R14;
 	info.r15 = exception->ContextRecord->R15;
 
-	if (g_install_state.load(std::memory_order_acquire) == 0) {
+	const auto handler = LoadInstalledHandler();
-		FailFast("host exception handler is not installed");
+
+	return handler(info) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
+}
+
+#elif defined(__APPLE__)
+
+static std::atomic<Handler> g_handler {nullptr};
+static std::atomic_uint32_t g_install_state {0};
+static thread_local bool    g_in_exception_filter = false;
+
+static_assert(decltype(g_handler)::is_always_lock_free);
+static_assert(decltype(g_install_state)::is_always_lock_free);
+
+[[noreturn]] static void FailFast(const char* reason) noexcept {
+	std::fputs("HostException fail-fast: ", stderr);
+	std::fputs(reason != nullptr ? reason : "unspecified", stderr);
+	std::fputc('\n', stderr);
+	std::fflush(stderr);
+	std::_Exit(321);
+}
+
+// Translate the x86-64 page-fault error code (mcontext __es.__err) into an access type.
+// bit 1 (0x2) = write, bit 4 (0x10) = instruction fetch, otherwise a read.
+static AccessViolationType DecodeAccess(uint64_t err) {
+	if ((err & 0x10u) != 0) {
+		return AccessViolationType::Execute;
 	}
+	if ((err & 0x2u) != 0) {
+		return AccessViolationType::Write;
+	}
+	return AccessViolationType::Read;
+}
+
+// POSIX signal handler that mirrors the Windows vectored handler: build an ExceptionInfo
+// from the mcontext and dispatch. A resolved fault (handler returns true) simply returns,
+// re-executing the faulting instruction against the now-fixed protection. An unresolved
+// fault restores the default disposition so the retry terminates the process.
+static void SignalHandler(int sig, siginfo_t* si, void* uctx) {
+	if (g_in_exception_filter) {
+		FailFast("nested exception while resolving a host fault");
+	}
+	g_in_exception_filter = true;
+
+	auto*       uc = static_cast<ucontext_t*>(uctx);
+	const auto* mc = uc->uc_mcontext;
+	const auto& ss = mc->__ss;
+
+	ExceptionInfo info {};
+	info.exception_address = ss.__rip;
+	info.native_code       = static_cast<uint32_t>(si->si_code);
+	info.native_context    = uctx;
+
+	if (sig == SIGILL) {
+		info.type = ExceptionType::IllegalInstruction;
+	} else {
+		info.type                   = ExceptionType::AccessViolation;
+		info.access_violation_type  = DecodeAccess(mc->__es.__err);
+		info.access_violation_vaddr = reinterpret_cast<uint64_t>(si->si_addr);
+	}
+
+	info.rax = ss.__rax;
+	info.rbx = ss.__rbx;
+	info.rcx = ss.__rcx;
+	info.rdx = ss.__rdx;
+	info.rsi = ss.__rsi;
+	info.rdi = ss.__rdi;
+	info.rbp = ss.__rbp;
+	info.rsp = ss.__rsp;
+	info.r8  = ss.__r8;
+	info.r9  = ss.__r9;
+	info.r10 = ss.__r10;
+	info.r11 = ss.__r11;
+	info.r12 = ss.__r12;
+	info.r13 = ss.__r13;
+	info.r14 = ss.__r14;
+	info.r15 = ss.__r15;
 
 	const auto handler = g_handler.load(std::memory_order_acquire);
 	if (handler == nullptr) {
 		FailFast("host exception callback is null");
 	}
 
-	return handler(info) ? EXCEPTION_CONTINUE_EXECUTION : EXCEPTION_CONTINUE_SEARCH;
+	const bool resolved   = handler(info);
+	g_in_exception_filter = false;
+
+	if (resolved) {
+		return; // retry the faulting instruction against the fixed mapping
+	}
+
+	// Unresolved: restore the default action so the re-executed instruction terminates.
+	struct sigaction dfl {};
+	dfl.sa_handler = SIG_DFL;
+	sigemptyset(&dfl.sa_mask);
+	sigaction(sig, &dfl, nullptr);
+}
+
+#else
+
+// x86-64 page-fault error bits.
+constexpr uint64_t PAGE_FAULT_ERROR_WRITE       = 0x02;
+constexpr uint64_t PAGE_FAULT_ERROR_INSTRUCTION = 0x10;
+
+// Let the kernel handle an unresolved fault on retry.
+static void ChainToDefault(int signal_number) noexcept {
+	struct sigaction restore {};
+	restore.sa_handler = SIG_DFL;
+	sigemptyset(&restore.sa_mask);
+	restore.sa_flags = 0;
+	::sigaction(signal_number, &restore, nullptr);
+}
+
+static void SignalHandler(int signal_number, siginfo_t* signal_info, void* native_context) {
+	FilterScope filter_scope;
+
+	auto* context = static_cast<ucontext_t*>(native_context);
+	auto* gregs   = context->uc_mcontext.gregs;
+
+	ExceptionInfo info {};
+	info.exception_address = static_cast<uint64_t>(gregs[REG_RIP]);
+	info.native_code       = static_cast<uint32_t>(signal_number);
+	info.native_context    = context;
+
+	if (signal_number == SIGSEGV || signal_number == SIGBUS) {
+		info.type             = ExceptionType::AccessViolation;
+		const auto error_code = static_cast<uint64_t>(gregs[REG_ERR]);
+		if ((error_code & PAGE_FAULT_ERROR_INSTRUCTION) != 0) {
+			info.access_violation_type = AccessViolationType::Execute;
+		} else if ((error_code & PAGE_FAULT_ERROR_WRITE) != 0) {
+			info.access_violation_type = AccessViolationType::Write;
+		} else {
+			info.access_violation_type = AccessViolationType::Read;
+		}
+		info.access_violation_vaddr = reinterpret_cast<uint64_t>(signal_info->si_addr);
+	} else if (signal_number == SIGILL) {
+		info.type = ExceptionType::IllegalInstruction;
+	} else {
+		ChainToDefault(signal_number);
+		return;
+	}
+
+	info.rax = static_cast<uint64_t>(gregs[REG_RAX]);
+	info.rbx = static_cast<uint64_t>(gregs[REG_RBX]);
+	info.rcx = static_cast<uint64_t>(gregs[REG_RCX]);
+	info.rdx = static_cast<uint64_t>(gregs[REG_RDX]);
+	info.rsi = static_cast<uint64_t>(gregs[REG_RSI]);
+	info.rdi = static_cast<uint64_t>(gregs[REG_RDI]);
+	info.rbp = static_cast<uint64_t>(gregs[REG_RBP]);
+	info.rsp = static_cast<uint64_t>(gregs[REG_RSP]);
+	info.r8  = static_cast<uint64_t>(gregs[REG_R8]);
+	info.r9  = static_cast<uint64_t>(gregs[REG_R9]);
+	info.r10 = static_cast<uint64_t>(gregs[REG_R10]);
+	info.r11 = static_cast<uint64_t>(gregs[REG_R11]);
+	info.r12 = static_cast<uint64_t>(gregs[REG_R12]);
+	info.r13 = static_cast<uint64_t>(gregs[REG_R13]);
+	info.r14 = static_cast<uint64_t>(gregs[REG_R14]);
+	info.r15 = static_cast<uint64_t>(gregs[REG_R15]);
+
+	const auto handler = LoadInstalledHandler();
+
+	if (handler(info)) {
+		return;
+	}
+
+	ChainToDefault(signal_number);
 }
 
 #endif
 
 bool InstallHandler(Handler handler) {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	if (handler == nullptr) {
 		return false;
 	}
@@ -133,19 +312,52 @@ bool InstallHandler(Handler handler) {
 
 	g_handler.store(handler, std::memory_order_release);
 
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	if (AddVectoredExceptionHandler(1, ExceptionFilter) == nullptr) {
 		g_handler.store(nullptr, std::memory_order_release);
 		g_install_state.store(0, std::memory_order_release);
 		printf("AddVectoredExceptionHandler() failed\n");
 		return false;
 	}
+#elif defined(__APPLE__)
+	struct sigaction sa {};
+	sa.sa_sigaction = SignalHandler;
+	sa.sa_flags     = SA_SIGINFO;
+	sigemptyset(&sa.sa_mask);
+	// The guest signal-dispatch path (KernelRaiseException) interrupts threads with
+	// SIGUSR1; block it while a fault is being resolved so a stop-the-world request
+	// cannot preempt the handler between the protection fix and the retry.
+	sigaddset(&sa.sa_mask, SIGUSR1);
+
+	// macOS raises SIGBUS for protection faults on some paths and SIGSEGV on others;
+	// SIGILL covers instructions the host cannot execute (routed to the x64 emulator).
+	bool ok = sigaction(SIGSEGV, &sa, nullptr) == 0 && sigaction(SIGBUS, &sa, nullptr) == 0 &&
+	          sigaction(SIGILL, &sa, nullptr) == 0;
+	if (!ok) {
+		g_handler.store(nullptr, std::memory_order_release);
+		g_install_state.store(0, std::memory_order_release);
+		printf("sigaction() failed to install the host fault handler\n");
+		return false;
+	}
+#else
+	struct sigaction action {};
+	action.sa_sigaction = SignalHandler;
+	sigemptyset(&action.sa_mask);
+	// Fault resolution needs the normal thread stack.
+	action.sa_flags = SA_SIGINFO | SA_RESTART;
+
+	for (const int signal_number: {SIGSEGV, SIGBUS, SIGILL}) {
+		if (::sigaction(signal_number, &action, nullptr) != 0) {
+			g_handler.store(nullptr, std::memory_order_release);
+			g_install_state.store(0, std::memory_order_release);
+			printf("sigaction(%d) failed\n", signal_number);
+			return false;
+		}
+	}
+#endif
 
 	g_install_state.store(2, std::memory_order_release);
 	return true;
-#else
-	(void)handler;
-	return false;
-#endif
 }
 
 } // namespace Common::HostException

src/common/logging/log.cpp

@@ -178,6 +178,11 @@ Direction GetDirection() {
 	return g_direction;
 }
 
+bool IsSilent() {
+	// Before init LOGF must keep writing to stdout, so report non-silent.
+	return g_initialized && g_direction == Direction::Silent;
+}
+
 void Write(std::string_view text) {
 	WriteImpl(text);
 }

src/common/logging/log.h

@@ -15,6 +15,7 @@ KYTY_SUBSYSTEM_DEFINE(Log);
 enum class Direction { Silent, Console, File };
 
 Direction GetDirection();
+bool      IsSilent();
 void      Write(std::string_view text);
 void      Write(fmt::text_style style, std::string_view text);
 void      WriteFatal(std::string_view text);
@@ -41,8 +42,18 @@ inline constexpr auto BrightWhite   = fmt::fg(fmt::terminal_color::bright_white)
 } // namespace Log
 
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LOGF(...) ::Log::Write(::fmt::sprintf(__VA_ARGS__))
+#define LOGF(...)                                                                                  \
+	do {                                                                                           \
+		if (!::Log::IsSilent()) {                                                                  \
+			::Log::Write(::fmt::sprintf(__VA_ARGS__));                                             \
+		}                                                                                          \
+	} while (false)
 // NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
-#define LOGF_COLOR(style, ...) ::Log::Write((style), ::fmt::sprintf(__VA_ARGS__))
+#define LOGF_COLOR(style, ...)                                                                     \
+	do {                                                                                           \
+		if (!::Log::IsSilent()) {                                                                  \
+			::Log::Write((style), ::fmt::sprintf(__VA_ARGS__));                                    \
+		}                                                                                          \
+	} while (false)
 
 #endif /* KYTY_COMMON_LOGGING_LOG_H_ */

src/common/lruCache.h

@@ -0,0 +1,118 @@
+#ifndef EMULATOR_SRC_COMMON_LRUCACHE_H_
+#define EMULATOR_SRC_COMMON_LRUCACHE_H_
+
+#include <cstddef>
+#include <deque>
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename Object, typename Tick>
+class LeastRecentlyUsedCache {
+	struct Item {
+		Object object {};
+		Tick   tick {};
+		Item*  next = nullptr;
+		Item*  prev = nullptr;
+	};
+
+public:
+	[[nodiscard]] size_t Insert(Object object, Tick tick) {
+		const auto id   = Build();
+		auto&      item = m_items[id];
+		item.object     = std::move(object);
+		item.tick       = tick;
+		Attach(item);
+		return id;
+	}
+
+	void Touch(size_t id, Tick tick) {
+		auto& item = m_items[id];
+		if (item.tick >= tick) {
+			return;
+		}
+		item.tick = tick;
+		if (&item != m_last) {
+			Detach(item);
+			Attach(item);
+		}
+	}
+
+	void Free(size_t id) {
+		auto& item = m_items[id];
+		Detach(item);
+		item.next = nullptr;
+		item.prev = nullptr;
+		m_free.push_back(id);
+	}
+
+	template <typename Function>
+	void ForEachItemBelow(Tick tick, Function&& function) {
+		constexpr bool ReturnsBool = std::is_same_v<std::invoke_result_t<Function, Object>, bool>;
+		for (auto* item = m_first; item != nullptr;) {
+			if (item->tick > tick) {
+				return;
+			}
+			auto* next = item->next;
+			if constexpr (ReturnsBool) {
+				if (function(item->object)) {
+					return;
+				}
+			} else {
+				function(item->object);
+			}
+			item = next;
+		}
+	}
+
+private:
+	[[nodiscard]] size_t Build() {
+		if (m_free.empty()) {
+			const auto id = m_items.size();
+			m_items.emplace_back();
+			return id;
+		}
+		const auto id = m_free.front();
+		m_free.pop_front();
+		return id;
+	}
+
+	void Attach(Item& item) {
+		if (m_first == nullptr) {
+			m_first = &item;
+		}
+		if (m_last == nullptr) {
+			m_last = &item;
+			return;
+		}
+		item.prev    = m_last;
+		m_last->next = &item;
+		item.next    = nullptr;
+		m_last       = &item;
+	}
+
+	void Detach(Item& item) {
+		if (item.prev != nullptr) {
+			item.prev->next = item.next;
+		}
+		if (item.next != nullptr) {
+			item.next->prev = item.prev;
+		}
+		if (m_first == &item) {
+			m_first = item.next;
+		}
+		if (m_last == &item) {
+			m_last = item.prev;
+		}
+	}
+
+	std::deque<Item>   m_items;
+	std::deque<size_t> m_free;
+	Item*              m_first = nullptr;
+	Item*              m_last  = nullptr;
+};
+
+} // namespace Common
+
+#endif // EMULATOR_SRC_COMMON_LRUCACHE_H_

src/common/platform/sysDbg.h

@@ -23,6 +23,10 @@ struct sys_dbg_stack_info_t {
 	size_t    commited_size;
 	size_t    total_size;
 	size_t    code_size;
+
+	// Full stack reservation reported by pthread.
+	uintptr_t reserved_addr;
+	size_t    reserved_size;
 #endif
 };
 

src/common/platform/sysLinuxDbg.cpp

@@ -8,12 +8,56 @@
 
 #include <cstdlib>
 #include <cstring>
+#include <execinfo.h>
+#include <pthread.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <unistd.h>
+#if defined(__APPLE__)
+#include <libgen.h> // POSIX basename() lives here on macOS, not in <cstring>
+#endif
 
-void SysStackWalk(void** /*stack*/, int* depth) {
+// Avoid unwinding a guest-owned stack.
-	*depth = 0;
+static bool OnOwnStack() {
+	const char* probe = reinterpret_cast<const char*>(&probe);
+
+	pthread_attr_t attr {};
+#if defined(__APPLE__)
+	const auto* top  = static_cast<const char*>(pthread_get_stackaddr_np(pthread_self()));
+	const auto  size = pthread_get_stacksize_np(pthread_self());
+	(void)attr;
+	return top != nullptr && size != 0 && probe < top && probe >= top - size;
+#else
+	if (pthread_getattr_np(pthread_self(), &attr) != 0) {
+		return false;
+	}
+	void*      base = nullptr;
+	size_t     size = 0;
+	const bool ok = pthread_attr_getstack(&attr, &base, &size) == 0 && base != nullptr && size != 0;
+	pthread_attr_destroy(&attr);
+	if (!ok) {
+		return false;
+	}
+	const auto* low = static_cast<const char*>(base);
+	return probe >= low && probe < low + size;
+#endif
+}
+
+void SysStackWalk(void** stack, int* depth) {
+	if (stack == nullptr || depth == nullptr || *depth <= 0) {
+		if (depth != nullptr) {
+			*depth = 0;
+		}
+		return;
+	}
+
+	if (!OnOwnStack()) {
+		*depth = 0;
+		return;
+	}
+
+	const int n = ::backtrace(stack, *depth);
+	*depth      = (n < 0 ? 0 : n);
 }
 
 void SysStackUsagePrint(sys_dbg_stack_info_t& stack) {
@@ -30,6 +74,33 @@ void SysStackUsage(sys_dbg_stack_info_t& s) {
 
 	[[maybe_unused]] int result = 0;
 
+	memset(&s, 0, sizeof(sys_dbg_stack_info_t));
+
+	// Record the reservation before the Linux /proc walk.
+	{
+		pthread_attr_t self_attr {};
+#if defined(__APPLE__)
+		void*        stack_top  = pthread_get_stackaddr_np(pthread_self());
+		const size_t stack_size = pthread_get_stacksize_np(pthread_self());
+		if (stack_top != nullptr && stack_size != 0) {
+			s.reserved_addr = reinterpret_cast<uintptr_t>(stack_top) - stack_size;
+			s.reserved_size = stack_size;
+		}
+		(void)self_attr;
+#else
+		if (pthread_getattr_np(pthread_self(), &self_attr) == 0) {
+			void*  stack_base = nullptr;
+			size_t stack_size = 0;
+			if (pthread_attr_getstack(&self_attr, &stack_base, &stack_size) == 0 &&
+			    stack_base != nullptr && stack_size != 0) {
+				s.reserved_addr = reinterpret_cast<uintptr_t>(stack_base);
+				s.reserved_size = stack_size;
+			}
+			pthread_attr_destroy(&self_attr);
+		}
+#endif
+	}
+
 	char str[1024];
 	char str2[1024];
 	result = sprintf(str, "/proc/%d/exe", static_cast<int>(pid));
@@ -43,8 +114,6 @@ void SysStackUsage(sys_dbg_stack_info_t& s) {
 
 	result = sprintf(str, "/proc/%d/maps", static_cast<int>(pid));
 
-	memset(&s, 0, sizeof(sys_dbg_stack_info_t));
-
 	FILE* f = fopen(str, "r");
 
 	if (f == nullptr) {
@@ -118,6 +187,11 @@ void SysStackUsage(sys_dbg_stack_info_t& s) {
 	}
 
 	result = fclose(f);
+
+	if (s.reserved_addr == 0) {
+		s.reserved_addr = s.addr;
+		s.reserved_size = s.total_size;
+	}
 }
 
 #endif

src/common/platform/sysLinuxFileIO.cpp

@@ -11,7 +11,11 @@
 
 #include <cerrno>
 #include <cstdlib>
+#include <dirent.h>
+#include <fcntl.h>
+#include <filesystem>
 #include <sys/stat.h>
+#include <system_error>
 #include <unistd.h>
 #include <utime.h>
 
@@ -39,10 +43,43 @@ struct sys_file_t {
 	};
 };
 
+// Darwin uses BSD timestamp member names.
+#if defined(__APPLE__)
+#define KYTY_STAT_ATIME_NS(st) ((st).st_atimespec.tv_nsec)
+#define KYTY_STAT_MTIME_NS(st) ((st).st_mtimespec.tv_nsec)
+#else
+#define KYTY_STAT_ATIME_NS(st) ((st).st_atim.tv_nsec)
+#define KYTY_STAT_MTIME_NS(st) ((st).st_mtim.tv_nsec)
+#endif
+
 static std::filesystem::path get_internal_name(const std::filesystem::path& name) {
 	return name.is_absolute() ? name : (std::filesystem::path(".") / name);
 }
 
+// Pass access-pattern hints to the host.
+static void apply_cache_hint(FILE* f, sys_file_cache_type_t cache_type) {
+	if (f == nullptr) {
+		return;
+	}
+
+#if !defined(__APPLE__)
+	int advice = POSIX_FADV_NORMAL;
+	switch (cache_type) {
+		case SYS_FILE_CACHE_RANDOM_ACCESS: advice = POSIX_FADV_RANDOM; break;
+		case SYS_FILE_CACHE_SEQUENTIAL_SCAN: advice = POSIX_FADV_SEQUENTIAL; break;
+		case SYS_FILE_CACHE_AUTO:
+		default: return;
+	}
+	::posix_fadvise(fileno(f), 0, 0, advice);
+#else
+	if (cache_type == SYS_FILE_CACHE_SEQUENTIAL_SCAN) {
+		::fcntl(fileno(f), F_RDAHEAD, 1);
+	} else if (cache_type == SYS_FILE_CACHE_RANDOM_ACCESS) {
+		::fcntl(fileno(f), F_RDAHEAD, 0);
+	}
+#endif
+}
+
 void SysFileRead(void* data, uint32_t size, sys_file_t& f, uint32_t* bytes_read) {
 	if (f.type == SYS_FILE_FILE) {
 		size_t w = fread(data, 1, size, f.f);
@@ -135,8 +172,7 @@ sys_file_t* SysFileCreate(const std::filesystem::path& file_name) {
 	return ret;
 }
 
-sys_file_t* SysFileOpenR(const std::filesystem::path& file_name,
+sys_file_t* SysFileOpenR(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
-                         sys_file_cache_type_t /*cache_type*/) {
 	auto* ret = new sys_file_t;
 
 	ret->type = SYS_FILE_FILE;
@@ -150,6 +186,8 @@ sys_file_t* SysFileOpenR(const std::filesystem::path& file_name,
 		ret->type = SYS_FILE_ERROR;
 	}
 
+	apply_cache_hint(f, cache_type);
+
 	ret->f = f;
 
 	return ret;
@@ -179,8 +217,7 @@ sys_file_t* SysFileCreate() {
 	return ret;
 }
 
-sys_file_t* SysFileOpenW(const std::filesystem::path& file_name,
+sys_file_t* SysFileOpenW(const std::filesystem::path& file_name, sys_file_cache_type_t cache_type) {
-                         sys_file_cache_type_t /*cache_type*/) {
 	auto* ret = new sys_file_t;
 
 	auto real_name     = get_internal_name(file_name);
@@ -194,13 +231,15 @@ sys_file_t* SysFileOpenW(const std::filesystem::path& file_name,
 		ret->type = SYS_FILE_FILE;
 	}
 
+	apply_cache_hint(f, cache_type);
+
 	ret->f = f;
 
 	return ret;
 }
 
 sys_file_t* SysFileOpenRw(const std::filesystem::path& file_name,
-                          sys_file_cache_type_t /*cache_type*/) {
+                          sys_file_cache_type_t        cache_type) {
 	auto* ret = new sys_file_t;
 
 	auto real_name     = get_internal_name(file_name);
@@ -214,6 +253,8 @@ sys_file_t* SysFileOpenRw(const std::filesystem::path& file_name,
 		ret->type = SYS_FILE_FILE;
 	}
 
+	apply_cache_hint(f, cache_type);
+
 	ret->f = f;
 
 	return ret;
@@ -239,11 +280,17 @@ uint64_t SysFileSize(sys_file_t& f) {
 	[[maybe_unused]] int result = 0;
 
 	if (f.type == SYS_FILE_FILE) {
-		uint32_t pos  = ftell(f.f);
+		// Preserve sizes above 4 GiB.
-		result        = fseek(f.f, 0, SEEK_END);
+		const off_t pos = ftello(f.f);
-		uint32_t size = ftell(f.f);
+		if (pos < 0) {
-		result        = fseek(f.f, pos, SEEK_SET);
+			return 0;
-		return size;
+		}
+		if (fseeko(f.f, 0, SEEK_END) != 0) {
+			return 0;
+		}
+		const off_t size = ftello(f.f);
+		result           = fseeko(f.f, pos, SEEK_SET);
+		return (size < 0 ? 0 : static_cast<uint64_t>(size));
 	}
 
 	if (f.type == SYS_FILE_MEMORY_STAT || f.type == SYS_FILE_MEMORY_DYN) {
@@ -260,8 +307,18 @@ uint64_t SysFileSize(const std::filesystem::path& file_name) {
 	return size;
 }
 
-bool SysFileTruncate(sys_file_t& /*f*/, uint64_t /*size*/) {
+bool SysFileTruncate(sys_file_t& f, uint64_t size) {
-	return false;
+	bool ok = false;
+	if (f.type == SYS_FILE_FILE) {
+		// Flush before resizing and restore the caller's position.
+		const auto position = ftell(f.f);
+		fflush(f.f);
+		ok = (ftruncate(fileno(f.f), static_cast<off_t>(size)) == 0);
+		if (position >= 0) {
+			fseek(f.f, position, SEEK_SET);
+		}
+	}
+	return ok;
 }
 
 bool SysFileUnlink(sys_file_t& /*f*/, const std::filesystem::path& name) {
@@ -382,6 +439,7 @@ SysFileTimeStruct SysFileGetLastAccessTimeUtc(const std::filesystem::path& name)
 	} else {
 		r.is_invalid = false;
 		r.time       = s.st_atime;
+		r.nanos      = KYTY_STAT_ATIME_NS(s);
 	}
 
 	return r;
@@ -400,6 +458,7 @@ SysFileTimeStruct SysFileGetLastWriteTimeUtc(const std::filesystem::path& name)
 	} else {
 		r.is_invalid = false;
 		r.time       = s.st_mtime;
+		r.nanos      = KYTY_STAT_MTIME_NS(s);
 	}
 
 	return r;
@@ -419,13 +478,36 @@ void SysFileGetLastAccessAndWriteTimeUtc(const std::filesystem::path& name, SysF
 		a.is_invalid = false;
 		w.is_invalid = false;
 		a.time       = s.st_atime;
+		a.nanos      = KYTY_STAT_ATIME_NS(s);
 		w.time       = s.st_mtime;
+		w.nanos      = KYTY_STAT_MTIME_NS(s);
 	}
 }
 
-void SysFileGetLastAccessAndWriteTimeUtc(sys_file_t& /*f*/, SysFileTimeStruct& /*a*/,
+void SysFileGetLastAccessAndWriteTimeUtc(sys_file_t& f, SysFileTimeStruct& a,
-                                         SysFileTimeStruct& /*w*/) {
+                                         SysFileTimeStruct& w) {
-	EXIT("not implemented\n");
+	if (f.type == SYS_FILE_FILE) {
+		struct stat s {};
+
+		const bool ok = (0 == fstat(fileno(f.f), &s));
+
+		a.is_invalid = w.is_invalid = !ok;
+
+		if (ok) {
+			a.time  = s.st_atime;
+			a.nanos = KYTY_STAT_ATIME_NS(s);
+			w.time  = s.st_mtime;
+			w.nanos = KYTY_STAT_MTIME_NS(s);
+		}
+	} else if (f.type == SYS_FILE_MEMORY_STAT || f.type == SYS_FILE_MEMORY_DYN) {
+		// Memory-backed files use the current time.
+		SysTimeStruct t {};
+		SysGetSystemTimeUtc(t);
+		SysSystemToFileTimeUtc(t, a);
+		SysSystemToFileTimeUtc(t, w);
+	} else {
+		a.is_invalid = w.is_invalid = true;
+	}
 }
 
 bool SysFileSetLastAccessTimeUtc(const std::filesystem::path& name, SysFileTimeStruct& access) {
@@ -531,27 +613,110 @@ bool SysFileSetLastAccessAndWriteTimeUtc(const std::filesystem::path& name,
 	//	}
 }
 
-void SysFileFindFiles(const std::filesystem::path& /*path*/,
+// Recursively collect regular files.
-                      std::vector<sys_file_find_t>& /*out*/) {
+void SysFileFindFiles(const std::filesystem::path& path, std::vector<sys_file_find_t>& out) {
-	EXIT("not implemented\n");
+	auto real_path = get_internal_name(path);
+
+	DIR* dir = opendir(real_path.string().c_str());
+	if (dir == nullptr) {
+		return;
+	}
+
+	for (const dirent* entry = readdir(dir); entry != nullptr; entry = readdir(dir)) {
+		const std::string file_name(entry->d_name);
+
+		if (file_name == "." || file_name == "..") {
+			continue;
+		}
+
+		auto        child = real_path / file_name;
+		struct stat s {};
+
+		// lstat, so a symlink is never followed into a cycle during the recursive walk.
+		if (0 != lstat(child.string().c_str(), &s)) {
+			continue;
+		}
+
+		if (S_ISDIR(s.st_mode)) {
+			SysFileFindFiles(child, out);
+		} else if (S_ISREG(s.st_mode)) {
+			sys_file_find_t r {};
+
+			r.path_with_name              = child;
+			r.size                        = static_cast<uint64_t>(s.st_size);
+			r.last_access_time.is_invalid = false;
+			r.last_access_time.time       = s.st_atime;
+			r.last_access_time.nanos      = KYTY_STAT_ATIME_NS(s);
+			r.last_write_time.is_invalid  = false;
+			r.last_write_time.time        = s.st_mtime;
+			r.last_write_time.nanos       = KYTY_STAT_MTIME_NS(s);
+
+			out.push_back(r);
+		}
+	}
+
+	closedir(dir);
 }
 
-void SysFileGetDents(const std::filesystem::path& /*path*/, std::vector<sys_dir_entry_t>& /*out*/) {
+// Keep "." and ".." to match FindFirstFileW.
-	EXIT("not implemented\n");
+void SysFileGetDents(const std::filesystem::path& path, std::vector<sys_dir_entry_t>& out) {
+	auto real_path = get_internal_name(path);
+
+	DIR* dir = opendir(real_path.string().c_str());
+	if (dir == nullptr) {
+		return;
+	}
+
+	for (const dirent* entry = readdir(dir); entry != nullptr; entry = readdir(dir)) {
+		sys_dir_entry_t r {};
+
+		r.name = entry->d_name;
+
+		if (entry->d_type == DT_UNKNOWN) {
+			// Some filesystems do not populate d_type.
+			struct stat s {};
+			r.is_file = 0 == lstat((real_path / r.name).string().c_str(), &s) && S_ISREG(s.st_mode);
+		} else {
+			r.is_file = entry->d_type != DT_DIR;
+		}
+
+		out.push_back(r);
+	}
+
+	closedir(dir);
 }
 
-bool SysFileCopyFile(const std::filesystem::path& /*src*/, const std::filesystem::path& /*dst*/) {
+bool SysFileCopyFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
-	EXIT("not implemented\n");
+	std::error_code error;
-	return false;
+	return std::filesystem::copy_file(get_internal_name(src), get_internal_name(dst),
+	                                  std::filesystem::copy_options::overwrite_existing, error) &&
+	       !error;
 }
 
-bool SysFileMoveFile(const std::filesystem::path& /*src*/, const std::filesystem::path& /*dst*/) {
+bool SysFileMoveFile(const std::filesystem::path& src, const std::filesystem::path& dst) {
-	EXIT("not implemented\n");
+	auto real_src = get_internal_name(src);
-	return false;
+	auto real_dst = get_internal_name(dst);
+
+	// Match MoveFileW: fail when the destination exists.
+	std::error_code error;
+	if (std::filesystem::exists(real_dst, error)) {
+		return false;
+	}
+
+	return 0 == rename(real_src.string().c_str(), real_dst.string().c_str());
 }
 
-void SysFileRemoveReadonly(const std::filesystem::path& /*name*/) {
+void SysFileRemoveReadonly(const std::filesystem::path& name) {
-	EXIT("not implemented\n");
+	auto real_name     = get_internal_name(name);
+	auto real_name_str = real_name.string();
+
+	struct stat s {};
+
+	if (0 != stat(real_name_str.c_str(), &s)) {
+		return;
+	}
+
+	chmod(real_name_str.c_str(), s.st_mode | S_IWUSR);
 }
 
 #endif

src/common/platform/sysLinuxVirtual.cpp

@@ -8,9 +8,16 @@
 #include "common/platform/sysVirtual.h"
 #include "common/virtualMemory.h"
 
+#include <atomic>
 #include <map>
 #include <pthread.h>
 #include <sys/mman.h>
+#include <unistd.h>
+
+#if defined(__APPLE__)
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#endif
 
 // IWYU pragma: no_include <asm/mman-common.h>
 // IWYU pragma: no_include <asm/mman.h>
@@ -31,8 +38,8 @@ void SysVirtualInit() {
 	pthread_mutexattr_t attr {};
 
 	pthread_mutexattr_init(&attr);
-#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX && !defined(__APPLE__)
-	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_FAST_NP);
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_FAST_NP); // glibc-only fast mutex
 #else
 	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
 #endif
@@ -76,6 +83,70 @@ static VirtualMemory::Mode get_protection_flag(int mode) {
 	}
 }
 
+// Keep automatic mappings inside the guest and GPU-addressable low window.
+#ifdef KYTY_FIXED_NOREPLACE
+static constexpr uintptr_t LOW_ARENA_LIMIT = 0x000000FC00000000ULL; // libc mspace window ceiling
+static constexpr uintptr_t LOW_ARENA_FLOOR = 0x000000A000000000ULL; // 640 GiB
+static constexpr uintptr_t LOW_ARENA_GRAIN = 0x0000000000010000ULL; // 64 KiB
+
+static_assert(LOW_ARENA_LIMIT <= 0x0000010000000000ULL,
+              "arena must stay inside the GPU page tracker's 1<<40 window");
+static_assert(LOW_ARENA_FLOOR < LOW_ARENA_LIMIT, "arena floor must sit below its ceiling");
+
+static std::atomic<uintptr_t> g_low_arena_next {LOW_ARENA_LIMIT};
+#endif
+
+// Caller holds g_virtual_mutex.
+static void record_alloc(uintptr_t addr, size_t size) {
+	auto next = g_allocs->upper_bound(addr);
+	if (next != g_allocs->begin()) {
+		auto       it         = std::prev(next);
+		const auto alloc_addr = it->first;
+		const auto alloc_end  = alloc_addr + it->second;
+		if (alloc_addr <= addr && addr + size <= alloc_end) {
+			g_allocs->erase(it);
+			if (alloc_addr < addr) {
+				(*g_allocs)[alloc_addr] = addr - alloc_addr;
+			}
+			if (addr + size < alloc_end) {
+				(*g_allocs)[addr + size] = alloc_end - (addr + size);
+			}
+		}
+	}
+	(*g_allocs)[addr] = size;
+}
+
+#ifdef KYTY_FIXED_NOREPLACE
+static uintptr_t align_up_to(uintptr_t addr, uint64_t alignment) {
+	return (addr + alignment - 1) & ~(alignment - 1);
+}
+#endif
+
+// Freed arena addresses are not reused while GPU caches remain keyed by address.
+static void* map_anonymous(uintptr_t addr, size_t size, int protect, int flags) {
+	if (addr != 0) {
+		return mmap(reinterpret_cast<void*>(addr), size, protect, flags, -1, 0); // NOLINT
+	}
+
+#ifdef KYTY_FIXED_NOREPLACE
+	const auto step = align_up_to(size, LOW_ARENA_GRAIN);
+	for (int attempt = 0; attempt < 256; attempt++) {
+		const auto top = g_low_arena_next.fetch_sub(step, std::memory_order_relaxed);
+		if (top < step || top - step < LOW_ARENA_FLOOR) {
+			break;
+		}
+		const auto hint = (top - step) & ~(LOW_ARENA_GRAIN - 1);
+		void* ptr = mmap(reinterpret_cast<void*>(hint), size, protect, flags | MAP_FIXED_NOREPLACE,
+		                 -1, 0); // NOLINT
+		if (ptr != MAP_FAILED) {
+			return ptr;
+		}
+	}
+#endif
+
+	return mmap(nullptr, size, protect, flags, -1, 0); // NOLINT
+}
+
 uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
 	EXIT_IF(g_allocs == nullptr);
 
@@ -83,16 +154,15 @@ uint64_t SysVirtualAlloc(uint64_t address, uint64_t size, VirtualMemory::Mode mo
 
 	int protect = get_protection_flag(mode);
 
-	void* ptr =
+	void* ptr = map_anonymous(addr, size, protect, MAP_PRIVATE | MAP_ANON);
-	    mmap(reinterpret_cast<void*>(addr), size, protect, MAP_PRIVATE | MAP_ANON, -1, 0); // NOLINT
 
 	auto ret_addr = reinterpret_cast<uintptr_t>(ptr);
 
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
-		(*g_allocs)[ret_addr] = size;
+		record_alloc(ret_addr, size);
-		uintptr_t page_start  = ret_addr >> 12u;
+		uintptr_t page_start = ret_addr >> 12u;
-		uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
+		uintptr_t page_end   = (ret_addr + size - 1) >> 12u;
 		for (uintptr_t page = page_start; page <= page_end; page++) {
 			(*g_protects)[page] = protect;
 		}
@@ -117,18 +187,43 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 	auto addr    = static_cast<uintptr_t>(address);
 	int  protect = get_protection_flag(mode);
 
-	void* ptr =
+	void* ptr = map_anonymous(addr, size, protect, MAP_PRIVATE | MAP_ANON);
-	    mmap(reinterpret_cast<void*>(addr), size, protect, MAP_PRIVATE | MAP_ANON, -1, 0); // NOLINT
 
 	auto ret_addr = reinterpret_cast<uintptr_t>(ptr);
 
 	if (ptr != MAP_FAILED && ((ret_addr & (alignment - 1)) != 0)) {
 		munmap(ptr, size);
 
-		ptr      = mmap(reinterpret_cast<void*>(addr), size + alignment, protect,
+		ptr =
-		                MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); // NOLINT
+		    map_anonymous(addr, size + alignment, protect, MAP_PRIVATE | MAP_ANON | MAP_NORESERVE);
 		ret_addr = reinterpret_cast<uintptr_t>(ptr);
 		if (ptr != MAP_FAILED) {
+#if defined(__APPLE__)
+			// Carve the aligned subrange out of the live mapping with MAP_FIXED (in-place
+			// replacement) and trim the slack; never munmap the whole range first, or a
+			// concurrent host mapping (dyld, Rosetta, Metal) could claim the hole and be
+			// destroyed by the MAP_FIXED. Other platforms keep the original path below.
+			auto aligned_addr = align_up(ret_addr, alignment);
+			// NOLINTNEXTLINE
+			void* fixed = mmap(reinterpret_cast<void*>(aligned_addr), size, protect,
+			                   MAP_FIXED | MAP_PRIVATE | MAP_ANON, -1, 0);
+			if (fixed == MAP_FAILED) {
+				munmap(ptr, size + alignment);
+				ret_addr = 0;
+				ptr      = MAP_FAILED;
+			} else {
+				if (aligned_addr > ret_addr) {
+					munmap(reinterpret_cast<void*>(ret_addr), aligned_addr - ret_addr);
+				}
+				const uintptr_t tail_start = aligned_addr + size;
+				const uintptr_t resv_end   = ret_addr + size + alignment;
+				if (resv_end > tail_start) {
+					munmap(reinterpret_cast<void*>(tail_start), resv_end - tail_start);
+				}
+				ptr      = fixed;
+				ret_addr = aligned_addr;
+			}
+#else
 			munmap(ptr, size + alignment);
 			auto aligned_addr = align_up(ret_addr, alignment);
 #ifdef KYTY_FIXED_NOREPLACE
@@ -146,6 +241,7 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 				ret_addr = 0;
 				ptr      = MAP_FAILED;
 			}
+#endif
 		}
 	}
 
@@ -154,9 +250,9 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 	}
 
 	pthread_mutex_lock(&g_virtual_mutex);
-	(*g_allocs)[ret_addr] = size;
+	record_alloc(ret_addr, size);
-	uintptr_t page_start  = ret_addr >> 12u;
+	uintptr_t page_start = ret_addr >> 12u;
-	uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
+	uintptr_t page_end   = (ret_addr + size - 1) >> 12u;
 	for (uintptr_t page = page_start; page <= page_end; page++) {
 		(*g_protects)[page] = protect;
 	}
@@ -165,6 +261,27 @@ uint64_t SysVirtualAllocAligned(uint64_t address, uint64_t size, VirtualMemory::
 	return ret_addr;
 }
 
+#if defined(__APPLE__)
+// macOS has no /proc/self/maps; query the Mach VM map directly. mach_vm_region returns
+// the first mapped region at or above `region_addr`; if it begins before the end of the
+// requested range, the range overlaps an existing mapping.
+static bool is_mapped(void* ptr, size_t length) {
+	auto                           query_addr  = reinterpret_cast<mach_vm_address_t>(ptr);
+	mach_vm_address_t              region_addr = query_addr;
+	mach_vm_size_t                 region_size = 0;
+	vm_region_basic_info_data_64_t info {};
+	mach_msg_type_number_t         count       = VM_REGION_BASIC_INFO_COUNT_64;
+	mach_port_t                    object_name = MACH_PORT_NULL;
+
+	kern_return_t kr =
+	    mach_vm_region(mach_task_self(), &region_addr, &region_size, VM_REGION_BASIC_INFO_64,
+	                   reinterpret_cast<vm_region_info_t>(&info), &count, &object_name);
+	if (kr != KERN_SUCCESS) {
+		return false; // no region at or above the address → unmapped
+	}
+	return region_addr < (query_addr + length);
+}
+#else
 static bool is_mapped(void* ptr, size_t length) {
 	FILE* file = fopen("/proc/self/maps", "r");
 	char  line[1024];
@@ -189,6 +306,7 @@ static bool is_mapped(void* ptr, size_t length) {
 	fclose(file);
 	return ret;
 }
+#endif
 
 bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode mode) {
 	EXIT_IF(g_allocs == nullptr);
@@ -218,9 +336,9 @@ bool SysVirtualAllocFixed(uint64_t address, uint64_t size, VirtualMemory::Mode m
 
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
-		(*g_allocs)[ret_addr] = size;
+		record_alloc(ret_addr, size);
-		uintptr_t page_start  = ret_addr >> 12u;
+		uintptr_t page_start = ret_addr >> 12u;
-		uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
+		uintptr_t page_end   = (ret_addr + size - 1) >> 12u;
 		for (uintptr_t page = page_start; page <= page_end; page++) {
 			(*g_protects)[page] = protect;
 		}
@@ -249,18 +367,44 @@ uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alig
 
 	auto addr = static_cast<uintptr_t>(address);
 
-	void* ptr = mmap(reinterpret_cast<void*>(addr), size, PROT_NONE,
+	void* ptr = map_anonymous(addr, size, PROT_NONE, MAP_PRIVATE | MAP_ANON | MAP_NORESERVE);
-	                 MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); // NOLINT
 
 	auto ret_addr = reinterpret_cast<uintptr_t>(ptr);
 
 	if (ptr != MAP_FAILED && ((ret_addr & (alignment - 1)) != 0)) {
 		munmap(ptr, size);
 
-		ptr      = mmap(reinterpret_cast<void*>(addr), size + alignment, PROT_NONE,
+		ptr      = map_anonymous(addr, size + alignment, PROT_NONE,
-		                MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0); // NOLINT
+		                         MAP_PRIVATE | MAP_ANON | MAP_NORESERVE);
 		ret_addr = reinterpret_cast<uintptr_t>(ptr);
 		if (ptr != MAP_FAILED) {
+#if defined(__APPLE__)
+			// Carve the aligned subrange out of the live reservation with MAP_FIXED (an
+			// in-place replacement), then trim the slack. The range must never be
+			// returned to the OS in between: another thread (dyld, Rosetta, Metal,
+			// malloc) could claim the hole, and the subsequent MAP_FIXED would silently
+			// destroy its mapping. Other platforms keep the original path below.
+			auto aligned_addr = align_up(ret_addr, alignment);
+			// NOLINTNEXTLINE
+			void* fixed = mmap(reinterpret_cast<void*>(aligned_addr), size, PROT_NONE,
+			                   MAP_FIXED | MAP_PRIVATE | MAP_ANON | MAP_NORESERVE, -1, 0);
+			if (fixed == MAP_FAILED) {
+				munmap(ptr, size + alignment);
+				ret_addr = 0;
+				ptr      = MAP_FAILED;
+			} else {
+				if (aligned_addr > ret_addr) {
+					munmap(reinterpret_cast<void*>(ret_addr), aligned_addr - ret_addr);
+				}
+				const uintptr_t tail_start = aligned_addr + size;
+				const uintptr_t resv_end   = ret_addr + size + alignment;
+				if (resv_end > tail_start) {
+					munmap(reinterpret_cast<void*>(tail_start), resv_end - tail_start);
+				}
+				ptr      = fixed;
+				ret_addr = aligned_addr;
+			}
+#else
 			munmap(ptr, size + alignment);
 			auto aligned_addr = align_up(ret_addr, alignment);
 #ifdef KYTY_FIXED_NOREPLACE
@@ -278,6 +422,7 @@ uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alig
 				ret_addr = 0;
 				ptr      = MAP_FAILED;
 			}
+#endif
 		}
 	}
 
@@ -286,12 +431,7 @@ uint64_t SysVirtualReserveAligned(uint64_t address, uint64_t size, uint64_t alig
 	}
 
 	pthread_mutex_lock(&g_virtual_mutex);
-	(*g_allocs)[ret_addr] = size;
+	record_alloc(ret_addr, size);
-	uintptr_t page_start  = ret_addr >> 12u;
-	uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-	for (uintptr_t page = page_start; page <= page_end; page++) {
-		(*g_protects)[page] = PROT_NONE;
-	}
 	pthread_mutex_unlock(&g_virtual_mutex);
 
 	return ret_addr;
@@ -324,12 +464,7 @@ bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 
 	if (ptr != MAP_FAILED) {
 		pthread_mutex_lock(&g_virtual_mutex);
-		(*g_allocs)[ret_addr] = size;
+		record_alloc(ret_addr, size);
-		uintptr_t page_start  = ret_addr >> 12u;
-		uintptr_t page_end    = (ret_addr + size - 1) >> 12u;
-		for (uintptr_t page = page_start; page <= page_end; page++) {
-			(*g_protects)[page] = PROT_NONE;
-		}
 		pthread_mutex_unlock(&g_virtual_mutex);
 
 		return true;
@@ -339,7 +474,29 @@ bool SysVirtualReserveFixed(uint64_t address, uint64_t size) {
 }
 
 bool SysVirtualDecommit(uint64_t address, uint64_t size) {
-	return SysVirtualProtect(address, size, VirtualMemory::Mode::NoAccess);
+	// Drop physical pages while preserving the reservation.
+	if (!SysVirtualProtect(address, size, VirtualMemory::Mode::NoAccess)) {
+		return false;
+	}
+
+	if (size != 0) {
+#if defined(__APPLE__)
+		constexpr int RECLAIM_ADVICE = MADV_FREE;
+#else
+		constexpr int RECLAIM_ADVICE = MADV_DONTNEED;
+#endif
+		const auto page_size = static_cast<uintptr_t>(sysconf(_SC_PAGESIZE));
+		if (page_size != 0) {
+			// Do not discard pages outside the requested range.
+			const auto begin = (static_cast<uintptr_t>(address) + page_size - 1) & ~(page_size - 1);
+			const auto end   = (static_cast<uintptr_t>(address) + size) & ~(page_size - 1);
+			if (end > begin) {
+				::madvise(reinterpret_cast<void*>(begin), end - begin, RECLAIM_ADVICE);
+			}
+		}
+	}
+
+	return true;
 }
 
 bool SysVirtualFree(uint64_t address) {
@@ -391,15 +548,34 @@ bool SysVirtualFreeRange(uint64_t address, uint64_t size) {
 		pthread_mutex_unlock(&g_virtual_mutex);
 		return false;
 	}
-	auto       it         = std::prev(next);
+
-	const auto alloc_addr = it->first;
+	// A reservation may have been split into several adjacent records.
-	const auto alloc_end  = alloc_addr + it->second;
+	auto       first      = std::prev(next);
-	if (addr < alloc_addr || end > alloc_end || munmap(reinterpret_cast<void*>(addr), size) != 0) {
+	const auto alloc_addr = first->first;
+	if (addr < alloc_addr || alloc_addr + first->second <= addr) {
 		pthread_mutex_unlock(&g_virtual_mutex);
 		return false;
 	}
 
-	g_allocs->erase(it);
+	auto      last   = first;
+	uintptr_t cursor = alloc_addr + first->second;
+	while (cursor < end) {
+		auto following = std::next(last);
+		if (following == g_allocs->end() || following->first != cursor) {
+			pthread_mutex_unlock(&g_virtual_mutex);
+			return false;
+		}
+		last   = following;
+		cursor = following->first + following->second;
+	}
+	const auto alloc_end = cursor;
+
+	if (munmap(reinterpret_cast<void*>(addr), size) != 0) {
+		pthread_mutex_unlock(&g_virtual_mutex);
+		return false;
+	}
+
+	g_allocs->erase(first, std::next(last));
 	if (alloc_addr < addr) {
 		(*g_allocs)[alloc_addr] = addr - alloc_addr;
 	}

src/common/platform/sysTimer.h

@@ -27,7 +27,9 @@ struct SysFileTimeStruct {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	FILETIME time;
 #elif KYTY_PLATFORM == KYTY_PLATFORM_LINUX
+	// Nanoseconds preserve sub-second file timestamps.
 	time_t time;
+	long   nanos;
 #endif
 	bool is_invalid;
 };
@@ -139,7 +141,7 @@ inline void SysFileToSystemTimeUtc(const SysFileTimeStruct& f, SysTimeStruct& t)
 	t.Hour         = i.tm_hour;
 	t.Minute       = i.tm_min;
 	t.Second       = (i.tm_sec == 60 ? 59 : i.tm_sec);
-	t.Milliseconds = 0;
+	t.Milliseconds = static_cast<uint16_t>((f.nanos / 1000000) % 1000);
 }
 
 inline void SysTimeTToSystem(time_t t, SysTimeStruct& s) {
@@ -168,10 +170,11 @@ inline void SysSystemToFileTimeUtc(const SysTimeStruct& f, SysFileTimeStruct& t)
 
 // Retrieves the current local date and time.
 inline void SysGetSystemTime(SysTimeStruct& t) {
-	time_t    st {};
+	// Preserve millisecond precision.
+	timespec  now {};
 	struct tm i {};
 
-	if (time(&st) == static_cast<time_t>(-1) || localtime_r(&st, &i) == nullptr) {
+	if (clock_gettime(CLOCK_REALTIME, &now) != 0 || localtime_r(&now.tv_sec, &i) == nullptr) {
 		t.is_invalid = true;
 		return;
 	}
@@ -183,15 +186,16 @@ inline void SysGetSystemTime(SysTimeStruct& t) {
 	t.Hour         = i.tm_hour;
 	t.Minute       = i.tm_min;
 	t.Second       = (i.tm_sec == 60 ? 59 : i.tm_sec);
-	t.Milliseconds = 0;
+	t.Milliseconds = static_cast<uint16_t>((now.tv_nsec / 1000000) % 1000);
 }
 
 // Retrieves the current system date and time in Coordinated Universal Time (UTC).
 inline void SysGetSystemTimeUtc(SysTimeStruct& t) {
-	time_t    st {};
+	// Preserve millisecond precision.
+	timespec  now {};
 	struct tm i {};
 
-	if (time(&st) == static_cast<time_t>(-1) || gmtime_r(&st, &i) == nullptr) {
+	if (clock_gettime(CLOCK_REALTIME, &now) != 0 || gmtime_r(&now.tv_sec, &i) == nullptr) {
 		t.is_invalid = true;
 		return;
 	}
@@ -203,7 +207,7 @@ inline void SysGetSystemTimeUtc(SysTimeStruct& t) {
 	t.Hour         = i.tm_hour;
 	t.Minute       = i.tm_min;
 	t.Second       = (i.tm_sec == 60 ? 59 : i.tm_sec);
-	t.Milliseconds = 0;
+	t.Milliseconds = static_cast<uint16_t>((now.tv_nsec / 1000000) % 1000);
 }
 
 inline void SysQueryPerformanceFrequency(uint64_t* freq) {

src/common/threads.cpp

@@ -5,6 +5,7 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cerrno>
 #include <chrono>             // IWYU pragma: keep
 #include <condition_variable> // IWYU pragma: keep
 #include <mutex>
@@ -14,6 +15,12 @@
 #define KYTY_WIN_CS
 #endif
 
+// macOS has no clock_nanosleep.
+#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS && !defined(__APPLE__)
+#define KYTY_POSIX_HIGH_RES_SLEEP
+#include <ctime>
+#endif
+
 #include <sstream>
 #include <string>
 #include <thread>
@@ -121,6 +128,42 @@ static SleepConditionVariableCS_func_t ResolveSleepConditionVariableCS() {
 
 #endif
 
+#ifdef KYTY_POSIX_HIGH_RES_SLEEP
+// Spin for very short waits; use an absolute deadline for longer waits.
+static void SleepHighResolutionNanos(uint64_t nanos) {
+	if (nanos == 0) {
+		return;
+	}
+
+	constexpr uint64_t NANOS_PER_SEC = 1000000000;
+	constexpr uint64_t SPIN_LIMIT_NS = 50000; // below this a context switch dominates
+
+	timespec deadline {};
+	if (clock_gettime(CLOCK_MONOTONIC, &deadline) != 0) {
+		std::this_thread::sleep_for(std::chrono::nanoseconds(nanos));
+		return;
+	}
+
+	auto target_nsec = static_cast<uint64_t>(deadline.tv_nsec) + nanos;
+	deadline.tv_sec += static_cast<time_t>(target_nsec / NANOS_PER_SEC);
+	deadline.tv_nsec = static_cast<long>(target_nsec % NANOS_PER_SEC);
+
+	if (nanos <= SPIN_LIMIT_NS) {
+		timespec now {};
+		do {
+			if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
+				return;
+			}
+		} while (now.tv_sec < deadline.tv_sec ||
+		         (now.tv_sec == deadline.tv_sec && now.tv_nsec < deadline.tv_nsec));
+		return;
+	}
+
+	while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &deadline, nullptr) == EINTR) {
+	}
+}
+#endif
+
 namespace Common {
 
 using thread_id_t = std::thread::id;
@@ -249,6 +292,8 @@ void Thread::Sleep(uint32_t millis) {
 void Thread::SleepMicro(uint32_t micros) {
 #ifdef KYTY_WIN_CS
 	SleepHighResolution100ns(static_cast<uint64_t>(micros) * 10);
+#elif defined(KYTY_POSIX_HIGH_RES_SLEEP)
+	SleepHighResolutionNanos(static_cast<uint64_t>(micros) * 1000);
 #else
 	std::this_thread::sleep_for(std::chrono::microseconds(micros));
 #endif
@@ -257,6 +302,8 @@ void Thread::SleepMicro(uint32_t micros) {
 void Thread::SleepNano(uint64_t nanos) {
 #ifdef KYTY_WIN_CS
 	SleepHighResolution100ns((nanos + 99) / 100);
+#elif defined(KYTY_POSIX_HIGH_RES_SLEEP)
+	SleepHighResolutionNanos(nanos);
 #else
 	std::this_thread::sleep_for(std::chrono::nanoseconds(nanos));
 #endif

src/common/uniqueFunction.h

@@ -0,0 +1,54 @@
+#ifndef KYTY_COMMON_UNIQUEFUNCTION_H_
+#define KYTY_COMMON_UNIQUEFUNCTION_H_
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace Common {
+
+template <typename Result, typename... Args>
+class UniqueFunction {
+	class CallableBase {
+	public:
+		virtual ~CallableBase()               = default;
+		virtual Result Invoke(Args&&... args) = 0;
+	};
+
+	template <typename Function>
+	class Callable final: public CallableBase {
+	public:
+		explicit Callable(Function function): m_function(std::move(function)) {}
+
+		Result Invoke(Args&&... args) override { return m_function(std::forward<Args>(args)...); }
+
+	private:
+		Function m_function;
+	};
+
+public:
+	UniqueFunction() = default;
+
+	template <typename Function>
+	UniqueFunction(Function&& function)
+	    : m_callable(std::make_unique<Callable<std::decay_t<Function>>>(
+	          std::forward<Function>(function))) {}
+
+	UniqueFunction(UniqueFunction&&) noexcept            = default;
+	UniqueFunction& operator=(UniqueFunction&&) noexcept = default;
+	UniqueFunction(const UniqueFunction&)                = delete;
+	UniqueFunction& operator=(const UniqueFunction&)     = delete;
+
+	Result operator()(Args... args) const {
+		return m_callable->Invoke(std::forward<Args>(args)...);
+	}
+
+	explicit operator bool() const noexcept { return m_callable != nullptr; }
+
+private:
+	std::unique_ptr<CallableBase> m_callable;
+};
+
+} // namespace Common
+
+#endif // KYTY_COMMON_UNIQUEFUNCTION_H_

src/common/virtualMemory.cpp

@@ -58,25 +58,6 @@ bool FlushInstructionCache(uint64_t address, uint64_t size) {
 	return SysVirtualFlushInstructionCache(address, size);
 }
 
-bool PatchReplace(uint64_t vaddr, uint64_t value) {
-	Mode old_mode {};
-	Protect(vaddr, 8, Mode::ReadWrite, &old_mode);
-
-	auto* ptr = reinterpret_cast<uint64_t*>(vaddr);
-
-	bool ret = (*ptr != value);
-
-	*ptr = value;
-
-	Protect(vaddr, 8, old_mode);
-
-	if (IsExecute(old_mode)) {
-		FlushInstructionCache(vaddr, 8);
-	}
-
-	return ret;
-}
-
 } // namespace VirtualMemory
 
 } // namespace Common

src/common/virtualMemory.h

@@ -37,7 +37,6 @@ bool     Free(uint64_t address);
 bool     FreeRange(uint64_t address, uint64_t size);
 bool     Protect(uint64_t address, uint64_t size, Mode mode, Mode* old_mode = nullptr);
 bool     FlushInstructionCache(uint64_t address, uint64_t size);
-bool     PatchReplace(uint64_t vaddr, uint64_t value);
 
 } // namespace VirtualMemory
 

src/emulator.cpp

@@ -105,7 +105,7 @@ static void ClearDebugTextureFolder() {
 	}
 }
 
-static void Init(const Config::ConfigOptions& cfg) {
+static void Init(const Config::ConfigOptions& cfg, const std::filesystem::path& param_json) {
 	EXIT_IF(!Common::Thread::IsMainThread());
 
 	auto* slist = Common::SubsystemsList::Instance();
@@ -127,12 +127,21 @@ static void Init(const Config::ConfigOptions& cfg) {
 	slist->InitAll(true);
 
 	Config::Load(cfg);
+	slist->Add(log, {core, config});
+	slist->InitAll(true);
+
+	if (Common::File::IsFileExisting(param_json)) {
+		Loader::SystemContentLoadParamSfo(param_json);
+		if (const auto flexible_memory_size = Loader::SystemContentGetFlexibleMemorySize();
+		    flexible_memory_size != 0) {
+			Libs::LibKernel::Memory::SetFlexibleMemorySize(flexible_memory_size);
+		}
+	}
 
 	slist->Add(audio, {core, log, pthread, memory});
 	slist->Add(controller, {core, log, config});
 	slist->Add(file_system, {core, log, pthread});
 	slist->Add(graphics, {core, log, pthread, memory, config, profiler, controller});
-	slist->Add(log, {core, config});
 	slist->Add(memory, {core, log});
 	slist->Add(network, {core, log, pthread});
 	slist->Add(profiler, {core, config});
@@ -159,25 +168,16 @@ static void LoadElf(const std::filesystem::path& elf, bool dbg_print_reloc = fal
 	}
 }
 
-static void Execute() {
+static void Execute(const std::filesystem::path& game_patch) {
-	int thread_model = 1;
+	auto           patch_path = game_patch;
-
+	Common::Thread guest_thread(
-	if (thread_model == 0) {
+	    [](void* param) {
-		Common::Thread t([](void* /*unused*/) { Libs::Graphics::WindowRun(); }, nullptr);
+		    auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
-		t.Detach();
+		    rt->Execute(*static_cast<const std::filesystem::path*>(param));
-		auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
+	    },
-		rt->Execute();
+	    &patch_path);
-	} else {
+	Libs::Graphics::WindowRun();
-		Common::Thread t(
+	std::quick_exit(0);
-		    [](void* /*unused*/) {
-			    auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
-			    rt->Execute();
-		    },
-		    nullptr);
-		t.Detach();
-		Libs::Graphics::WindowRun();
-		t.Join();
-	}
 }
 
 void Run(const RunOptions& options) {
@@ -189,7 +189,8 @@ void Run(const RunOptions& options) {
 		EXIT("ELF is required\n");
 	}
 
-	Init(options.config);
+	const auto param_json = options.app0_dir / "sce_sys" / "param.json";
+	Init(options.config, param_json);
 
 	ClearDebugTextureFolder();
 
@@ -201,15 +202,6 @@ void Run(const RunOptions& options) {
 	Libs::LibKernel::FileSystem::Mount(options.app0_dir, "/app0");
 	Libs::LibKernel::FileSystem::Mount(options.app0_dir, "/hostapp");
 
-	auto param_json = options.app0_dir / "sce_sys" / "param.json";
-	if (Common::File::IsFileExisting(param_json)) {
-		Loader::SystemContentLoadParamSfo(param_json);
-		if (auto flexible_memory_size = Loader::SystemContentGetFlexibleMemorySize();
-		    flexible_memory_size != 0) {
-			Libs::LibKernel::Memory::SetFlexibleMemorySize(flexible_memory_size);
-		}
-	}
-
 	MountSandboxDirs();
 
 	auto* rt = Common::Singleton<Loader::RuntimeLinker>::Instance();
@@ -217,7 +209,7 @@ void Run(const RunOptions& options) {
 
 	LoadElf(options.elf);
 
-	Execute();
+	Execute(options.game_patch);
 }
 
 } // namespace Emulator

src/emulator.h

@@ -12,6 +12,7 @@ struct RunOptions {
 	Config::ConfigOptions config;
 	std::filesystem::path app0_dir;
 	std::filesystem::path elf;
+	std::filesystem::path game_patch;
 };
 
 void Run(const RunOptions& options);

src/generate_version.cmake

@@ -1,8 +1,15 @@
-#message("${GIT_EXECUTABLE}")
+set(KYTY_GIT_VERSION "unknown")
 if(GIT_EXECUTABLE)
-	execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --always OUTPUT_VARIABLE KYTY_GIT_VERSION)
+	execute_process(
-else()
+		COMMAND "${GIT_EXECUTABLE}" describe --tags --always
-	set(KYTY_GIT_VERSION "unknown")
+		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
+		OUTPUT_VARIABLE KYTY_GIT_VERSION
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+		RESULT_VARIABLE GIT_RESULT
+		ERROR_QUIET
+	)
+	if(NOT GIT_RESULT EQUAL 0)
+		set(KYTY_GIT_VERSION "unknown")
+	endif()
 endif()
-string(STRIP ${KYTY_GIT_VERSION} KYTY_GIT_VERSION)
+configure_file("${INPUT_FILE}" "${OUTPUT_FILE}")
-configure_file(${INPUT_FILE} ${OUTPUT_FILE})

src/graphics/asyncJob.h

@@ -1,96 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_ASYNCJOB_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_ASYNCJOB_H_
-
-#include "common/common.h"
-#include "common/profiler.h"
-#include "common/threads.h"
-
-#include <functional>
-#include <string>
-#include <utility>
-
-namespace Libs::Graphics {
-
-class AsyncJob final {
-public:
-	using Task = std::function<void()>;
-
-	explicit AsyncJob(std::string thread_name = {})
-	    : m_thread_name(std::move(thread_name)), m_worker_thread(WorkerEntry, this) {}
-
-	~AsyncJob() {
-		{
-			Common::LockGuard lock(m_mutex);
-			m_stop_requested = true;
-			m_task_available_condition.Signal();
-		}
-
-		m_worker_thread.Join();
-	}
-
-	KYTY_CLASS_NO_COPY(AsyncJob);
-
-	void Execute(Task task) {
-		Common::LockGuard lock(m_mutex);
-		while (m_is_busy) {
-			m_idle_condition.Wait(&m_mutex);
-		}
-
-		m_task    = std::move(task);
-		m_is_busy = true;
-		m_task_available_condition.Signal();
-	}
-
-	void Wait() {
-		Common::LockGuard lock(m_mutex);
-		while (m_is_busy) {
-			m_idle_condition.Wait(&m_mutex);
-		}
-	}
-
-private:
-	static void WorkerEntry(void* data) { static_cast<AsyncJob*>(data)->WorkerLoop(); }
-
-	void WorkerLoop() {
-		if (!m_thread_name.empty()) {
-			KYTY_PROFILER_THREAD(m_thread_name.c_str());
-		}
-
-		for (;;) {
-			Task task;
-			{
-				Common::LockGuard lock(m_mutex);
-				while (!m_is_busy && !m_stop_requested) {
-					m_task_available_condition.Wait(&m_mutex);
-				}
-
-				if (!m_is_busy) {
-					return;
-				}
-
-				task = std::move(m_task);
-			}
-
-			task();
-
-			{
-				Common::LockGuard lock(m_mutex);
-				m_is_busy = false;
-				m_idle_condition.SignalAll();
-			}
-		}
-	}
-
-	std::string     m_thread_name;
-	Common::Mutex   m_mutex;
-	Common::CondVar m_task_available_condition;
-	Common::CondVar m_idle_condition;
-	Task            m_task;
-	bool            m_is_busy        = false;
-	bool            m_stop_requested = false;
-	Common::Thread  m_worker_thread;
-};
-
-} // namespace Libs::Graphics
-
-#endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_ASYNCJOB_H_ */

src/graphics/guest_gpu/command_processor/commandProcessor.h

@@ -2,109 +2,36 @@
 #define GRAPHICS_GUEST_GPU_COMMAND_PROCESSOR_COMMAND_PROCESSOR_H
 
 #include "common/assert.h"
-#include "common/threads.h"
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 
-#include <array>
 #include <cstdint>
 #include <vector>
 
 namespace Libs::Graphics {
 
-inline constexpr uint32_t AcquireGcrGl2Writeback = 1u << 15u;
-
 bool TestWaitRegMemValue(uint64_t value, uint64_t ref, uint64_t mask, uint32_t func);
 
-class CommandScheduler {
+enum class Pm4ProcessResult { Complete, Blocked };
+
+class Pm4Execution {
 public:
-	static constexpr int BuffersNum = 8;
+	[[nodiscard]] bool MadeProgress() const noexcept { return m_made_progress; }
-
-	CommandScheduler(HW::Context& registers, HW::UserConfig& user_config, HW::Shader& shaders)
-	    : m_registers(registers), m_user_config(user_config), m_shaders(shaders) {}
-
-	bool Active() const { return m_current >= 0 && m_current < BuffersNum; }
-	void CheckActive() const { EXIT_IF(!Active()); }
-
-	RenderCommandBuffer& Current() const {
-		CheckActive();
-		EXIT_IF(m_buffers[m_current] == nullptr);
-		return *m_buffers[m_current];
-	}
-
-	void Init() {
-		if (m_current >= 0) {
-			return;
-		}
-		for (auto& buf: m_buffers) {
-			EXIT_IF(buf != nullptr);
-			buf = new RenderCommandBuffer(m_registers, m_user_config, m_shaders);
-		}
-		m_current = 0;
-		Current().Begin();
-	}
-
-	void Flush() {
-		SubmitCurrent();
-		BeginNext();
-	}
-
-	CommandBuffer& FlushAndGetSubmitted() {
-		auto& submitted = SubmitCurrent();
-		BeginNext();
-		return submitted;
-	}
-
-	void CopyBuffers(std::array<CommandBuffer*, BuffersNum>& out) const {
-		for (int i = 0; i < BuffersNum; i++) {
-			auto* buf = m_buffers[i];
-			EXIT_IF(buf == nullptr);
-			out[i] = buf;
-		}
-	}
-
-	void WaitAll() {
-		for (auto* buf: m_buffers) {
-			EXIT_IF(buf == nullptr);
-			buf->WaitForFenceAndReset();
-		}
-	}
-
-	void SubmitForReadback() {
-		if (!Active()) {
-			return;
-		}
-		SubmitCurrent();
-	}
-
-	void ResumeAfterReadback() {
-		if (!Active()) {
-			return;
-		}
-		Current().WaitForFenceAndReset();
-		Current().Begin();
-	}
 
 private:
-	CommandBuffer& SubmitCurrent() {
+	friend class CommandProcessor;
-		auto& submitted = Current();
-		submitted.End();
-		submitted.Execute();
-		return submitted;
-	}
 
-	void BeginNext() {
+	struct BufferCursor {
-		m_current = (m_current + 1) % BuffersNum;
+		uint32_t* next_packet         = nullptr;
-		Current().WaitForFenceAndReset();
+		uint32_t  remaining_dw        = 0;
-		Current().Begin();
+		uint32_t  total_dw            = 0;
-	}
+		uint32_t  deferred_advance_dw = 0;
+	};
 
-	RenderCommandBuffer* m_buffers[BuffersNum] = {};
+	std::vector<BufferCursor> m_buffer_stack;
-	int                  m_current             = -1;
+	bool                      m_suspended     = false;
-	HW::Context&         m_registers;
+	bool                      m_made_progress = false;
-	HW::UserConfig&      m_user_config;
-	HW::Shader&          m_shaders;
 };
 
 class CommandProcessor {
@@ -116,8 +43,8 @@ public:
 		int64_t flip_arg  = 0;
 	};
 
-	CommandProcessor();
+	explicit CommandProcessor(RenderContext& renderer): m_renderer(renderer) {}
-	~CommandProcessor() { KYTY_NOT_IMPLEMENTED; }
+	~CommandProcessor() = default;
 
 	KYTY_CLASS_NO_COPY(CommandProcessor);
 
@@ -128,26 +55,18 @@ public:
 	void BufferFlushAndWait();
 	void BufferWait();
 	void BeginReadbackTransaction() {
-		m_mutex.Lock();
 		if (m_readback_active) {
 			EXIT("nested command-processor readback transaction\n");
 		}
-		m_readback_active   = true;
+		m_readback_active = true;
-		m_readback_finished = false;
 	}
-	void FinishReadbackTransaction();
 	void EndReadbackTransaction() {
 		if (!m_readback_active) {
 			EXIT("command-processor readback transaction is not active\n");
 		}
-		m_readback_active   = false;
+		m_readback_active = false;
-		m_readback_finished = false;
-		m_mutex.Unlock();
 	}
 
-	void RunLock() { m_run_mutex.Lock(); }
-	void RunUnlock() { m_run_mutex.Unlock(); }
-
 	HW::Context&    GetCtx() { return m_ctx; }
 	HW::UserConfig& GetUcfg() { return m_ucfg; }
 	HW::Shader&     GetShCtx() { return m_sh_ctx; }
@@ -164,8 +83,7 @@ public:
 	               uint32_t first_instance = 0);
 	void DrawIndexOffset(uint32_t index_offset, uint32_t index_count, uint32_t flags);
 	void DrawIndexAuto(uint32_t index_count, uint32_t flags,
-	                   uint32_t render_target_slice_offset = 0, uint32_t instance_count = 1,
+	                   uint32_t render_target_slice_offset = 0);
-	                   uint32_t first_vertex = 0, uint32_t first_instance = 0);
 	void DrawIndirect(uint32_t data_offset, uint32_t draw_initiator, bool indexed);
 	void DrawIndirectMulti(uint32_t data_offset, uint32_t max_count_or_count,
 	                       const volatile uint32_t* count_addr, uint32_t stride_in_bytes,
@@ -182,12 +100,10 @@ public:
 	void Flip(void* dst_gpu_addr, uint32_t value);
 	void FlipWithInterrupt(uint32_t eop_event_type, uint32_t cache_action, void* dst_gpu_addr,
 	                       uint32_t value);
-	void PrepareCpuFlip();
+	void PrepareCpuFlip(uint64_t request_id);
 	void SynchronizeGpu();
-	void MemoryBarrier();
+	void EmitGlobalBarrier();
 	void TriggerEopEventAtEndOfPipe(uint32_t interrupt_context_id);
-	void RenderTextureBarrier(uint64_t vaddr, uint64_t size);
-	void DepthStencilBarrier(uint64_t vaddr, uint64_t size);
 	void DispatchDirect(uint32_t thread_group_x, uint32_t thread_group_y, uint32_t thread_group_z,
 	                    uint32_t mode);
 	void DispatchIndirect(uint32_t data_offset, uint32_t mode);
@@ -196,16 +112,13 @@ public:
 
 	void SetUserDataMarker(HW::UserSgprType type) { m_user_data_marker = type; }
 	[[nodiscard]] HW::UserSgprType GetUserDataMarker() const { return m_user_data_marker; }
-	void SetEmbeddedDataMarker(const uint32_t* buffer, uint32_t num_dw, uint32_t align) {}
-	void PushMarker(const char* str) {}
-	void PopMarker() {}
 
-	void PrefetchL2(void* addr, uint32_t size) {}
 	void ResetDeCe();
+	void SetCeComplete(bool complete) { m_ce_complete = complete; }
 	void WaitCe();
 	void WaitDeDiff(uint32_t diff);
-	void IncremenetDe();
+	void IncrementDe();
-	void IncremenetCe();
+	void IncrementCe();
 
 	void WriteConstRam(uint32_t offset, const uint32_t* src, uint32_t dw_num);
 	void DumpConstRam(uint32_t* dst, uint32_t offset, uint32_t dw_num);
@@ -222,32 +135,32 @@ public:
 	                    const volatile void* address, uint32_t count_in_dwords);
 	[[nodiscard]] bool ShouldSkipPredicatedPackets() const { return m_predicate_skip; }
 
-	void Run(uint32_t* data, uint32_t num_dw);
+	Pm4ProcessResult Process(Pm4Execution& execution, uint32_t* buffer, uint32_t size_dw);
+	void             ProcessIndirectBuffer(uint32_t* buffer, uint32_t size_dw);
 
-	[[nodiscard]] const FlipInfo& GetFlip() const { return m_flip; }
+	void SetFlip(const FlipInfo& flip) { m_flip = flip; }
-	void                          SetFlip(const FlipInfo& flip) { m_flip = flip; }
 
 	[[nodiscard]] uint64_t GetSubmitId() const { return m_submit_id; }
 	void                   SetSubmitId(uint64_t submit_id) { m_submit_id = submit_id; }
 
 private:
-	struct Counter {
-		Common::Mutex   mutex;
-		Common::CondVar cond_var;
-		uint32_t        value = 0;
-	};
-
 	template <typename T>
 	void WriteAtEndOfPipe(uint32_t cache_policy, uint32_t event_write_dest, uint32_t eop_event_type,
 	                      uint32_t cache_action, uint32_t event_index, uint32_t event_write_source,
 	                      void* dst_gpu_addr, T value, uint32_t interrupt_selector,
 	                      uint32_t interrupt_context_id);
-	void FinishCommandProcessors();
+	void ProcessPm4(Pm4Execution& execution, size_t stop_depth);
+	void SuspendPm4();
+	void SubmitNonIndexedDraw(uint32_t vertex_count, uint32_t flags,
+	                          uint32_t render_target_slice_offset, uint32_t first_vertex,
+	                          uint32_t first_instance);
 
-	RenderCommandBuffer& CurrentBuffer() { return m_scheduler.Current(); }
+	CommandScheduler&    GetScheduler() const { return m_renderer.GetCommandScheduler(); }
-	void                 CheckBuffer() const { m_scheduler.CheckActive(); }
+	RenderCommandBuffer& CurrentBuffer() { return GetScheduler().Current(); }
-	GpuResourceManager&  GetGpuResources() const { return GetRenderContext().GetGpuResources(); }
+	void                 CheckBuffer() const { GetScheduler().CheckActive(); }
+	GpuResourceManager&  GetGpuResources() const { return m_renderer.GetGpuResources(); }
 
+	RenderContext&   m_renderer;
 	HW::Context      m_ctx;
 	HW::UserConfig   m_ucfg;
 	HW::Shader       m_sh_ctx;
@@ -257,18 +170,13 @@ private:
 	uint64_t         m_index_base_addr                  = 0;
 	uint64_t         m_draw_indirect_args_base_addr     = 0;
 	uint64_t         m_dispatch_indirect_args_base_addr = 0;
-	uint32_t         m_num_instances                    = 1;
+	// Persistent draw state: indirect draws update it for subsequent draws.
+	uint32_t m_num_instances = 1;
 
-	inline static Common::Mutex                  m_mutex;
+	uint32_t m_de_count        = 0;
-	inline static std::vector<CommandProcessor*> m_processors;
+	uint32_t m_ce_count        = 0;
-	inline static bool                           m_readback_active   = false;
+	bool     m_ce_complete     = false;
-	inline static bool                           m_readback_finished = false;
+	bool     m_readback_active = false;
-	Common::Mutex                                m_run_mutex;
-
-	CommandScheduler m_scheduler;
-
-	Counter m_de_counter;
-	Counter m_ce_counter;
 
 	uint32_t m_const_ram[0x3000] = {0};
 

src/graphics/guest_gpu/command_processor/pm4Handlers.cpp

@@ -6,7 +6,6 @@
 #include "graphics/guest_gpu/command_processor/pm4Dispatch.h"
 #include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/objects/label.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/presentation/videoOut.h"
@@ -66,10 +65,23 @@ constexpr uint32_t GcrKnownMask             = GcrGl2MetadataInvalidate | GcrGl0V
                                               GcrGl2Writeback | GcrOrder012 | GcrOrder210;
 constexpr uint32_t RegisterSelectorMask     = 0x70000000u;
 
-uint32_t NormalizeRegisterOffset(uint32_t raw_offset) {
+constexpr uint32_t NormalizeRegisterOffset(uint32_t raw_offset) {
-	return (raw_offset & ~RegisterSelectorMask);
+	return raw_offset & ~RegisterSelectorMask;
 }
 
+// Indirect Cx descriptors retain their selector. Selector 1 offsets 0..31 address the
+// SPI_PS_INPUT_CNTL register bank; ordinary context-register offsets remain unchanged.
+constexpr uint32_t DecodeIndirectCxRegisterOffset(uint32_t raw_offset) {
+	const auto offset = NormalizeRegisterOffset(raw_offset);
+	return (raw_offset & RegisterSelectorMask) == Pm4::CX_PS_SHADER_USAGE_BASE && offset < 32u
+	           ? Pm4::SPI_PS_INPUT_CNTL_0 + offset
+	           : offset;
+}
+
+static_assert(DecodeIndirectCxRegisterOffset(Pm4::CX_PS_SHADER_USAGE_BASE + 2u) ==
+              Pm4::SPI_PS_INPUT_CNTL_0 + 2u);
+static_assert(DecodeIndirectCxRegisterOffset(Pm4::DB_Z_INFO) == Pm4::DB_Z_INFO);
+
 bool ReleaseMemGcrNeedsBarrier(uint32_t eop_event_type, uint32_t gcr_cntl) {
 	return eop_event_type != 0x28u ||
 	       (gcr_cntl & (GcrGl2MetadataInvalidate | GcrGl0VectorInvalidate | GcrGl1Invalidate |
@@ -598,30 +610,7 @@ KYTY_HW_CTX_PARSER(HwCtxSetDepthRenderTarget) {
 	uint32_t count = 1;
 
 	if (cmd_id == 0xC0016900) {
-		HW::DepthZInfo r;
+		cp.GetCtx().SetDepthZInfo(HW::DepthZInfo::Decode(buffer[0]));
-
-		//	r.expclear_enabled = (buffer[0] & 0x08000000u) != 0;
-		//	r.format              = (buffer[0] >> Pm4::DB_Z_INFO_FORMAT_SHIFT) &
-		// Pm4::DB_Z_INFO_FORMAT_MASK; 	r.num_samples         = (buffer[0] >>
-		// Pm4::DB_Z_INFO_NUM_SAMPLES_SHIFT) & Pm4::DB_Z_INFO_NUM_SAMPLES_MASK; r.tile_mode_index =
-		//(buffer[0] >> Pm4::DB_Z_INFO_TILE_MODE_INDEX_SHIFT) & Pm4::DB_Z_INFO_TILE_MODE_INDEX_MASK;
-		//	r.tile_surface_enable = ((buffer[0] >> Pm4::DB_Z_INFO_TILE_SURFACE_ENABLE_SHIFT) &
-		// Pm4::DB_Z_INFO_TILE_SURFACE_ENABLE_MASK) !=0
-		// 	r.zrange_precision    = (buffer[0] >> Pm4::DB_Z_INFO_ZRANGE_PRECISION_SHIFT) &
-		// Pm4::DB_Z_INFO_ZRANGE_PRECISION_MASK;
-
-		r.format                    = KYTY_PM4_GET(buffer[0], DB_Z_INFO, FORMAT);
-		r.num_samples               = KYTY_PM4_GET(buffer[0], DB_Z_INFO, NUM_SAMPLES);
-		r.embedded_sample_locations = KYTY_PM4_GET(buffer[0], DB_Z_INFO, ITERATE_FLUSH) != 0;
-		r.partially_resident        = KYTY_PM4_GET(buffer[0], DB_Z_INFO, PARTIALLY_RESIDENT) != 0;
-		r.num_mip_levels            = KYTY_PM4_GET(buffer[0], DB_Z_INFO, MAXMIP);
-		r.tile_mode_index           = KYTY_PM4_GET(buffer[0], DB_Z_INFO, TILE_MODE_INDEX);
-		r.plane_compression         = KYTY_PM4_GET(buffer[0], DB_Z_INFO, DECOMPRESS_ON_N_ZPLANES);
-		r.expclear_enabled          = KYTY_PM4_GET(buffer[0], DB_Z_INFO, ALLOW_EXPCLEAR) != 0;
-		r.tile_surface_enable       = KYTY_PM4_GET(buffer[0], DB_Z_INFO, TILE_SURFACE_ENABLE) != 0;
-		r.zrange_precision          = KYTY_PM4_GET(buffer[0], DB_Z_INFO, ZRANGE_PRECISION);
-
-		cp.GetCtx().SetDepthZInfo(r);
 	} else if (cmd_id == 0xC0086900) {
 		if (dw >= 22 && buffer[8] == 0xC0016900 && buffer[9] == Pm4::DB_DEPTH_INFO &&
 		    buffer[11] == 0xC0016900 && buffer[12] == Pm4::DB_DEPTH_VIEW &&
@@ -632,51 +621,8 @@ KYTY_HW_CTX_PARSER(HwCtxSetDepthRenderTarget) {
 
 			HW::DepthRenderTarget z;
 
-			//			z.z_info.expclear_enabled    = (buffer[0] & 0x08000000u) != 0;
+			z.z_info       = HW::DepthZInfo::Decode(buffer[0]);
-			//			z.z_info.format              = (buffer[0] >> Pm4::DB_Z_INFO_FORMAT_SHIFT) &
+			z.stencil_info = HW::DepthStencilInfo::Decode(buffer[1]);
-			// Pm4::DB_Z_INFO_FORMAT_MASK; 			z.z_info.num_samples         = (buffer[0] >>
-			// Pm4::DB_Z_INFO_NUM_SAMPLES_SHIFT) & Pm4::DB_Z_INFO_NUM_SAMPLES_MASK;
-			//			z.z_info.tile_mode_index     = (buffer[0] >>
-			// Pm4::DB_Z_INFO_TILE_MODE_INDEX_SHIFT) &
-			// Pm4::DB_Z_INFO_TILE_MODE_INDEX_MASK; 			z.z_info.tile_surface_enable =
-			// KYTY_PM4_GET(buffer[0], DB_Z_INFO, TILE_SURFACE_ENABLE) != 0;
-			// z.z_info.zrange_precision    = (buffer[0] >> Pm4::DB_Z_INFO_ZRANGE_PRECISION_SHIFT) &
-			// Pm4::DB_Z_INFO_ZRANGE_PRECISION_MASK;
-
-			z.z_info.format      = KYTY_PM4_GET(buffer[0], DB_Z_INFO, FORMAT);
-			z.z_info.num_samples = KYTY_PM4_GET(buffer[0], DB_Z_INFO, NUM_SAMPLES);
-			z.z_info.embedded_sample_locations =
-			    KYTY_PM4_GET(buffer[0], DB_Z_INFO, ITERATE_FLUSH) != 0;
-			z.z_info.partially_resident =
-			    KYTY_PM4_GET(buffer[0], DB_Z_INFO, PARTIALLY_RESIDENT) != 0;
-			z.z_info.num_mip_levels  = KYTY_PM4_GET(buffer[0], DB_Z_INFO, MAXMIP);
-			z.z_info.tile_mode_index = KYTY_PM4_GET(buffer[0], DB_Z_INFO, TILE_MODE_INDEX);
-			z.z_info.plane_compression =
-			    KYTY_PM4_GET(buffer[0], DB_Z_INFO, DECOMPRESS_ON_N_ZPLANES);
-			z.z_info.expclear_enabled = KYTY_PM4_GET(buffer[0], DB_Z_INFO, ALLOW_EXPCLEAR) != 0;
-			z.z_info.tile_surface_enable =
-			    KYTY_PM4_GET(buffer[0], DB_Z_INFO, TILE_SURFACE_ENABLE) != 0;
-			z.z_info.zrange_precision = KYTY_PM4_GET(buffer[0], DB_Z_INFO, ZRANGE_PRECISION);
-
-			//			z.stencil_info.expclear_enabled     = (buffer[1] & 0x08000000u) != 0;
-			//			z.stencil_info.tile_split           = (buffer[1] >> 13u) & 0x7u;
-			//			z.stencil_info.format               = KYTY_PM4_GET(buffer[1],
-			// DB_STENCIL_INFO, FORMAT); 			z.stencil_info.tile_mode_index      =
-			// KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, TILE_MODE_INDEX);
-			//			z.stencil_info.tile_stencil_disable = KYTY_PM4_GET(buffer[1],
-			// DB_STENCIL_INFO, TILE_STENCIL_DISABLE);
-			z.stencil_info.format = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, FORMAT);
-			z.stencil_info.texture_compatible_stencil =
-			    KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, ITERATE_FLUSH) != 0;
-			z.stencil_info.partially_resident =
-			    KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, PARTIALLY_RESIDENT) != 0;
-			z.stencil_info.tile_split = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, RESERVED_FIELD_1);
-			z.stencil_info.tile_mode_index =
-			    KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, TILE_MODE_INDEX);
-			z.stencil_info.expclear_enabled =
-			    KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, ALLOW_EXPCLEAR) != 0;
-			z.stencil_info.tile_stencil_disable =
-			    KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, TILE_STENCIL_DISABLE) != 0;
 
 			z.z_read_base_addr        = static_cast<uint64_t>(buffer[2]) << 8u;
 			z.stencil_read_base_addr  = static_cast<uint64_t>(buffer[3]) << 8u;
@@ -1253,26 +1199,7 @@ KYTY_HW_CTX_PARSER(HwCtxSetStencilInfo) {
 	EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0016900);
 	EXIT_NOT_IMPLEMENTED(cmd_offset != Pm4::DB_STENCIL_INFO);
 
-	HW::DepthStencilInfo r;
+	cp.GetCtx().SetDepthStencilInfo(HW::DepthStencilInfo::Decode(buffer[0]));
-
-	//	r.expclear_enabled = (buffer[0] & 0x08000000u) != 0;
-	//	r.tile_split       = (buffer[0] >> 13u) & 0x7u;
-	//	r.format          = (buffer[0] >> Pm4::DB_STENCIL_INFO_FORMAT_SHIFT) &
-	// Pm4::DB_STENCIL_INFO_FORMAT_MASK; 	r.tile_mode_index = (buffer[0] >>
-	// Pm4::DB_STENCIL_INFO_TILE_MODE_INDEX_SHIFT) & Pm4::DB_STENCIL_INFO_TILE_MODE_INDEX_MASK;
-	//	r.tile_stencil_disable =
-	//	    ((buffer[0] >> Pm4::DB_STENCIL_INFO_TILE_STENCIL_DISABLE_SHIFT) &
-	// Pm4::DB_STENCIL_INFO_TILE_STENCIL_DISABLE_MASK) != 0;
-
-	r.format                     = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, FORMAT);
-	r.texture_compatible_stencil = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, ITERATE_FLUSH) != 0;
-	r.partially_resident   = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, PARTIALLY_RESIDENT) != 0;
-	r.tile_split           = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, RESERVED_FIELD_1);
-	r.tile_mode_index      = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, TILE_MODE_INDEX);
-	r.expclear_enabled     = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, ALLOW_EXPCLEAR) != 0;
-	r.tile_stencil_disable = KYTY_PM4_GET(buffer[1], DB_STENCIL_INFO, TILE_STENCIL_DISABLE) != 0;
-
-	cp.GetCtx().SetDepthStencilInfo(r);
 
 	return 1;
 }
@@ -1764,231 +1691,11 @@ static bool HwUcTrySetFakeRegisterRange(uint32_t cmd_offset, const uint32_t* buf
 	return true;
 }
 
-// NOLINTNEXTLINE(readability-function-cognitive-complexity)
 KYTY_CP_OP_PARSER(CpOpAcquireMem) {
 	KYTY_PROFILER_FUNCTION();
 
 	EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0055800 && cmd_id != 0xc0061050);
-
+	return (cmd_id == 0xc0061050 ? 7 : 6);
-	bool custom = (cmd_id == 0xc0061050);
-
-	uint32_t                  engine       = buffer[0] >> 31u;
-	uint32_t                  stall_mode   = (custom ? 1u : engine);
-	uint32_t                  cache_action = buffer[0] & 0x7fffffffu;
-	uint64_t                  size_lo      = buffer[1];
-	uint32_t                  size_hi      = buffer[2];
-	uint64_t                  base_lo      = buffer[3];
-	uint32_t                  base_hi      = buffer[4];
-	uint32_t                  poll         = buffer[5];
-	[[maybe_unused]] uint32_t gcr_cntl     = (custom ? buffer[6] : 0);
-
-	uint32_t target_mask     = cache_action & 0x00007FC0u;
-	uint32_t extended_action = cache_action & 0x2E000000u;
-	uint32_t action =
-	    ((cache_action & 0x00C00000u) >> 0x12u) | ((cache_action & 0x00058000u) >> 0xfu);
-
-	if (custom && engine > 1) {
-		LOGF("\t warning: custom acquire_mem unsupported engine: %" PRIu32 "\n", engine);
-	}
-
-	// EXIT_NOT_IMPLEMENTED(stall_mode != 1);
-	EXIT_NOT_IMPLEMENTED(size_hi != 0);
-	EXIT_NOT_IMPLEMENTED(base_hi != 0);
-	if (poll != 10) {
-		LOGF("\t warning: acquire_mem unexpected poll interval: %" PRIu32 "\n", poll);
-	}
-
-	switch (cache_action) {
-		case 0x00000000: {
-			if (custom && gcr_cntl != 0) {
-				LOGF("\t custom acquire_mem GCR-only barrier, gcr_cntl = 0x%08" PRIx32
-				     ", base = 0x%016" PRIx64 ", size = 0x%016" PRIx64 "\n",
-				     gcr_cntl, base_lo << 8u, size_lo << 8u);
-
-				cp.MemoryBarrier();
-				if ((gcr_cntl & AcquireGcrGl2Writeback) != 0) {
-					cp.SynchronizeGpu();
-				}
-			}
-		} break;
-		case 0x00000040:
-		case 0x00003fc0:
-		case 0x00004000:
-		case 0x00007fc0: {
-			// target_mask set, no CB/DB action bits. Treat as an ordering barrier.
-			EXIT_IF(target_mask != cache_action);
-			EXIT_IF(extended_action != 0x00000000);
-			EXIT_IF(action != 0x00);
-
-			LOGF("\t temporary: acquire_mem target-mask-only barrier, target_mask = 0x%08" PRIx32
-			     ", gcr_cntl = 0x%08" PRIx32 ", base = 0x%016" PRIx64 ", size = 0x%016" PRIx64 "\n",
-			     target_mask, gcr_cntl, base_lo << 8u, size_lo << 8u);
-
-			cp.MemoryBarrier();
-		} break;
-		case 0x02000000: {
-			// target_mask:     0x00000000 (none)
-			// extended_action: 0x02000000 (FlushAndInvalidateCbCache)
-			// action:          0x00 (none)
-			EXIT_IF(target_mask != 0x00000000);
-			EXIT_IF(extended_action != 0x02000000);
-			EXIT_IF(action != 0x00);
-
-			LOGF("\t temporary: acquire_mem CB-cache-only barrier, gcr_cntl = 0x%08" PRIx32
-			     ", base = 0x%016" PRIx64 ", size = 0x%016" PRIx64 "\n",
-			     gcr_cntl, base_lo << 8u, size_lo << 8u);
-
-			cp.MemoryBarrier();
-		} break;
-		case 0x04000000: {
-			// target_mask:     0x00000000 (none)
-			// extended_action: 0x04000000 (FlushAndInvalidateDbCache)
-			// action:          0x00 (none)
-			EXIT_IF(target_mask != 0x00000000);
-			EXIT_IF(extended_action != 0x04000000);
-			EXIT_IF(action != 0x00);
-
-			LOGF("\t temporary: acquire_mem DB-cache-only barrier, gcr_cntl = 0x%08" PRIx32
-			     ", base = 0x%016" PRIx64 ", size = 0x%016" PRIx64 "\n",
-			     gcr_cntl, base_lo << 8u, size_lo << 8u);
-
-			cp.MemoryBarrier();
-		} break;
-		case 0x04004000:
-		case 0x04007fc0: {
-			// target_mask:     0x00004000 (Depth Target), 0x00007fc0 (all rt and depth)
-			// extended_action: 0x04000000 (FlushAndInvalidateDbCache)
-			// action:          0x00 (none)
-			EXIT_IF(target_mask != 0x00004000 && target_mask != 0x00007FC0);
-			EXIT_IF(extended_action != 0x04000000);
-			EXIT_IF(action != 0x00);
-
-			LOGF("\t temporary: acquire_mem DB target barrier, target_mask = 0x%08" PRIx32
-			     ", gcr_cntl = 0x%08" PRIx32 ", base = 0x%016" PRIx64 ", size = 0x%016" PRIx64 "\n",
-			     target_mask, gcr_cntl, base_lo << 8u, size_lo << 8u);
-
-			if (size_lo != 0) {
-				cp.DepthStencilBarrier(base_lo << 8u, size_lo << 8u);
-			} else {
-				cp.MemoryBarrier();
-			}
-		} break;
-		case 0x02c40040:
-		case 0x02c43fc0:
-		case 0x02c47fc0: {
-			// target_mask:     0x00000040 (rt0), 0x00003fc0 (all rt), 0x00007fc0 (all rt and depth)
-			// extended_action: 0x02000000 (FlushAndInvalidateCbCache)
-			// action:          0x38 (WriteBackAndInvalidateL1andL2)
-			EXIT_IF(target_mask != 0x00000040 && target_mask != 0x00003FC0 &&
-			        target_mask != 0x00007FC0);
-			EXIT_IF(extended_action != 0x02000000);
-			EXIT_IF(action != 0x38);
-			EXIT_NOT_IMPLEMENTED(size_lo == 0);
-			EXIT_NOT_IMPLEMENTED(base_lo == 0);
-
-			cp.RenderTextureBarrier(base_lo << 8u, size_lo << 8u);
-			cp.SynchronizeGpu();
-		} break;
-		case 0x02003fc0:
-		case 0x02007fc0: {
-			// target_mask:     0x00003FC0 (all rt), 0x00007fc0 (all rt and depth)
-			// extended_action: 0x02000000 (FlushAndInvalidateCbCache)
-			// action:          0x00 (none)
-			EXIT_IF(target_mask != 0x00003FC0 && target_mask != 0x00007fc0);
-			EXIT_IF(extended_action != 0x02000000);
-			EXIT_IF(action != 0x00);
-
-			if (size_lo == 0) {
-				if (base_lo != 0) {
-					LOGF("\t warning: acquire_mem CB-cache barrier with non-zero base");
-				}
-
-				cp.MemoryBarrier();
-			} else {
-				EXIT_NOT_IMPLEMENTED(base_lo == 0);
-
-				cp.RenderTextureBarrier(base_lo << 8u, size_lo << 8u);
-			}
-		} break;
-		case 0x00C40000: {
-			// target_mask:     0x00000000 (none)
-			// extended_action: 0x00000000 (none)
-			// action:          0x38 (WriteBackAndInvalidateL1andL2)
-			EXIT_IF(target_mask != 0x00000000);
-			EXIT_IF(extended_action != 0x00000000);
-			EXIT_IF(action != 0x38);
-			EXIT_NOT_IMPLEMENTED(size_lo != 1);
-			EXIT_NOT_IMPLEMENTED(base_lo != 0);
-
-			cp.MemoryBarrier();
-			cp.SynchronizeGpu();
-		} break;
-		case 0x00400000: {
-			// target_mask:     0x00000000 (none)
-			// extended_action: 0x00000000 (none)
-			// action:          0x10 (InvalidateL1)
-			EXIT_IF(target_mask != 0x00000000);
-			EXIT_IF(extended_action != 0x00000000);
-			EXIT_IF(action != 0x10);
-			EXIT_NOT_IMPLEMENTED(size_lo != 1);
-			EXIT_NOT_IMPLEMENTED(base_lo != 0);
-
-			cp.MemoryBarrier();
-		} break;
-		case 0x04c44000: {
-			// target_mask:     0x00004000 (Depth Target)
-			// extended_action: 0x04000000 (FlushAndInvalidateDbCache)
-			// action:          0x38 (WriteBackAndInvalidateL1andL2)
-			EXIT_IF(target_mask != 0x00004000);
-			EXIT_IF(extended_action != 0x04000000);
-			EXIT_IF(action != 0x38);
-
-			cp.DepthStencilBarrier(base_lo << 8u, size_lo << 8u);
-			cp.SynchronizeGpu();
-		} break;
-
-		case 0x06000040:
-		case 0x06000080:
-		case 0x06003fc0:
-		case 0x06007fc0: {
-			// target_mask:     0x00000040 (rt0), 0x00000080 (rt1), 0x00003fc0 (all rt), 0x00007fc0
-			// (all rt and depth) extended_action: 0x06000000 (Flush Cb & Db) action:          0x00
-			// (none)
-			if (gcr_cntl != 0 && gcr_cntl != 0x280 && gcr_cntl != 0x300) {
-				LOGF("\t temporary: acquire_mem CB+DB barrier with unhandled GCR control "
-				     "0x%08" PRIx32 "\n",
-				     gcr_cntl);
-			}
-
-			EXIT_IF(target_mask != 0x00000040 && target_mask != 0x00000080 &&
-			        target_mask != 0x00003fc0 && target_mask != 0x00007fc0);
-			EXIT_IF(extended_action != 0x06000000);
-			EXIT_IF(action != 0x00);
-
-			if (size_lo != 0) {
-				if ((target_mask & 0x00003fc0) != 0) {
-					cp.RenderTextureBarrier(base_lo << 8u, size_lo << 8u);
-				}
-				if ((target_mask & 0x00004000) != 0) {
-					cp.DepthStencilBarrier(base_lo << 8u, size_lo << 8u);
-				}
-			} else {
-				cp.MemoryBarrier();
-			}
-		} break;
-
-		default:
-			EXIT("unknown barrier: 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32
-			     "\n",
-			     cache_action, target_mask, extended_action, action);
-	}
-
-	if (stall_mode == 0) {
-		cp.BufferFlush();
-		cp.BufferWait();
-	}
-
-	return (custom ? 7 : 6);
 }
 
 KYTY_CP_OP_PARSER(CpOpDispatchDirect) {
@@ -2166,10 +1873,10 @@ KYTY_CP_OP_PARSER(CpOpBranch) {
 	     reinterpret_cast<uint64_t>(else_buffer), else_num_dw);
 
 	if (take_then) {
-		cp.Run(then_buffer, then_num_dw);
+		cp.ProcessIndirectBuffer(then_buffer, then_num_dw);
 	} else if (mode == 2 && else_num_dw != 0) {
 		EXIT_NOT_IMPLEMENTED(else_buffer == nullptr);
-		cp.Run(else_buffer, else_num_dw);
+		cp.ProcessIndirectBuffer(else_buffer, else_num_dw);
 	}
 
 	return payload_dw;
@@ -2210,17 +1917,23 @@ KYTY_CP_OP_PARSER(CpOpCopyData) {
 
 	EXIT_NOT_IMPLEMENTED(cmd_id != KYTY_PM4(6, Pm4::IT_COPY_DATA, 0u));
 
-	const uint32_t control       = buffer[0];
+	const uint32_t control             = buffer[0];
-	const uint32_t src_sel       = ((control & 0xfu) << 1u) | ((control >> 30u) & 0x1u);
+	const uint32_t src_sel             = ((control & 0xfu) << 1u) | ((control >> 30u) & 0x1u);
-	const uint32_t dst_sel       = ((control >> 8u) & 0xfu) << 1u;
+	const uint32_t dst_sel             = ((control >> 8u) & 0xfu) << 1u;
-	const uint8_t  src_cache     = static_cast<uint8_t>((control >> 13u) & 0x3u);
+	const uint8_t  src_cache           = static_cast<uint8_t>((control >> 13u) & 0x3u);
-	const uint8_t  dst_cache     = static_cast<uint8_t>((control >> 25u) & 0x3u);
+	const uint8_t  dst_cache           = static_cast<uint8_t>((control >> 25u) & 0x3u);
-	const uint8_t  write_confirm = static_cast<uint8_t>((control >> 20u) & 0x1u);
+	const uint8_t  write_confirm       = static_cast<uint8_t>((control >> 20u) & 0x1u);
-	const uint32_t num_bytes     = ((control >> 16u) & 0x1u) != 0 ? 8u : 4u;
+	const uint32_t num_bytes           = ((control >> 16u) & 0x1u) != 0 ? 8u : 4u;
-	const uint64_t src           = buffer[1] | (static_cast<uint64_t>(buffer[2]) << 32u);
+	const uint64_t src                 = buffer[1] | (static_cast<uint64_t>(buffer[2]) << 32u);
-	const uint64_t dst           = buffer[3] | (static_cast<uint64_t>(buffer[4]) << 32u);
+	const uint64_t dst                 = buffer[3] | (static_cast<uint64_t>(buffer[4]) << 32u);
-	if (src_sel == (9u << 1u)) {
+	uint32_t       reference_clock_dst = 0;
-		if (dst_sel != (2u << 1u) || dst == 0 || (dst & (num_bytes - 1u)) != 0) {
+	switch (src_sel) {
+		case 9u: reference_clock_dst = 2u; break;
+		case 18u: reference_clock_dst = 4u; break;
+		default: break;
+	}
+	if (reference_clock_dst != 0) {
+		if (dst_sel != reference_clock_dst || dst == 0 || (dst & (num_bytes - 1u)) != 0) {
 			EXIT("unsupported reference-clock copyData, src_sel=0x%02" PRIx32
 			     " dst_sel=0x%02" PRIx32 " dst=0x%016" PRIx64 " size=%u\n",
 			     src_sel, dst_sel, dst, num_bytes);
@@ -2250,9 +1963,6 @@ KYTY_CP_OP_PARSER(CpOpDmaData) {
 	const uint64_t dst      = buffer[3] | (static_cast<uint64_t>(buffer[4]) << 32u);
 
 	if (control == 0x60000000 && dst == 0x0003022c && (control2 >> 21u) == 0x141u) {
-		auto* addr = reinterpret_cast<void*>(src);
-
-		cp.PrefetchL2(addr, control2 & 0x1fffffu);
 		return 6;
 	}
 
@@ -2496,7 +2206,7 @@ KYTY_CP_OP_PARSER(CpOpIncrementCeCounter) {
 	EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0008400);
 	EXIT_NOT_IMPLEMENTED(buffer[0] != 1);
 
-	cp.IncremenetCe();
+	cp.IncrementCe();
 
 	return 1;
 }
@@ -2507,7 +2217,7 @@ KYTY_CP_OP_PARSER(CpOpIncrementDeCounter) {
 	EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0008500);
 	EXIT_NOT_IMPLEMENTED(buffer[0] != 0);
 
-	cp.IncremenetDe();
+	cp.IncrementDe();
 
 	return 1;
 }
@@ -2607,7 +2317,7 @@ KYTY_CP_OP_PARSER(CpOpIndirectBuffer) {
 
 	GraphicsDbgDumpDcb("ci", indirect_num_dw, indirect_buffer);
 
-	cp.Run(indirect_buffer, indirect_num_dw);
+	cp.ProcessIndirectBuffer(indirect_buffer, indirect_num_dw);
 
 	return 3;
 }
@@ -2630,14 +2340,18 @@ KYTY_CP_OP_PARSER(CpOpIndirectCxRegs) {
 		EXIT("indirect CX registers have null address, num_regs = %" PRIu32 "\n", indirect_num_dw);
 	}
 	for (uint32_t i = 0; i < indirect_num_dw; i++, indirect_buffer += 2) {
-		auto cmd_offset = indirect_buffer[0];
+		// Keep the encoded offset for packet control values, and use the decoded offset only
-		auto value      = indirect_buffer[1];
+		// for register dispatch.
+		auto raw_cmd_offset = indirect_buffer[0];
+		auto cmd_offset     = DecodeIndirectCxRegisterOffset(raw_cmd_offset);
+		auto value          = indirect_buffer[1];
 
 		if (HwCtxTrySetFakeRegister(cmd_offset, value)) {
 			continue;
 		}
 
-		if (cmd_offset == 0xffffffffu) {
+		// The sentinel is an encoded descriptor value and must be checked before normalization.
+		if (raw_cmd_offset == 0xffffffffu) {
 			static bool logged = false;
 			if (!logged) {
 				LOGF("\t temporary: skipping indirect CX sentinel pair offset = 0xffffffff, value "
@@ -2800,11 +2514,10 @@ KYTY_CP_OP_PARSER(CpOpMarker) {
 	// EXIT_NOT_IMPLEMENTED(cmd_id != 0xC0001000);
 
 	uint32_t id     = buffer[0] & 0xfffu;
-	uint32_t align  = (buffer[0] >> 12u) & 0xfu;
 	uint32_t len_dw = ((cmd_id >> 16u) & 0x3fffu);
 
 	switch (id) {
-		case 0x0: cp.SetEmbeddedDataMarker(buffer + 1, len_dw, align); break;
+		case 0x0: break;
 		case 0x4: cp.SetUserDataMarker(HW::UserSgprType::Vsharp); break;
 		case 0xd: cp.SetUserDataMarker(HW::UserSgprType::Region); break;
 		case 0x777: {
@@ -2876,8 +2589,6 @@ KYTY_CP_OP_PARSER(CpOpPopMarker) {
 		LOGF("Pop marker\n");
 	}
 
-	cp.PopMarker();
-
 	return dw_num + 1;
 }
 
@@ -2893,8 +2604,6 @@ KYTY_CP_OP_PARSER(CpOpPushMarker) {
 		LOGF("Push marker: %s\n", str);
 	}
 
-	cp.PushMarker(str);
-
 	return dw_num + 1;
 }
 
@@ -2939,7 +2648,7 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 
 	if (data_sel == 0 || interrupt_selector == 4) {
 		if (eop_event_type != 0x28 || gcr_cntl != 0) {
-			cp.MemoryBarrier();
+			cp.EmitGlobalBarrier();
 		}
 
 		if (gl2_writeback) {
@@ -2953,7 +2662,7 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 
 	if (release_dst == ReleaseMemDstMemory && dst_gpu_addr == nullptr) {
 		if (eop_event_type != 0x28 || gcr_cntl != 0) {
-			cp.MemoryBarrier();
+			cp.EmitGlobalBarrier();
 		}
 
 		if (gl2_writeback) {
@@ -2966,7 +2675,7 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 	}
 
 	if (ReleaseMemGcrNeedsBarrier(eop_event_type, gcr_cntl)) {
-		cp.MemoryBarrier();
+		cp.EmitGlobalBarrier();
 	}
 
 	auto cache_action = ReleaseMemCacheActionFromGcr(gcr_cntl);
@@ -3687,6 +3396,12 @@ void GraphicsInitJmpTablesCxIndirect() {
 	g_hw_ctx_indirect_func[Pm4::DB_COUNT_CONTROL] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
 		HwCtxIgnoreDepthMetadataRegister(cmd_offset, value);
 	};
+	for (auto cmd_offset = Pm4::DB_SRESULTS_COMPARE_STATE0;
+	     cmd_offset <= Pm4::DB_SRESULTS_COMPARE_STATE1; cmd_offset++) {
+		g_hw_ctx_indirect_func[cmd_offset] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
+			HwCtxIgnoreDepthMetadataRegister(cmd_offset, value);
+		};
+	}
 	g_hw_ctx_indirect_func[Pm4::DB_RENDER_OVERRIDE] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
 		HwCtxIgnoreDepthMetadataRegister(cmd_offset, value);
 	};
@@ -3986,18 +3701,7 @@ void GraphicsInitJmpTablesCxIndirect() {
 	};
 
 	g_hw_ctx_indirect_func[Pm4::DB_Z_INFO] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HW::DepthZInfo r;
+		cp.GetCtx().SetDepthZInfo(HW::DepthZInfo::Decode(value));
-		r.format                    = KYTY_PM4_GET(value, DB_Z_INFO, FORMAT);
-		r.num_samples               = KYTY_PM4_GET(value, DB_Z_INFO, NUM_SAMPLES);
-		r.embedded_sample_locations = KYTY_PM4_GET(value, DB_Z_INFO, ITERATE_FLUSH) != 0;
-		r.partially_resident        = KYTY_PM4_GET(value, DB_Z_INFO, PARTIALLY_RESIDENT) != 0;
-		r.num_mip_levels            = KYTY_PM4_GET(value, DB_Z_INFO, MAXMIP);
-		r.tile_mode_index           = KYTY_PM4_GET(value, DB_Z_INFO, TILE_MODE_INDEX);
-		r.plane_compression         = KYTY_PM4_GET(value, DB_Z_INFO, DECOMPRESS_ON_N_ZPLANES);
-		r.expclear_enabled          = KYTY_PM4_GET(value, DB_Z_INFO, ALLOW_EXPCLEAR) != 0;
-		r.tile_surface_enable       = KYTY_PM4_GET(value, DB_Z_INFO, TILE_SURFACE_ENABLE) != 0;
-		r.zrange_precision          = KYTY_PM4_GET(value, DB_Z_INFO, ZRANGE_PRECISION);
-		cp.GetCtx().SetDepthZInfo(r);
 	};
 
 	g_hw_ctx_indirect_func[Pm4::DB_DEPTH_INFO] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
@@ -4025,15 +3729,7 @@ void GraphicsInitJmpTablesCxIndirect() {
 	};
 
 	g_hw_ctx_indirect_func[Pm4::DB_STENCIL_INFO] = [](KYTY_HW_CTX_INDIRECT_ARGS) {
-		HW::DepthStencilInfo r;
+		cp.GetCtx().SetDepthStencilInfo(HW::DepthStencilInfo::Decode(value));
-		r.format                     = KYTY_PM4_GET(value, DB_STENCIL_INFO, FORMAT);
-		r.texture_compatible_stencil = KYTY_PM4_GET(value, DB_STENCIL_INFO, ITERATE_FLUSH) != 0;
-		r.partially_resident   = KYTY_PM4_GET(value, DB_STENCIL_INFO, PARTIALLY_RESIDENT) != 0;
-		r.tile_split           = KYTY_PM4_GET(value, DB_STENCIL_INFO, RESERVED_FIELD_1);
-		r.tile_mode_index      = KYTY_PM4_GET(value, DB_STENCIL_INFO, TILE_MODE_INDEX);
-		r.expclear_enabled     = KYTY_PM4_GET(value, DB_STENCIL_INFO, ALLOW_EXPCLEAR) != 0;
-		r.tile_stencil_disable = KYTY_PM4_GET(value, DB_STENCIL_INFO, TILE_STENCIL_DISABLE) != 0;
-		cp.GetCtx().SetDepthStencilInfo(r);
 	};
 
 	g_hw_ctx_indirect_func[Pm4::DB_Z_READ_BASE] = [](KYTY_HW_CTX_INDIRECT_ARGS) {

src/graphics/guest_gpu/gpu_defs.h

@@ -72,6 +72,7 @@ enum class ChannelLayout : uint32_t {
 	k32_32       = 11,
 	k16_16_16_16 = 12,
 	k32_32_32_32 = 14,
+	k5_6_5       = 16,
 	k5_5_5_1     = 17,
 	k4_4_4_4     = 19,
 	kBc1         = 35,
@@ -142,6 +143,24 @@ enum class StencilFormat : uint32_t {
 	k8UInt   = 1,
 };
 
+enum class TextureCompatiblePlaneCompression : uint32_t {
+	kDisable = 0x00000000,
+	kEnable  = 0x02900800,
+	kBitMask = 0x02900800,
+};
+
+enum class TextureCompatibleStencil : uint32_t {
+	kDisable = 0x00000000,
+	kEnable  = 0x00100800,
+	kBitMask = 0x00100800,
+};
+
+enum class ZCompareBase : uint32_t {
+	kZMin    = 0x00000000,
+	kZMax    = 0x80000000,
+	kBitMask = 0x80000000,
+};
+
 enum class TileMode : uint32_t {
 	kLinear       = 0x00,
 	kStandard256B = 0x01,
@@ -356,6 +375,8 @@ enum class BufferFormat : uint32_t {
 	k32_32_32_32UInt    = 75,
 	k32_32_32_32SInt    = 76,
 	k32_32_32_32Float   = 77,
+	k8Srgb              = 128,
+	k8_8Srgb            = 129,
 	k8_8_8_8Srgb        = 130,
 	k9_9_9_5Float       = 132,
 	k5_6_5UNorm         = 133,

src/graphics/guest_gpu/gpu_format.cpp

@@ -39,6 +39,7 @@ constexpr FormatInfo kFormatInfo[] = {
     {GpuEnumValue(BufferFormat::k16_16Float), 4, 0, 4, true, false},
     {GpuEnumValue(BufferFormat::k11_11_10Float), 4, 0, 4, true, false},
     {GpuEnumValue(BufferFormat::k10_10_10_2UNorm), 4, 0, 4, true, false},
+    {GpuEnumValue(BufferFormat::k10_10_10_2UInt), 4, 0, 4, true, true},
     {GpuEnumValue(BufferFormat::k8_8_8_8UNorm), 4, 0, 4, true, false},
     {GpuEnumValue(BufferFormat::k8_8_8_8SNorm), 4, 0, 4, true, false},
     {GpuEnumValue(BufferFormat::k8_8_8_8UInt), 4, 0, 4, true, true},
@@ -57,6 +58,8 @@ constexpr FormatInfo kFormatInfo[] = {
     {GpuEnumValue(BufferFormat::k32_32_32_32UInt), 16, 0, 16, true, true},
     {GpuEnumValue(BufferFormat::k32_32_32_32SInt), 16, 0, 16, false, false},
     {GpuEnumValue(BufferFormat::k32_32_32_32Float), 16, 0, 16, true, false},
+    {GpuEnumValue(BufferFormat::k8Srgb), 1, 0, 0, true, false},
+    {GpuEnumValue(BufferFormat::k8_8Srgb), 2, 0, 0, true, false},
     {GpuEnumValue(BufferFormat::k8_8_8_8Srgb), 4, 0, 4, true, false},
     {GpuEnumValue(BufferFormat::k9_9_9_5Float), 4, 0, 0, true, false},
     {GpuEnumValue(BufferFormat::k5_6_5UNorm), 2, 0, 2, true, false},

src/graphics/guest_gpu/graphicsRun.h

@@ -3,33 +3,42 @@
 
 #include "common/abi.h"
 #include "common/common.h"
+#include "common/uniqueFunction.h"
+
+#include <memory>
 
 namespace Libs::Graphics {
 
 class CommandProcessor;
+class GpuState;
+class RenderContext;
 
-class GraphicsRunSubmissionLock final {
+class Gpu final {
 public:
-	GraphicsRunSubmissionLock();
+	explicit Gpu(RenderContext& renderer);
-	~GraphicsRunSubmissionLock();
+	~Gpu();
-	KYTY_CLASS_NO_COPY(GraphicsRunSubmissionLock);
+	KYTY_CLASS_NO_COPY(Gpu);
+
+	void               Shutdown();
+	[[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);
+	void SubmitCompute(uint32_t queue, uint32_t* commands, uint32_t size_dw,
+	                   bool trigger_agc_interrupt_on_done = false);
+	void SubmitFlipPreparation(uint64_t request_id);
+	void Done();
+	[[nodiscard]] int GetFrameNum() const;
+
+	[[nodiscard]] static bool              IsCommandProcessorThread() noexcept;
+	[[nodiscard]] static CommandProcessor* CurrentCommandProcessor() noexcept;
+
+private:
+	std::unique_ptr<GpuState> m_state;
 };
-
-void GraphicsRunInit();
-
-void GraphicsRunSubmit(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 = false);
-void GraphicsRunSubmitCompute(uint32_t queue, uint32_t* cmd_buffer, uint32_t num_dw,
-                              bool trigger_agc_interrupt_on_done = false);
-void GraphicsRunSubmitFlipPreparation();
-void GraphicsRunWait();
-void GraphicsRunDone();
-int  GraphicsRunGetFrameNum();
-[[nodiscard]] bool              GraphicsRunIsCommandProcessorThread() noexcept;
-[[nodiscard]] CommandProcessor* GraphicsRunCurrentCommandProcessor() noexcept;
-void                            GraphicsRunFinishCommandProcessors();
-[[nodiscard]] bool              GraphicsRunSubmissionLockHeld() noexcept;
-[[nodiscard]] bool              GraphicsRunGpuLockHeld() noexcept;
 } // namespace Libs::Graphics
 
 #endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GRAPHICSRUN_H_ */

src/graphics/guest_gpu/hardwareContext.h

@@ -3,6 +3,7 @@
 
 #include "common/abi.h"
 #include "common/common.h"
+#include "graphics/guest_gpu/gpu_defs.h"
 
 namespace Libs::Graphics::HW {
 
@@ -131,26 +132,66 @@ struct RenderTarget {
 };
 
 struct DepthZInfo {
-	uint32_t format                    = 0;
+	uint32_t                                    format      = 0;
-	uint32_t tile_mode_index           = 0;
+	uint32_t                                    num_samples = 0;
-	uint32_t num_samples               = 0;
+	Prospero::TextureCompatiblePlaneCompression texture_compatibility =
-	uint32_t zrange_precision          = 0;
+	    Prospero::TextureCompatiblePlaneCompression::kDisable;
-	bool     tile_surface_enable       = false;
+	Prospero::ZCompareBase z_compare_base     = Prospero::ZCompareBase::kZMin;
-	bool     expclear_enabled          = false;
+	bool                   htile_acceleration = false;
-	bool     embedded_sample_locations = false;
+	bool                   expclear_enabled   = false;
-	bool     partially_resident        = false;
+	bool                   partially_resident = false;
-	uint8_t  num_mip_levels            = 0;
+	uint8_t                max_mip_level      = 0;
-	uint8_t  plane_compression         = 0;
+
+	[[nodiscard]] static DepthZInfo Decode(uint32_t value) {
+		DepthZInfo info;
+		info.format                = value & 0x3u;
+		info.num_samples           = (value >> 2u) & 0x3u;
+		info.texture_compatibility = static_cast<Prospero::TextureCompatiblePlaneCompression>(
+		    value & Prospero::GpuEnumValue(Prospero::TextureCompatiblePlaneCompression::kBitMask));
+		info.partially_resident = (value & 0x00001000u) != 0;
+		info.max_mip_level      = static_cast<uint8_t>((value >> 16u) & 0x0fu);
+		info.expclear_enabled   = (value & 0x08000000u) != 0;
+		info.htile_acceleration = (value & 0x20000000u) != 0;
+		info.z_compare_base     = static_cast<Prospero::ZCompareBase>(
+		    value & Prospero::GpuEnumValue(Prospero::ZCompareBase::kBitMask));
+		return info;
+	}
+
+	[[nodiscard]] bool HasValidTextureCompatibility() const {
+		switch (texture_compatibility) {
+			case Prospero::TextureCompatiblePlaneCompression::kDisable:
+			case Prospero::TextureCompatiblePlaneCompression::kEnable: return true;
+			default: return false;
+		}
+	}
 };
 
 struct DepthStencilInfo {
-	uint32_t format                     = 0;
+	uint32_t                           format = 0;
-	uint32_t tile_mode_index            = 0;
+	Prospero::TextureCompatibleStencil texture_compatibility =
-	uint32_t tile_split                 = 0;
+	    Prospero::TextureCompatibleStencil::kDisable;
-	bool     expclear_enabled           = false;
+	bool expclear_enabled       = false;
-	bool     tile_stencil_disable       = false;
+	bool htile_stencil_disabled = false;
-	bool     texture_compatible_stencil = false;
+	bool partially_resident     = false;
-	bool     partially_resident         = false;
+
+	[[nodiscard]] static DepthStencilInfo Decode(uint32_t value) {
+		DepthStencilInfo info;
+		info.format                = value & 0x1u;
+		info.texture_compatibility = static_cast<Prospero::TextureCompatibleStencil>(
+		    value & Prospero::GpuEnumValue(Prospero::TextureCompatibleStencil::kBitMask));
+		info.partially_resident     = (value & 0x00001000u) != 0;
+		info.expclear_enabled       = (value & 0x08000000u) != 0;
+		info.htile_stencil_disabled = (value & 0x20000000u) != 0;
+		return info;
+	}
+
+	[[nodiscard]] bool HasValidTextureCompatibility() const {
+		switch (texture_compatibility) {
+			case Prospero::TextureCompatibleStencil::kDisable:
+			case Prospero::TextureCompatibleStencil::kEnable: return true;
+			default: return false;
+		}
+	}
 };
 
 struct DepthRenderTargetDepthInfo {

src/graphics/guest_gpu/pm4.cpp

@@ -110,7 +110,6 @@ void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t star
 	auto* cmd = cmd_buffer + start_dw;
 	auto  dw  = num_dw;
 	while (dw != 0) {
-		EXIT_NOT_IMPLEMENTED(dw < 2);
 		EXIT_NOT_IMPLEMENTED(dw > num_dw);
 
 		auto cmd_id = *cmd++;
@@ -120,6 +119,9 @@ void DumpPm4PacketStream(Common::File* file, uint32_t* cmd_buffer, uint32_t star
 		uint32_t len = 0;
 
 		const auto packet_type = static_cast<PacketType>(cmd_id >> 30u);
+		// Type-2 packets are header-only padding; every other packet type requires a body.
+		EXIT_NOT_IMPLEMENTED(dw < 2 && packet_type != PacketType::Type2);
+
 		switch (packet_type) {
 			case PacketType::Type3: {
 				const bool    sh_gx = (cmd_id & 0x2u) == 0;

src/graphics/guest_gpu/pm4.h

@@ -385,6 +385,9 @@ constexpr uint32_t SPI_SHADER_POS_FORMAT  = 0x1C3;
 constexpr uint32_t SPI_SHADER_Z_FORMAT    = 0x1C4;
 constexpr uint32_t SPI_SHADER_COL_FORMAT  = 0x1C5;
 
+// Indirect Cx descriptor selector for the 32-entry PS input-control register bank.
+constexpr uint32_t CX_PS_SHADER_USAGE_BASE = 0x10000000u;
+
 constexpr uint32_t CB_BLEND0_CONTROL                            = 0x1E0;
 constexpr uint32_t CB_BLEND0_CONTROL_COLOR_SRCBLEND_SHIFT       = 0;
 constexpr uint32_t CB_BLEND0_CONTROL_COLOR_SRCBLEND_MASK        = 0x1F;

src/graphics/guest_gpu/tile.cpp

@@ -406,8 +406,8 @@ struct TextureBlockLayout {
 
 static bool GetTextureBlockLayout(uint32_t format, uint32_t tile, TextureBlockLayout& out) {
 	uint32_t width_log2 = 0, height_log2 = 0;
-	if (tile == 1 && Gen5Standard256BLayout(format, &out.bytes, &out.texel_width,
+	if (tile == 1 && Gen5Standard256BLayout(format, &out.bytes, &out.texel_width, &out.texel_height,
-	                                        &out.texel_height, &width_log2, &height_log2)) {
+	                                        &width_log2, &height_log2)) {
 		out.block_size = 256;
 	} else if (tile == 5 && Gen5Standard4KBLayout(format, &out.bytes, &out.texel_width,
 	                                              &out.texel_height, &width_log2, &height_log2)) {
@@ -524,7 +524,7 @@ static void SetMacroMipLayout(const TextureBlockLayout& block, uint32_t tile, ui
 }
 
 bool TileGetTextureVolumeLayout(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
-	                            uint32_t levels, uint32_t tile, TileVolumeLayout& out) {
+                                uint32_t levels, uint32_t tile, TileVolumeLayout& out) {
 	if (width == 0 || height == 0 || depth == 0 || levels == 0 || levels > 16) {
 		return false;
 	}
@@ -543,21 +543,26 @@ bool TileGetTextureVolumeLayout(uint32_t format, uint32_t width, uint32_t height
 	TileBlockLayout block {};
 	if (!TileGetBlockLayout(family, element.bytes, block)) return false;
 
-	out                   = {};
+	out                    = {};
-	out.family            = family;
+	out.family             = family;
-	out.bytes_per_element = element.bytes;
+	out.bytes_per_element  = element.bytes;
-	out.texel_width       = element.texel_width;
+	out.texel_width        = element.texel_width;
-	out.texel_height      = element.texel_height;
+	out.texel_height       = element.texel_height;
-	out.block_depth       = block.block_depth;
+	out.block_depth        = block.block_depth;
-	out.first_tail_level  = levels;
+	out.first_tail_level   = levels;
 	const uint32_t width0  = (width + element.texel_width - 1u) / element.texel_width;
 	const uint32_t height0 = (height + element.texel_height - 1u) / element.texel_height;
 	const bool     thick4  = family == TileBlockFamily::Standard4KB3D;
 	const bool     thick64 =
 	    family == TileBlockFamily::Standard64KB3D || family == TileBlockFamily::Prt64KB3D;
-	const uint32_t max_tail    = thick4 ? 5u : (thick64 ? 10u : 12u);
+	uint32_t max_tail = 12u;
-	uint32_t       tail_width  = thick4 ? block.block_width : block.block_width >> 1u;
+	if (thick4) {
-	uint32_t       tail_height = thick4 ? block.block_height >> 1u : block.block_height;
+		max_tail = 5u;
+	} else if (thick64) {
+		max_tail = 10u;
+	}
+	uint32_t tail_width  = thick4 ? block.block_width : block.block_width >> 1u;
+	uint32_t tail_height = thick4 ? block.block_height >> 1u : block.block_height;
 	if (family == TileBlockFamily::Depth64KB && element.bytes < 4) {
 		tail_width  = 64;
 		tail_height = 128;
@@ -574,18 +579,23 @@ bool TileGetTextureVolumeLayout(uint32_t format, uint32_t width, uint32_t height
 		}
 		out.level_widths[level]  = AlignUp(mip_width, block.block_width);
 		out.level_heights[level] = AlignUp(mip_height, block.block_height);
-		out.level_sizes[level]   = static_cast<uint64_t>(block.block_depth) *
+		out.level_sizes[level] = static_cast<uint64_t>(block.block_depth) *
-		                            out.level_widths[level] * out.level_heights[level] *
+		                         out.level_widths[level] * out.level_heights[level] * element.bytes;
-		                            element.bytes;
 		out.block_slice_size += out.level_sizes[level];
 	}
 
-	const auto bytes_log2 = std::countr_zero(element.bytes);
+	const auto                 bytes_log2     = std::countr_zero(element.bytes);
+	const Gen5MipTailLocation* tail_locations = nullptr;
+	if (thick4) {
+		tail_locations = GEN5_MIP_TAIL_LOCATIONS_THICK_4KB[bytes_log2];
+	} else if (thick64) {
+		tail_locations = GEN5_MIP_TAIL_LOCATIONS_THICK_64KB[bytes_log2];
+	} else {
+		tail_locations = GEN5_MIP_TAIL_LOCATIONS_THIN_64KB[bytes_log2];
+	}
 	for (uint32_t level = out.first_tail_level; level < levels; ++level) {
-		const auto index = level - out.first_tail_level;
+		const auto index         = level - out.first_tail_level;
-		const auto tail = thick4 ? GEN5_MIP_TAIL_LOCATIONS_THICK_4KB[bytes_log2][index]
+		const auto tail          = tail_locations[index];
-		                         : (thick64 ? GEN5_MIP_TAIL_LOCATIONS_THICK_64KB[bytes_log2][index]
-		                                    : GEN5_MIP_TAIL_LOCATIONS_THIN_64KB[bytes_log2][index]);
 		out.level_sizes[level]   = block.block_size;
 		out.level_widths[level]  = block.block_width;
 		out.level_heights[level] = block.block_height;
@@ -1047,7 +1057,7 @@ static constexpr uint32_t Depth64KB64XOffsetBytes(uint32_t x);
 static constexpr uint32_t Depth64KB64YOffsetBytes(uint32_t y);
 
 bool TileGetBlockLayout(TileBlockFamily family, uint32_t bytes_per_element,
-	                    TileBlockLayout& layout) {
+                        TileBlockLayout& layout) {
 	if (!std::has_single_bit(bytes_per_element) || bytes_per_element > 16) {
 		return false;
 	}
@@ -1067,13 +1077,25 @@ bool TileGetBlockLayout(TileBlockFamily family, uint32_t bytes_per_element,
 	};
 	switch (family) {
 		case TileBlockFamily::Standard256B:
-			result.block_size   = 256;
+			result.block_size = 256;
-			result.block_width  = bytes_per_element <= 2 ? 16 : (bytes_per_element <= 8 ? 8 : 4);
+			if (bytes_per_element <= 2) {
+				result.block_width = 16;
+			} else if (bytes_per_element <= 8) {
+				result.block_width = 8;
+			} else {
+				result.block_width = 4;
+			}
 			result.block_height = result.block_size / (result.block_width * bytes_per_element);
 			break;
 		case TileBlockFamily::Standard4KB:
-			result.block_size   = 4096;
+			result.block_size = 4096;
-			result.block_width  = bytes_per_element <= 2 ? 64 : (bytes_per_element <= 8 ? 32 : 16);
+			if (bytes_per_element <= 2) {
+				result.block_width = 64;
+			} else if (bytes_per_element <= 8) {
+				result.block_width = 32;
+			} else {
+				result.block_width = 16;
+			}
 			result.block_height = result.block_size / (result.block_width * bytes_per_element);
 			break;
 		case TileBlockFamily::Standard4KB3D: {
@@ -1126,7 +1148,7 @@ bool TileGetBlockLayout(TileBlockFamily family, uint32_t bytes_per_element,
 }
 
 bool TileGetBlockOffset(const TileBlockLayout& layout, uint32_t x, uint32_t y, uint32_t z,
-	                    uint32_t& byte_offset) {
+                        uint32_t& byte_offset) {
 	TileBlockLayout expected {};
 	if (!TileGetBlockLayout(layout.family, layout.bytes_per_element, expected) ||
 	    layout.block_size != expected.block_size || layout.block_width != expected.block_width ||
@@ -1226,12 +1248,12 @@ bool TileGetBlockOffset(const TileBlockLayout& layout, uint32_t x, uint32_t y, u
 }
 
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
-	                 uint32_t& byte_offset) {
+                     uint32_t& byte_offset) {
 	return TileGetBlockXor(layout, block_x, block_y, 0, byte_offset);
 }
 
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
-	                 uint32_t block_z, uint32_t& byte_offset) {
+                     uint32_t block_z, uint32_t& byte_offset) {
 	TileBlockLayout expected {};
 	if (!TileGetBlockLayout(layout.family, layout.bytes_per_element, expected) ||
 	    layout.block_size != expected.block_size || layout.block_width != expected.block_width ||
@@ -1377,8 +1399,8 @@ bool TileGetHtileSize(uint32_t width, uint32_t height, TileSizeAlign& htile_size
 }
 
 bool TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch, uint32_t z_format,
-	                  uint32_t stencil_format, bool htile, TileSizeAlign& stencil_size,
+                      uint32_t stencil_format, bool htile, TileSizeAlign& stencil_size,
-	                  TileSizeAlign& htile_size, TileSizeAlign& depth_size,
+                      TileSizeAlign& htile_size, TileSizeAlign& depth_size,
                       uint32_t num_fragments_log2) {
 	EXIT_IF(pitch != 0);
 	// Prospero derives uncompressed depth/stencil as independent 64 KiB block surfaces.
@@ -1410,8 +1432,8 @@ bool TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch, uint32_t
 		if (depth_bytes_total <= UINT32_MAX && stencil_bytes_total <= UINT32_MAX && htile_valid) {
 			depth_size   = {static_cast<uint32_t>(depth_bytes_total), 65536};
 			stencil_size = stencil_format == 1
-			                    ? TileSizeAlign {static_cast<uint32_t>(stencil_bytes_total), 65536}
+			                   ? TileSizeAlign {static_cast<uint32_t>(stencil_bytes_total), 65536}
-			                    : TileSizeAlign {};
+			                   : TileSizeAlign {};
 			htile_size   = calculated_htile;
 			return true;
 		}
@@ -1441,7 +1463,7 @@ uint32_t TileGetDepthPitch(uint32_t width, uint32_t bytes_per_element,
 }
 
 bool TileGetRenderTargetSize(uint32_t width, uint32_t height, uint32_t pitch,
-	                         uint32_t bytes_per_element, TileSizeAlign& total_size,
+                             uint32_t bytes_per_element, TileSizeAlign& total_size,
                              uint32_t num_fragments_log2) {
 	total_size            = {};
 	uint32_t block_width  = 0;
@@ -1466,7 +1488,7 @@ bool TileGetRenderTargetSize(uint32_t width, uint32_t height, uint32_t pitch,
 
 bool TileGetRenderTargetMipLayout(uint32_t width, uint32_t height, uint32_t pitch,
                                   uint32_t bytes_per_element, uint32_t levels,
-	                              TileSizeAlign& total_size, TileSizeOffset* level_sizes,
+                                  TileSizeAlign& total_size, TileSizeOffset* level_sizes,
                                   TilePaddedSize* padded_size) {
 	total_size = {};
 	if (width == 0 || height == 0 || levels == 0 || levels > 16 ||
@@ -1578,7 +1600,7 @@ void TileGetTextureSize(uint32_t format, uint32_t width, uint32_t height, uint32
 
 void TileGetTextureTotalSize(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
                              uint32_t pitch, uint32_t levels, uint32_t tile, bool volume_texture,
-	                         TileSizeAlign& total_size) {
+                             TileSizeAlign& total_size) {
 	EXIT_NOT_IMPLEMENTED(depth == 0);
 	if (volume_texture) {
 		TileVolumeLayout volume {};

src/graphics/guest_gpu/tile.h

@@ -65,41 +65,41 @@ struct TileVolumeLayout {
 };
 
 bool TileGetBlockLayout(TileBlockFamily family, uint32_t bytes_per_element,
-	                    TileBlockLayout& layout);
+                        TileBlockLayout& layout);
 bool TileGetBlockOffset(const TileBlockLayout& layout, uint32_t x, uint32_t y, uint32_t z,
-	                    uint32_t& byte_offset);
+                        uint32_t& byte_offset);
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
-	                 uint32_t& byte_offset);
+                     uint32_t& byte_offset);
 bool TileGetBlockXor(const TileBlockLayout& layout, uint32_t block_x, uint32_t block_y,
-	                 uint32_t block_z, uint32_t& byte_offset);
+                     uint32_t block_z, uint32_t& byte_offset);
 bool TileIsStandard256BTextureSupported(uint32_t format);
 bool TileIsStandard4KBTextureSupported(uint32_t format);
 bool TileIsStandard64KBTextureSupported(uint32_t format);
 bool TileGetTextureVolumeLayout(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
-	                            uint32_t levels, uint32_t tile, TileVolumeLayout& layout);
+                                uint32_t levels, uint32_t tile, TileVolumeLayout& layout);
 
 bool     TileGetHtileSize(uint32_t width, uint32_t height, TileSizeAlign& htile_size);
 bool     TileGetDepthSize(uint32_t width, uint32_t height, uint32_t pitch, uint32_t z_format,
-	                      uint32_t stencil_format, bool htile, TileSizeAlign& stencil_size,
+                          uint32_t stencil_format, bool htile, TileSizeAlign& stencil_size,
-	                      TileSizeAlign& htile_size, TileSizeAlign& depth_size,
+                          TileSizeAlign& htile_size, TileSizeAlign& depth_size,
                           uint32_t num_fragments_log2 = 0);
 uint32_t TileGetRenderTargetPitch(uint32_t width, uint32_t bytes_per_element,
                                   uint32_t num_fragments_log2 = 0);
 uint32_t TileGetDepthPitch(uint32_t width, uint32_t bytes_per_element,
                            uint32_t num_fragments_log2 = 0);
 bool     TileGetRenderTargetSize(uint32_t width, uint32_t height, uint32_t pitch,
-	                             uint32_t bytes_per_element, TileSizeAlign& total_size,
+                                 uint32_t bytes_per_element, TileSizeAlign& total_size,
                                  uint32_t num_fragments_log2 = 0);
 bool     TileGetRenderTargetMipLayout(uint32_t width, uint32_t height, uint32_t pitch,
-	                                  uint32_t bytes_per_element, uint32_t levels,
+                                      uint32_t bytes_per_element, uint32_t levels,
-	                                  TileSizeAlign& total_size, TileSizeOffset* level_sizes,
+                                      TileSizeAlign& total_size, TileSizeOffset* level_sizes,
                                       TilePaddedSize* padded_size);
 void     TileGetTextureSize(uint32_t format, uint32_t width, uint32_t height, uint32_t pitch,
                             uint32_t levels, uint32_t tile, TileSizeAlign* total_size,
                             TileSizeOffset* level_sizes, TilePaddedSize* padded_size);
 void TileGetTextureTotalSize(uint32_t format, uint32_t width, uint32_t height, uint32_t depth,
                              uint32_t pitch, uint32_t levels, uint32_t tile, bool volume_texture,
-	                         TileSizeAlign& total_size);
+                             TileSizeAlign& total_size);
 uint32_t TileGetTexturePitch(uint32_t format, uint32_t width, uint32_t levels, uint32_t tile);
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/gpuTiler.cpp

@@ -1,549 +0,0 @@
-#include "graphics/host_gpu/gpuTiler.h"
-
-#include "common/assert.h"
-#include "common/threads.h"
-#include "gpu_tiler_shaders/gpu_tiler_depth_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_prt_3d_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_prt_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_render_target_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard256_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard4_3d_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard4_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard64_3d_spv.h"
-#include "gpu_tiler_shaders/gpu_tiler_standard64_spv.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/vma.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <algorithm>
-#include <array>
-#include <bit>
-#include <cstring>
-#include <memory>
-#include <vector>
-
-namespace Libs::Graphics {
-namespace {
-
-constexpr uint32_t GROUP_SIZE              = 64;
-constexpr uint32_t FAMILY_COUNT            = static_cast<uint32_t>(TileBlockFamily::Count);
-constexpr uint32_t BYTES_PER_ELEMENT_COUNT = 5;
-constexpr uint32_t DIRECTION_COUNT         = 2;
-constexpr uint32_t PIPELINE_COUNT = FAMILY_COUNT * BYTES_PER_ELEMENT_COUNT * DIRECTION_COUNT;
-static_assert(FAMILY_COUNT == 9);
-
-struct Push {
-	uint32_t src_base;
-	uint32_t dst_base;
-	uint32_t width;
-	uint32_t height;
-	uint32_t depth;
-	uint32_t surface_z;
-	uint32_t pitch_bytes;
-	uint32_t slice_bytes;
-	uint32_t blocks_per_row;
-	uint32_t blocks_per_slice;
-	uint32_t tail_x;
-	uint32_t tail_y;
-	uint32_t tail;
-	uint32_t first;
-	uint32_t count;
-};
-static_assert(sizeof(Push) == 60);
-
-struct Shader {
-	const uint32_t* code;
-	size_t          words;
-};
-
-constexpr std::array<Shader, FAMILY_COUNT> SHADERS {{
-    {GPU_TILER_STANDARD256_SPV, std::size(GPU_TILER_STANDARD256_SPV)},
-    {GPU_TILER_STANDARD4_SPV, std::size(GPU_TILER_STANDARD4_SPV)},
-    {GPU_TILER_STANDARD4_3D_SPV, std::size(GPU_TILER_STANDARD4_3D_SPV)},
-    {GPU_TILER_STANDARD64_SPV, std::size(GPU_TILER_STANDARD64_SPV)},
-    {GPU_TILER_STANDARD64_3D_SPV, std::size(GPU_TILER_STANDARD64_3D_SPV)},
-    {GPU_TILER_PRT_SPV, std::size(GPU_TILER_PRT_SPV)},
-    {GPU_TILER_PRT_3D_SPV, std::size(GPU_TILER_PRT_3D_SPV)},
-    {GPU_TILER_RENDER_TARGET_SPV, std::size(GPU_TILER_RENDER_TARGET_SPV)},
-    {GPU_TILER_DEPTH_SPV, std::size(GPU_TILER_DEPTH_SPV)},
-}};
-
-struct Dispatch {
-	Push     push {};
-	uint32_t pipeline_slot = 0;
-	uint32_t elements      = 0;
-};
-
-struct Resources {
-	vk::DescriptorSetLayout                  descriptor_layout = nullptr;
-	vk::PipelineLayout                       pipeline_layout   = nullptr;
-	vk::DescriptorPool                       descriptor_pool   = nullptr;
-	vk::DescriptorSet                        descriptor_set    = nullptr;
-	std::array<vk::Pipeline, PIPELINE_COUNT> pipelines {};
-	VulkanBuffer                             staging;
-	VulkanBuffer                             linear;
-	void*                                    mapped = nullptr;
-};
-
-bool CheckedAdd(uint64_t a, uint64_t b, uint64_t& result) {
-	return b <= UINT64_MAX - a && (result = a + b, true);
-}
-
-bool CheckedMultiply(uint64_t a, uint64_t b, uint64_t& result) {
-	return (a == 0 || b <= UINT64_MAX / a) && (result = a * b, true);
-}
-
-bool CheckedAddProduct(uint64_t& value, uint64_t count, uint64_t stride) {
-	uint64_t bytes = 0;
-	return CheckedMultiply(count, stride, bytes) && CheckedAdd(value, bytes, value);
-}
-
-bool IsRangeValid(uint64_t offset, uint64_t size, uint64_t capacity) {
-	return size != 0 && offset <= capacity && size <= capacity - offset;
-}
-
-uint64_t AlignToDword(uint64_t value) {
-	return (value + 3u) & ~uint64_t {3};
-}
-
-uint32_t GetPipelineSlot(bool to_tiled, TileBlockFamily family, uint32_t bytes_per_element) {
-	const uint32_t direction_index    = to_tiled ? 1u : 0u;
-	const uint32_t family_index       = static_cast<uint32_t>(family);
-	const uint32_t element_size_index = std::countr_zero(bytes_per_element);
-	return (direction_index * FAMILY_COUNT + family_index) * BYTES_PER_ELEMENT_COUNT +
-	       element_size_index;
-}
-
-void Barrier(vk::CommandBuffer command, vk::Buffer buffer, vk::AccessFlags src_access,
-             vk::AccessFlags dst_access, vk::PipelineStageFlags src_stage,
-             vk::PipelineStageFlags dst_stage) {
-	vk::BufferMemoryBarrier barrier {};
-	barrier.sType               = vk::StructureType::eBufferMemoryBarrier;
-	barrier.srcAccessMask       = src_access;
-	barrier.dstAccessMask       = dst_access;
-	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-	barrier.buffer              = buffer;
-	barrier.size                = VK_WHOLE_SIZE;
-	command.pipelineBarrier(src_stage, dst_stage, {}, 0, nullptr, 1, &barrier, 0, nullptr);
-}
-
-class TileCompute final {
-public:
-	explicit TileCompute(GraphicContext& graphics): graphics(graphics) {}
-	void Run(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-	         uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-	         const GpuTileRecord& record);
-	void Release();
-
-private:
-	void Prepare(bool to_tiled, uint64_t tiled_capacity, uint64_t linear_capacity,
-	             std::span<const GpuTileInfo> infos, std::vector<Dispatch>& dispatches) const;
-	void Init();
-	void CreatePipelines(std::span<const Dispatch> dispatches);
-	void CreatePipeline(uint32_t pipeline_slot);
-	void Resize(uint64_t staging_size, uint64_t linear_size);
-	void CreateBuffer(uint64_t size, bool mapped, VulkanBuffer& buffer, void** data) const;
-	void Execute(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-	             uint64_t linear_capacity, std::span<const Dispatch> dispatches,
-	             const GpuTileRecord& record);
-	void Destroy(Resources& target) const;
-
-	GraphicContext& graphics;
-	Resources       resources;
-};
-
-Common::Mutex                g_tiler_mutex;
-std::unique_ptr<TileCompute> g_tiler;
-
-void TileCompute::Prepare(bool to_tiled, uint64_t tiled_capacity, uint64_t linear_capacity,
-                          std::span<const GpuTileInfo> infos,
-                          std::vector<Dispatch>&       dispatches) const {
-	EXIT_IF(infos.empty() || tiled_capacity == 0 || linear_capacity == 0);
-	const auto& limits = graphics.GetPhysicalDeviceProperties().limits;
-	EXIT_NOT_IMPLEMENTED(tiled_capacity > UINT32_MAX || linear_capacity > UINT32_MAX ||
-	                     AlignToDword(tiled_capacity) > limits.maxStorageBufferRange ||
-	                     AlignToDword(linear_capacity) > limits.maxStorageBufferRange);
-
-	dispatches.clear();
-	dispatches.reserve(infos.size());
-	for (const auto& info: infos) {
-		TileBlockLayout block {};
-		const uint32_t  tiled_width  = info.tiled_width != 0 ? info.tiled_width : info.pitch;
-		const uint32_t  tiled_height = info.tiled_height != 0 ? info.tiled_height : info.height;
-		EXIT_NOT_IMPLEMENTED(
-		    !TileGetBlockLayout(info.family, info.bytes_per_element, block) || info.width == 0 ||
-		    info.height == 0 || info.depth == 0 || info.pitch < info.width ||
-		    (!info.tail && (tiled_width < info.width || tiled_height < info.height)) ||
-		    !IsRangeValid(info.linear_offset, info.linear_size, linear_capacity) ||
-		    !IsRangeValid(info.tiled_offset, info.tiled_size, tiled_capacity) ||
-		    (block.block_depth == 1 && info.depth != 1));
-
-		uint64_t elements = 0, pitch_bytes = 0;
-		EXIT_NOT_IMPLEMENTED(!CheckedMultiply(info.width, info.height, elements) ||
-		                     !CheckedMultiply(elements, info.depth, elements) ||
-		                     !CheckedMultiply(info.pitch, info.bytes_per_element, pitch_bytes) ||
-		                     elements > UINT32_MAX || pitch_bytes > UINT32_MAX);
-		uint64_t slice_bytes = info.linear_slice_stride;
-		EXIT_NOT_IMPLEMENTED(slice_bytes == 0 &&
-		                     !CheckedMultiply(pitch_bytes, info.height, slice_bytes));
-		uint64_t linear_used = 0, minimum_slice = 0;
-		EXIT_NOT_IMPLEMENTED(!CheckedMultiply(pitch_bytes, info.height, minimum_slice) ||
-		                     (info.depth > 1 && slice_bytes < minimum_slice) ||
-		                     !CheckedAddProduct(linear_used, info.depth - 1u, slice_bytes) ||
-		                     !CheckedAddProduct(linear_used, info.height - 1u, pitch_bytes) ||
-		                     !CheckedAddProduct(linear_used, info.width, info.bytes_per_element) ||
-		                     linear_used > info.linear_size || slice_bytes > UINT32_MAX);
-
-		const uint64_t columns =
-		    (static_cast<uint64_t>(tiled_width) + block.block_width - 1u) / block.block_width;
-		const uint64_t rows =
-		    (static_cast<uint64_t>(tiled_height) + block.block_height - 1u) / block.block_height;
-		uint64_t blocks_per_slice = 0;
-		EXIT_NOT_IMPLEMENTED(!CheckedMultiply(columns, rows, blocks_per_slice) ||
-		                     columns > UINT32_MAX || blocks_per_slice > UINT32_MAX ||
-		                     rows * block.block_height > UINT32_MAX);
-		if (info.tail) {
-			const bool supported = info.family != TileBlockFamily::Standard256B;
-			EXIT_NOT_IMPLEMENTED(
-			    !supported || info.depth > block.block_depth || info.tail_x >= block.block_width ||
-			    info.width > block.block_width - info.tail_x || info.tail_y >= block.block_height ||
-			    info.height > block.block_height - info.tail_y ||
-			    info.tiled_size < block.block_size);
-		} else {
-			const uint64_t slices =
-			    (static_cast<uint64_t>(info.depth) + block.block_depth - 1u) / block.block_depth;
-			uint64_t tiled_used = 0;
-			EXIT_NOT_IMPLEMENTED(!CheckedMultiply(blocks_per_slice, slices, tiled_used) ||
-			                     !CheckedMultiply(tiled_used, block.block_size, tiled_used) ||
-			                     tiled_used > info.tiled_size);
-		}
-		const uint32_t alignment = std::min(info.bytes_per_element, 4u);
-		EXIT_NOT_IMPLEMENTED(((info.linear_offset | info.tiled_offset | pitch_bytes | slice_bytes) &
-		                      (alignment - 1u)) != 0);
-
-		Dispatch dispatch {};
-		dispatch.elements      = static_cast<uint32_t>(elements);
-		dispatch.pipeline_slot = GetPipelineSlot(to_tiled, info.family, info.bytes_per_element);
-		dispatch.push.src_base =
-		    static_cast<uint32_t>(to_tiled ? info.linear_offset : info.tiled_offset);
-		dispatch.push.dst_base =
-		    static_cast<uint32_t>(to_tiled ? info.tiled_offset : info.linear_offset);
-		dispatch.push.width            = info.width;
-		dispatch.push.height           = info.height;
-		dispatch.push.depth            = info.depth;
-		dispatch.push.surface_z        = info.surface_z;
-		dispatch.push.pitch_bytes      = static_cast<uint32_t>(pitch_bytes);
-		dispatch.push.slice_bytes      = static_cast<uint32_t>(slice_bytes);
-		dispatch.push.blocks_per_row   = static_cast<uint32_t>(columns);
-		dispatch.push.blocks_per_slice = static_cast<uint32_t>(blocks_per_slice);
-		dispatch.push.tail_x           = info.tail_x;
-		dispatch.push.tail_y           = info.tail_y;
-		dispatch.push.tail             = info.tail;
-		dispatches.push_back(dispatch);
-	}
-}
-
-void TileCompute::Destroy(Resources& target) const {
-	if (target.mapped != nullptr) {
-		graphics.UnmapMemory(target.staging.memory);
-	}
-	if (target.staging.buffer != nullptr) {
-		graphics.DeleteBuffer(target.staging);
-	}
-	if (target.linear.buffer != nullptr) {
-		graphics.DeleteBuffer(target.linear);
-	}
-	for (auto pipeline: target.pipelines) {
-		if (pipeline != nullptr) {
-			graphics.device.destroyPipeline(pipeline, nullptr);
-		}
-	}
-	if (target.descriptor_pool != nullptr) {
-		graphics.device.destroyDescriptorPool(target.descriptor_pool, nullptr);
-	}
-	if (target.pipeline_layout != nullptr) {
-		graphics.device.destroyPipelineLayout(target.pipeline_layout, nullptr);
-	}
-	if (target.descriptor_layout != nullptr) {
-		graphics.device.destroyDescriptorSetLayout(target.descriptor_layout, nullptr);
-	}
-	target = {};
-}
-
-void TileCompute::Init() {
-	if (resources.pipeline_layout != nullptr) {
-		return;
-	}
-	std::array<vk::DescriptorSetLayoutBinding, 2> bindings {};
-	for (uint32_t i = 0; i < bindings.size(); i++) {
-		bindings[i] = {i, vk::DescriptorType::eStorageBuffer, 1, vk::ShaderStageFlagBits::eCompute,
-		               nullptr};
-	}
-	vk::DescriptorSetLayoutCreateInfo descriptor_info {};
-	descriptor_info.sType        = vk::StructureType::eDescriptorSetLayoutCreateInfo;
-	descriptor_info.bindingCount = static_cast<uint32_t>(bindings.size());
-	descriptor_info.pBindings    = bindings.data();
-	RequireVulkanSuccess(graphics.device.createDescriptorSetLayout(&descriptor_info, nullptr,
-	                                                               &resources.descriptor_layout),
-	                     "create GPU tiler descriptor layout");
-
-	vk::PushConstantRange        push_range {vk::ShaderStageFlagBits::eCompute, 0, sizeof(Push)};
-	vk::PipelineLayoutCreateInfo layout_info {};
-	layout_info.sType                  = vk::StructureType::ePipelineLayoutCreateInfo;
-	layout_info.setLayoutCount         = 1;
-	layout_info.pSetLayouts            = &resources.descriptor_layout;
-	layout_info.pushConstantRangeCount = 1;
-	layout_info.pPushConstantRanges    = &push_range;
-	RequireVulkanSuccess(
-	    graphics.device.createPipelineLayout(&layout_info, nullptr, &resources.pipeline_layout),
-	    "create GPU tiler pipeline layout");
-	vk::DescriptorPoolSize       pool_size {vk::DescriptorType::eStorageBuffer, 2};
-	vk::DescriptorPoolCreateInfo pool_info {};
-	pool_info.sType         = vk::StructureType::eDescriptorPoolCreateInfo;
-	pool_info.maxSets       = 1;
-	pool_info.poolSizeCount = 1;
-	pool_info.pPoolSizes    = &pool_size;
-	RequireVulkanSuccess(
-	    graphics.device.createDescriptorPool(&pool_info, nullptr, &resources.descriptor_pool),
-	    "create GPU tiler descriptor pool");
-	vk::DescriptorSetAllocateInfo set_info {};
-	set_info.sType              = vk::StructureType::eDescriptorSetAllocateInfo;
-	set_info.descriptorPool     = resources.descriptor_pool;
-	set_info.descriptorSetCount = 1;
-	set_info.pSetLayouts        = &resources.descriptor_layout;
-	RequireVulkanSuccess(
-	    graphics.device.allocateDescriptorSets(&set_info, &resources.descriptor_set),
-	    "allocate GPU tiler descriptor set");
-}
-
-void TileCompute::CreatePipeline(uint32_t pipeline_slot) {
-	const uint32_t element_size_index     = pipeline_slot % BYTES_PER_ELEMENT_COUNT;
-	const uint32_t family_direction_index = pipeline_slot / BYTES_PER_ELEMENT_COUNT;
-	const uint32_t family_index           = family_direction_index % FAMILY_COUNT;
-	const uint32_t direction_index        = family_direction_index / FAMILY_COUNT;
-	const uint32_t specialization_values[] {1u << element_size_index, direction_index};
-	const vk::SpecializationMapEntry entries[] {{0, 0, 4}, {1, 4, 4}};
-	vk::SpecializationInfo           specialization {2, entries, sizeof(specialization_values),
-	                                                 specialization_values};
-	vk::ShaderModuleCreateInfo       module_info {};
-	module_info.sType       = vk::StructureType::eShaderModuleCreateInfo;
-	module_info.codeSize    = SHADERS[family_index].words * sizeof(uint32_t);
-	module_info.pCode       = SHADERS[family_index].code;
-	vk::ShaderModule module = nullptr;
-	RequireVulkanSuccess(graphics.device.createShaderModule(&module_info, nullptr, &module),
-	                     "create GPU tiler shader module");
-	vk::PipelineShaderStageCreateInfo stage {};
-	stage.sType               = vk::StructureType::ePipelineShaderStageCreateInfo;
-	stage.stage               = vk::ShaderStageFlagBits::eCompute;
-	stage.module              = module;
-	stage.pName               = "main";
-	stage.pSpecializationInfo = &specialization;
-	vk::ComputePipelineCreateInfo info {};
-	info.sType            = vk::StructureType::eComputePipelineCreateInfo;
-	info.stage            = stage;
-	info.layout           = resources.pipeline_layout;
-	vk::Pipeline pipeline = nullptr;
-	const auto   result =
-	    graphics.device.createComputePipelines(nullptr, 1, &info, nullptr, &pipeline);
-	graphics.device.destroyShaderModule(module, nullptr);
-	RequireVulkanSuccess(result, "create GPU tiler pipeline");
-	resources.pipelines[pipeline_slot] = pipeline;
-}
-
-void TileCompute::CreatePipelines(std::span<const Dispatch> dispatches) {
-	for (const auto& dispatch: dispatches) {
-		if (resources.pipelines[dispatch.pipeline_slot] == nullptr) {
-			CreatePipeline(dispatch.pipeline_slot);
-		}
-	}
-}
-
-void TileCompute::CreateBuffer(uint64_t size, bool mapped, VulkanBuffer& buffer,
-                               void** data) const {
-	buffer.usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eTransferSrc |
-	               vk::BufferUsageFlagBits::eTransferDst;
-	buffer.memory.property =
-	    mapped
-	        ? vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent
-	        : vk::MemoryPropertyFlags(vk::MemoryPropertyFlagBits::eDeviceLocal);
-	graphics.CreateBuffer(size, buffer);
-	if (mapped) graphics.MapMemory(buffer.memory, *data);
-}
-
-void TileCompute::Resize(uint64_t staging_size, uint64_t linear_size) {
-	if (resources.staging.buffer_size >= staging_size &&
-	    resources.linear.buffer_size >= linear_size) {
-		return;
-	}
-	staging_size = std::max(staging_size, resources.staging.buffer_size);
-	linear_size  = std::max(linear_size, resources.linear.buffer_size);
-	VulkanBuffer staging {}, linear {};
-	void*        mapped = nullptr;
-	CreateBuffer(staging_size, true, staging, &mapped);
-	CreateBuffer(linear_size, false, linear, nullptr);
-	if (resources.mapped != nullptr) graphics.UnmapMemory(resources.staging.memory);
-	if (resources.staging.buffer != nullptr) graphics.DeleteBuffer(resources.staging);
-	if (resources.linear.buffer != nullptr) graphics.DeleteBuffer(resources.linear);
-	resources.staging = staging;
-	resources.linear  = linear;
-	resources.mapped  = mapped;
-}
-
-void TileCompute::Execute(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-                          uint64_t linear_capacity, std::span<const Dispatch> dispatches,
-                          const GpuTileRecord& record) {
-	const uint64_t tiled_size  = AlignToDword(tiled_capacity);
-	const uint64_t linear_size = AlignToDword(linear_capacity);
-	const uint64_t input_size  = to_tiled ? linear_capacity : tiled_capacity;
-	if (input != nullptr) {
-		std::memcpy(resources.mapped, input, static_cast<size_t>(input_size));
-		std::memset(static_cast<uint8_t*>(resources.mapped) + input_size, 0,
-		            static_cast<size_t>(AlignToDword(input_size) - input_size));
-	}
-
-	std::array<vk::DescriptorBufferInfo, 2> buffer_info {{
-	    {to_tiled ? resources.linear.buffer : resources.staging.buffer, 0,
-	     to_tiled ? linear_size : tiled_size},
-	    {to_tiled ? resources.staging.buffer : resources.linear.buffer, 0,
-	     to_tiled ? tiled_size : linear_size},
-	}};
-	std::array<vk::WriteDescriptorSet, 2>   writes {};
-	for (uint32_t i = 0; i < writes.size(); i++) {
-		writes[i].sType           = vk::StructureType::eWriteDescriptorSet;
-		writes[i].dstSet          = resources.descriptor_set;
-		writes[i].dstBinding      = i;
-		writes[i].descriptorCount = 1;
-		writes[i].descriptorType  = vk::DescriptorType::eStorageBuffer;
-		writes[i].pBufferInfo     = &buffer_info[i];
-	}
-	graphics.device.updateDescriptorSets(static_cast<uint32_t>(writes.size()), writes.data(), 0,
-	                                     nullptr);
-
-	CommandBuffer command;
-	command.Begin();
-	auto vk_command = command.Handle();
-	if (input != nullptr) {
-		Barrier(vk_command, resources.staging.buffer, vk::AccessFlagBits::eHostWrite,
-		        vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eTransferRead,
-		        vk::PipelineStageFlagBits::eHost,
-		        vk::PipelineStageFlagBits::eComputeShader | vk::PipelineStageFlagBits::eTransfer);
-	}
-	if (to_tiled && input != nullptr) {
-		const vk::BufferCopy copy {0, 0, linear_size};
-		vk_command.copyBuffer(resources.staging.buffer, resources.linear.buffer, 1, &copy);
-		Barrier(vk_command, resources.linear.buffer, vk::AccessFlagBits::eTransferWrite,
-		        vk::AccessFlagBits::eShaderRead, vk::PipelineStageFlagBits::eTransfer,
-		        vk::PipelineStageFlagBits::eComputeShader);
-		Barrier(vk_command, resources.staging.buffer, vk::AccessFlagBits::eTransferRead,
-		        vk::AccessFlagBits::eTransferWrite, vk::PipelineStageFlagBits::eTransfer,
-		        vk::PipelineStageFlagBits::eTransfer);
-	}
-	if (to_tiled && record) {
-		record(command, resources.linear);
-		Barrier(vk_command, resources.linear.buffer,
-		        vk::AccessFlagBits::eTransferWrite | vk::AccessFlagBits::eMemoryWrite,
-		        vk::AccessFlagBits::eShaderRead, vk::PipelineStageFlagBits::eAllCommands,
-		        vk::PipelineStageFlagBits::eComputeShader);
-	}
-
-	const auto output_buffer = to_tiled ? resources.staging.buffer : resources.linear.buffer;
-	const auto output_size   = to_tiled ? tiled_size : linear_size;
-	vk_command.fillBuffer(output_buffer, 0, output_size, 0);
-	Barrier(vk_command, output_buffer, vk::AccessFlagBits::eTransferWrite,
-	        vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite,
-	        vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eComputeShader);
-	vk_command.bindDescriptorSets(vk::PipelineBindPoint::eCompute, resources.pipeline_layout, 0, 1,
-	                              &resources.descriptor_set, 0, nullptr);
-	const uint64_t limit =
-	    static_cast<uint64_t>(
-	        graphics.GetPhysicalDeviceProperties().limits.maxComputeWorkGroupCount[0]) *
-	    GROUP_SIZE;
-	for (const auto& dispatch: dispatches) {
-		vk_command.bindPipeline(vk::PipelineBindPoint::eCompute,
-		                        resources.pipelines[dispatch.pipeline_slot]);
-		for (uint32_t first = 0; first < dispatch.elements;) {
-			auto push  = dispatch.push;
-			push.first = first;
-			push.count =
-			    static_cast<uint32_t>(std::min<uint64_t>(dispatch.elements - first, limit));
-			vk_command.pushConstants(resources.pipeline_layout, vk::ShaderStageFlagBits::eCompute,
-			                         0, sizeof(push), &push);
-			vk_command.dispatch((push.count - 1u) / GROUP_SIZE + 1u, 1, 1);
-			first += push.count;
-		}
-	}
-	Barrier(vk_command, output_buffer, vk::AccessFlagBits::eShaderWrite,
-	        vk::AccessFlagBits::eTransferRead | vk::AccessFlagBits::eHostRead,
-	        vk::PipelineStageFlagBits::eComputeShader,
-	        vk::PipelineStageFlagBits::eTransfer | vk::PipelineStageFlagBits::eHost);
-	if (!to_tiled && record) {
-		record(command, resources.linear);
-	}
-	if (!to_tiled && output != nullptr) {
-		const vk::BufferCopy copy {0, 0, linear_size};
-		vk_command.copyBuffer(resources.linear.buffer, resources.staging.buffer, 1, &copy);
-		Barrier(vk_command, resources.staging.buffer, vk::AccessFlagBits::eTransferWrite,
-		        vk::AccessFlagBits::eHostRead, vk::PipelineStageFlagBits::eTransfer,
-		        vk::PipelineStageFlagBits::eHost);
-	}
-	command.End();
-	command.Execute();
-	command.WaitForFence();
-	if (output != nullptr) {
-		std::memcpy(output, resources.mapped,
-		            static_cast<size_t>(to_tiled ? tiled_capacity : linear_capacity));
-	}
-}
-
-void TileCompute::Run(bool to_tiled, const void* input, void* output, uint64_t tiled_capacity,
-                      uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-                      const GpuTileRecord& record) {
-	EXIT_IF((to_tiled && (output == nullptr || (input == nullptr && !record))) ||
-	        (!to_tiled && (input == nullptr || (output == nullptr && !record))));
-	std::vector<Dispatch> dispatches;
-	Prepare(to_tiled, tiled_capacity, linear_capacity, infos, dispatches);
-	Init();
-	CreatePipelines(dispatches);
-	const uint64_t staging_size =
-	    std::max(AlignToDword(tiled_capacity), AlignToDword(linear_capacity));
-	const uint64_t linear_size = AlignToDword(linear_capacity);
-	Resize(staging_size, linear_size);
-	Execute(to_tiled, input, output, tiled_capacity, linear_capacity, dispatches, record);
-}
-
-void TileCompute::Release() {
-	Destroy(resources);
-}
-
-} // namespace
-
-void GpuDetile(const void* tiled, void* linear, uint64_t tiled_capacity, uint64_t linear_capacity,
-               std::span<const GpuTileInfo> infos, const GpuTileRecord& after) {
-	Common::LockGuard lock(g_tiler_mutex);
-	if (!g_tiler) {
-		g_tiler = std::make_unique<TileCompute>(GetRenderContext().GetGraphics());
-	}
-	g_tiler->Run(false, tiled, linear, tiled_capacity, linear_capacity, infos, after);
-}
-
-void GpuTile(const void* linear, void* tiled, uint64_t tiled_capacity, uint64_t linear_capacity,
-             std::span<const GpuTileInfo> infos, const GpuTileRecord& before) {
-	Common::LockGuard lock(g_tiler_mutex);
-	if (!g_tiler) {
-		g_tiler = std::make_unique<TileCompute>(GetRenderContext().GetGraphics());
-	}
-	g_tiler->Run(true, linear, tiled, tiled_capacity, linear_capacity, infos, before);
-}
-
-void GpuTileRelease() {
-	Common::LockGuard lock(g_tiler_mutex);
-	if (g_tiler) {
-		g_tiler->Release();
-		g_tiler.reset();
-	}
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/gpuTiler.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "graphics/guest_gpu/tile.h"
-
-#include <cstdint>
-#include <functional>
-#include <span>
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-struct VulkanBuffer;
-class CommandBuffer;
-
-struct GpuTileInfo {
-	TileBlockFamily family              = TileBlockFamily::Count;
-	uint32_t        bytes_per_element   = 0;
-	uint64_t        linear_offset       = 0;
-	uint64_t        linear_size         = 0;
-	uint64_t        tiled_offset        = 0;
-	uint64_t        tiled_size          = 0;
-	uint64_t        linear_slice_stride = 0;
-	uint32_t        width               = 0;
-	uint32_t        height              = 0;
-	uint32_t        depth               = 1;
-	uint32_t        pitch               = 0;
-	uint32_t        tail_x              = 0;
-	uint32_t        tail_y              = 0;
-	bool            tail                = false;
-	uint32_t        tiled_width         = 0;
-	uint32_t        tiled_height        = 0;
-	uint32_t        surface_z           = 0;
-};
-
-using GpuTileRecord = std::function<void(CommandBuffer&, VulkanBuffer&)>;
-
-void GpuDetile(const void* tiled, void* linear, uint64_t tiled_capacity,
-               uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-               const GpuTileRecord& after = {});
-void GpuTile(const void* linear, void* tiled, uint64_t tiled_capacity,
-             uint64_t linear_capacity, std::span<const GpuTileInfo> infos,
-             const GpuTileRecord& before = {});
-void GpuTileRelease();
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/graphicContext.h

@@ -6,8 +6,6 @@
 #include "graphics/host_gpu/vulkanCommon.h" // IWYU pragma: export
 #include "graphics/host_gpu/vulkanInstance.h"
 
-#include <memory>
-#include <mutex>
 #include <vector>
 #include <vk_mem_alloc.h>
 
@@ -18,32 +16,20 @@ struct VulkanBuffer;
 struct VulkanImage;
 struct VulkanMemory;
 
-struct VulkanSwapchain {
-	~VulkanSwapchain();
-
-	vk::SwapchainKHR                 swapchain        = nullptr;
-	vk::Format                       swapchain_format = vk::Format::eUndefined;
-	vk::Extent2D                     swapchain_extent = {};
-	std::unique_ptr<vk::Image[]>     swapchain_images;
-	std::unique_ptr<vk::ImageView[]> swapchain_image_views;
-	uint32_t                         swapchain_images_count = 0;
-	std::unique_ptr<vk::Semaphore[]> image_acquired_semaphores;
-	std::unique_ptr<vk::Semaphore[]> render_complete_semaphores;
-	uint32_t                         current_index = 0;
-	uint32_t                         present_frame = 0;
-};
-
 struct GraphicContext: public VulkanInstance {
 	[[nodiscard]] bool CreateAllocator();
 	void               DestroyAllocator();
 	void               LogMemoryBudget() const;
-	void               CreateBuffer(uint64_t size, VulkanBuffer& buffer);
+	[[nodiscard]] bool CanReportMemoryUsage() const noexcept { return memory_budget_ext_enabled; }
-	void               DeleteBuffer(VulkanBuffer& buffer);
+	[[nodiscard]] uint64_t GetDeviceMemoryUsage() const;
-	[[nodiscard]] bool CreateImage(const vk::ImageCreateInfo& info, VulkanImage& image);
+	[[nodiscard]] uint64_t GetTotalMemoryBudget() const;
-	void               DeleteImage(VulkanImage& image);
+	void                   CreateBuffer(uint64_t size, VulkanBuffer& buffer);
-	void               MapMemory(VulkanMemory& memory, void*& data);
+	void                   DeleteBuffer(VulkanBuffer& buffer);
-	void               UnmapMemory(VulkanMemory& memory);
+	[[nodiscard]] bool     CreateImage(const vk::ImageCreateInfo& info, VulkanImage& image);
-	void               AppendHardwareRayTracingDeviceExtensions(
+	void                   DeleteImage(VulkanImage& image);
+	void                   MapMemory(VulkanMemory& memory, void*& data);
+	void                   UnmapMemory(VulkanMemory& memory);
+	void                   AppendHardwareRayTracingDeviceExtensions(
 	    const std::vector<vk::ExtensionProperties>& available_extensions,
 	    std::vector<const char*>&                   device_extensions);
 	void LoadHardwareRayTracingFunctions() const;
@@ -64,92 +50,29 @@ struct VulkanMemory {
 	uint64_t                unique_id          = 0;
 };
 
-enum class VulkanImageType {
+struct VulkanImageState {
-	Unknown,
+	vk::PipelineStageFlags2 pl_stage    = vk::PipelineStageFlagBits2::eAllCommands;
-	VideoOut,
+	vk::AccessFlags2        access_mask = vk::AccessFlagBits2::eNone;
-	DepthStencil,
+	vk::ImageLayout         layout      = vk::ImageLayout::eUndefined;
-	Texture,
-	StorageTexture,
-	RenderTexture
-};
-
-struct ImageViewInfo {
-	vk::Format           format      = vk::Format::eUndefined;
-	vk::ImageViewType    type        = vk::ImageViewType::e2D;
-	vk::ImageAspectFlags aspect      = {};
-	uint32_t             base_level  = 0;
-	uint32_t             level_count = 0;
-	uint32_t             base_layer  = 0;
-	uint32_t             layer_count = 1;
-	uint32_t             swizzle     = 0;
-	vk::ImageUsageFlags  usage       = vk::ImageUsageFlagBits::eSampled;
-
-	bool operator==(const ImageViewInfo&) const = default;
-};
-
-struct CachedImageView {
-	ImageViewInfo info;
-	vk::ImageView view = nullptr;
-};
-
-struct ImageViewCache {
-	std::mutex                   mutex;
-	std::vector<CachedImageView> views;
-
-	ImageViewCache() = default;
-	KYTY_CLASS_NO_COPY(ImageViewCache);
 };
 
 struct VulkanImage {
-	static constexpr int VIEW_MAX           = 4;
+	VulkanImage() = default;
-	static constexpr int VIEW_DEFAULT       = 0;
-	static constexpr int VIEW_DEFAULT_ARRAY = 1;
-	static constexpr int VIEW_STORAGE       = 2;
-	static constexpr int VIEW_STORAGE_ARRAY = 3;
-
-	explicit VulkanImage(VulkanImageType type): type(type) {}
 	KYTY_CLASS_NO_COPY(VulkanImage);
 
-	VulkanImageType        type                 = VulkanImageType::Unknown;
+	vk::Format                    format      = vk::Format::eUndefined;
-	vk::Format             format               = vk::Format::eUndefined;
+	vk::ImageType                 image_type  = vk::ImageType::e2D;
-	vk::Extent2D           extent               = {};
+	vk::Extent3D                  extent      = {1, 1, 1};
-	uint32_t               guest_pitch          = 0;
+	uint32_t                      guest_pitch = 0;
-	uint32_t               layers               = 1;
+	uint32_t                      layers      = 1;
-	uint32_t               mip_levels           = 1;
+	uint32_t                      mip_levels  = 1;
-	uint32_t               samples              = 1;
+	uint32_t                      samples     = 1;
-	vk::Image              image                = nullptr;
+	vk::ImageUsageFlags           usage       = {};
-	vk::ImageView          image_view[VIEW_MAX] = {};
+	vk::ImageCreateFlags          flags       = {};
-	vk::ImageLayout        layout               = vk::ImageLayout::eUndefined;
+	vk::Image                     image       = nullptr;
-	Graphics::VulkanMemory memory;
+	VulkanImageState              state;
-	ImageViewCache         view_cache;
+	std::vector<VulkanImageState> subresource_states;
-};
+	Graphics::VulkanMemory        memory;
-
-struct VideoOutVulkanImage: public VulkanImage {
-	VideoOutVulkanImage(): VulkanImage(VulkanImageType::VideoOut) {}
-};
-
-struct DepthStencilVulkanImage: public VulkanImage {
-	DepthStencilVulkanImage(): VulkanImage(VulkanImageType::DepthStencil) {}
-	bool compressed                    = false;
-	bool initial_depth_clear_pending   = false;
-	bool initial_stencil_clear_pending = false;
-};
-
-struct GpuTextureVulkanImage: public VulkanImage {
-	explicit GpuTextureVulkanImage(VulkanImageType type): VulkanImage(type) {}
-};
-
-struct TextureVulkanImage: public GpuTextureVulkanImage {
-	TextureVulkanImage(): GpuTextureVulkanImage(VulkanImageType::Texture) {}
-};
-
-struct StorageTextureVulkanImage: public GpuTextureVulkanImage {
-	StorageTextureVulkanImage(): GpuTextureVulkanImage(VulkanImageType::StorageTexture) {}
-};
-
-struct RenderTextureVulkanImage: public VulkanImage {
-	RenderTextureVulkanImage(): VulkanImage(VulkanImageType::RenderTexture) {}
-	bool initial_clear_pending = false;
 };
 
 struct VulkanBuffer {
@@ -159,8 +82,6 @@ struct VulkanBuffer {
 	uint64_t             buffer_size = 0;
 };
 
-struct StorageVulkanBuffer: public VulkanBuffer {};
-
 } // namespace Libs::Graphics
 
 #endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_GRAPHICCONTEXT_H_ */

src/graphics/host_gpu/hostMemory.cpp

@@ -30,7 +30,7 @@ bool IsAccessible(DWORD protect, HostMemoryAccess access) {
 } // namespace
 
 bool HostMemoryQueryRange(uint64_t addr, uint64_t requested_size, HostMemoryAccess access,
-	                      uint64_t& accessible_size) {
+                          uint64_t& accessible_size) {
 	accessible_size = 0;
 	if (addr == 0 || requested_size == 0) {
 		return false;

src/graphics/host_gpu/hostMemory.h

@@ -8,7 +8,7 @@ namespace Libs::Graphics {
 enum class HostMemoryAccess { Read, Mapped };
 
 bool HostMemoryQueryRange(uint64_t addr, uint64_t requested_size, HostMemoryAccess access,
-	                      uint64_t& accessible_size);
+                          uint64_t& accessible_size);
 bool HostMemoryQueryReadable(uint64_t addr, uint64_t requested_size, uint64_t& readable_size);
 bool HostMemoryIsReadable(uint64_t addr);
 bool HostMemoryRangeIsReadable(uint64_t addr, uint64_t size);

src/graphics/host_gpu/memoryTracker.cpp

@@ -4,25 +4,9 @@
 
 namespace Libs::Graphics {
 
-#if defined(KYTY_MEMORY_TRACKER_TESTS)
-namespace {
-std::atomic<MemoryTracker::UnmapContentionHook> g_unmap_contention_hook {nullptr};
-}
-
-void MemoryTracker::SetUnmapContentionHook(UnmapContentionHook hook) noexcept {
-	g_unmap_contention_hook.store(hook, std::memory_order_release);
-}
-#endif
-
 static_assert(std::atomic<void*>::is_always_lock_free);
 
-MemoryTracker::MemoryTracker(PageManager& page_manager, PageWatchMode gpu_watch_mode)
+MemoryTracker::MemoryTracker(PageManager& page_manager): m_page_manager(page_manager) {
-    : m_page_manager(page_manager), m_gpu_watch_mode(gpu_watch_mode) {
-	switch (m_gpu_watch_mode) {
-		case PageWatchMode::Write:
-		case PageWatchMode::ReadWrite: break;
-		default: EXIT("unsupported memory tracker GPU page-watch mode\n");
-	}
 	m_regions = std::make_unique<std::atomic<RegionManager*>[]>(REGION_COUNT);
 	for (size_t i = 0; i < REGION_COUNT; i++) {
 		m_regions[i].store(nullptr, std::memory_order_relaxed);
@@ -31,6 +15,46 @@ MemoryTracker::MemoryTracker(PageManager& page_manager, PageWatchMode gpu_watch_
 
 MemoryTracker::~MemoryTracker() = default;
 
+#if KYTY_BUILD == KYTY_BUILD_DEBUG
+void MemoryTracker::ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+                                          const char* operation) const noexcept {
+	if (vaddr == 0 || size == 0 || size > UINT64_MAX - vaddr ||
+	    (vaddr & (TRACKER_PAGE_SIZE - 1)) != 0 || (size & (TRACKER_PAGE_SIZE - 1)) != 0) {
+		EXIT("MemoryTracker: invalid dirty-page validation range\n");
+	}
+	for (auto page = vaddr; page < vaddr + size; page += TRACKER_PAGE_SIZE) {
+		bool found = false;
+		dirty.ForEachIntersection(page, TRACKER_PAGE_SIZE,
+		                          [&found](RangeSet::Range) { found = true; });
+		if (!found) {
+			EXIT("MemoryTracker: GPU-dirty tracker page has no dirty bytes, operation=%s "
+			     "addr=0x%016" PRIx64 "\n",
+			     operation, page);
+		}
+	}
+}
+
+void MemoryTracker::ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+                                              const char* operation) {
+	ValidateRange(vaddr, size);
+	if (vaddr + size > UINT64_MAX - (TRACKER_PAGE_SIZE - 1)) {
+		EXIT("MemoryTracker: dirty ownership range alignment overflow\n");
+	}
+	const auto begin = vaddr & ~(TRACKER_PAGE_SIZE - 1);
+	const auto end   = (vaddr + size + TRACKER_PAGE_SIZE - 1) & ~(TRACKER_PAGE_SIZE - 1);
+	for (auto page = begin; page < end; page += TRACKER_PAGE_SIZE) {
+		bool has_dirty_bytes = false;
+		dirty.ForEachIntersection(page, TRACKER_PAGE_SIZE,
+		                          [&has_dirty_bytes](RangeSet::Range) { has_dirty_bytes = true; });
+		if (IsRegionGpuModified(page, TRACKER_PAGE_SIZE) != has_dirty_bytes) {
+			EXIT("MemoryTracker: tracker and byte ownership disagree, operation=%s "
+			     "addr=0x%016" PRIx64 "\n",
+			     operation, page);
+		}
+	}
+}
+#endif
+
 void MemoryTracker::ValidateRange(uint64_t vaddr, uint64_t size) {
 	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
 	    size > TRACKER_ADDRESS_SIZE - vaddr) {
@@ -56,7 +80,6 @@ RegionManager* MemoryTracker::GetOrCreateRegion(uint64_t index) {
 bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
 	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
 	return Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		return manager->IsModified<DirtySource::Cpu>(offset, bytes);
@@ -66,7 +89,6 @@ bool MemoryTracker::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
 bool MemoryTracker::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
 	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
 	return Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
 		return manager->IsModified<DirtySource::Gpu>(offset, bytes);
@@ -76,45 +98,31 @@ bool MemoryTracker::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 void MemoryTracker::MarkRegionAsCpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
 	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
 	Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		const auto       changed =
+		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-		    manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyProtection(changed, false);
 	});
 }
 
 void MemoryTracker::MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
 	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
+	Iterate<true>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-	Iterate<true>(vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		const auto       changed =
+		manager->ChangeState<DirtySource::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
-		    manager->ChangeState<DirtySource::Gpu, true>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyGpuProtection(changed, true, m_gpu_watch_mode);
 	});
 }
 
 void MemoryTracker::UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size) {
 	CheckNotInUploadCallback();
 	std::lock_guard access(m_access_mutex);
-	RequireMapped(vaddr, size);
+	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-	Iterate<true>(vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 		std::scoped_lock lock(manager->lock);
-		if (!manager->IsFullyModified<DirtySource::Gpu>(offset, bytes)) {
+		manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
-			EXIT("cannot clear partially GPU-dirty tracking range\n");
-		}
-		const auto changed =
-		    manager->ChangeState<DirtySource::Gpu, false>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyGpuProtection(changed, false, m_gpu_watch_mode);
 	});
 }
 
 void MemoryTracker::UntrackMemoryLocked(uint64_t vaddr, uint64_t size) {
-	RequireMapped(vaddr, size);
-
 	std::vector<RegionManager*> managers;
 	managers.reserve((vaddr % TRACKER_REGION_SIZE + size + TRACKER_REGION_SIZE - 1) /
 	                 TRACKER_REGION_SIZE);
@@ -133,10 +141,7 @@ void MemoryTracker::UntrackMemoryLocked(uint64_t vaddr, uint64_t size) {
 		EXIT("cannot untrack GPU-dirty memory\n");
 	}
 	Iterate<false>(vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		const auto changed =
+		manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-		    manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
-		manager->ApplyProtection(changed, false);
-		manager->Untrack(manager->GetCpuAddr() + offset, bytes);
 	});
 	locks.clear();
 }
@@ -147,109 +152,4 @@ void MemoryTracker::UntrackMemory(uint64_t vaddr, uint64_t size) {
 	UntrackMemoryLocked(vaddr, size);
 }
 
-void MemoryTracker::UnmapMemory(uint64_t vaddr, uint64_t size) {
-	CheckNotInUploadCallback();
-	std::unique_lock access(m_access_mutex, std::try_to_lock);
-	if (!access.owns_lock()) {
-#if defined(KYTY_MEMORY_TRACKER_TESTS)
-		if (const auto hook = g_unmap_contention_hook.load(std::memory_order_acquire);
-		    hook != nullptr) {
-			hook();
-		}
-#endif
-		access.lock();
-	}
-	UntrackMemoryLocked(vaddr, size);
-	m_page_manager.OnGpuUnmap(vaddr, size);
-}
-
-bool MemoryTracker::InvalidateRegion(uint64_t vaddr, uint64_t size, PageFaultPhase phase) noexcept {
-	switch (phase) {
-		case PageFaultPhase::Release: return true;
-		case PageFaultPhase::Invalidate: {
-			const auto action = BeginCpuFault(vaddr, size);
-			switch (action) {
-				case CpuFaultAction::Untracked: return false;
-				case CpuFaultAction::Continue: return true;
-				case CpuFaultAction::Download:
-					EXIT("generic region invalidation cannot download GPU-dirty memory\n");
-			}
-		}
-		case PageFaultPhase::Complete:
-			return CompleteCpuFault(vaddr, size, PageFaultAccess::Write, false);
-	}
-	EXIT("unsupported region invalidation phase\n");
-}
-
-bool MemoryTracker::InvalidateVirtualGpuWrite(PageFaultAccess access, uint64_t vaddr, uint64_t size,
-                                              PageFaultPhase phase) noexcept {
-	switch (phase) {
-		case PageFaultPhase::Release: return true;
-		case PageFaultPhase::Invalidate: {
-			const bool gpu_modified = Iterate<false>(
-			    vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    std::scoped_lock lock(manager->lock);
-				    return manager->IsModified<DirtySource::Gpu>(offset, bytes);
-			    });
-			if (!gpu_modified) {
-				return false;
-			}
-			const auto action = BeginCpuFault(vaddr, size);
-			if (access != PageFaultAccess::Write || action != CpuFaultAction::Download) {
-				EXIT("virtual GPU write fault requires write access to GPU-dirty memory\n");
-			}
-			return true;
-		}
-		case PageFaultPhase::Complete: {
-			if (access != PageFaultAccess::Write) {
-				EXIT("virtual GPU write completion requires write access\n");
-			}
-			bool completed = false;
-			Iterate<false>(
-			    vaddr, size, [&completed](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    std::scoped_lock lock(manager->lock);
-				    if (completed) {
-					    EXIT("virtual GPU write fault spans multiple tracked regions\n");
-				    }
-				    completed =
-				        manager->CompleteVirtualGpuWrite(manager->GetCpuAddr() + offset, bytes);
-			    });
-			return completed;
-		}
-	}
-	EXIT("unsupported virtual GPU write invalidation phase\n");
-}
-
-CpuFaultAction MemoryTracker::BeginCpuFault(uint64_t vaddr, uint64_t size,
-                                            PageFaultAccess access) noexcept {
-	CheckNotInUploadCallback();
-	CpuFaultAction action = CpuFaultAction::Untracked;
-	Iterate<false>(
-	    vaddr, size, [&action, access](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		    std::scoped_lock lock(manager->lock);
-		    if (action != CpuFaultAction::Untracked) {
-			    EXIT("CPU fault spans multiple tracked regions\n");
-		    }
-		    action = manager->BeginCpuFault(manager->GetCpuAddr() + offset, bytes, access);
-	    });
-	return action;
-}
-
-bool MemoryTracker::CompleteCpuFault(uint64_t vaddr, uint64_t size, PageFaultAccess access,
-                                     bool downloaded) noexcept {
-	CheckNotInUploadCallback();
-	bool found = false;
-	Iterate<false>(
-	    vaddr, size,
-	    [&found, access, downloaded](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-		    std::scoped_lock lock(manager->lock);
-		    if (found) {
-			    EXIT("CPU fault completion spans multiple tracked regions\n");
-		    }
-		    found = manager->CompleteCpuFault(manager->GetCpuAddr() + offset, bytes, access,
-		                                      downloaded);
-	    });
-	return found;
-}
-
 } // namespace Libs::Graphics

src/graphics/host_gpu/memoryTracker.h

@@ -3,6 +3,7 @@
 
 #include "common/assert.h"
 #include "graphics/host_gpu/pageManager.h"
+#include "graphics/host_gpu/rangeSet.h"
 #include "graphics/host_gpu/regionManager.h"
 
 #include <algorithm>
@@ -10,14 +11,14 @@
 #include <memory>
 #include <mutex>
 #include <type_traits>
+#include <utility>
 #include <vector>
 
 namespace Libs::Graphics {
 
 class MemoryTracker final {
 public:
-	explicit MemoryTracker(PageManager&  page_manager,
+	explicit MemoryTracker(PageManager& page_manager);
-	                       PageWatchMode gpu_watch_mode = PageWatchMode::ReadWrite);
 	~MemoryTracker();
 
 	KYTY_CLASS_NO_COPY(MemoryTracker);
@@ -28,24 +29,62 @@ 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);
-	void               UnmapMemory(uint64_t vaddr, uint64_t size);
+	template <typename Flush>
-	[[nodiscard]] CpuFaultAction
+	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) {
-	                   BeginCpuFault(uint64_t vaddr, uint64_t size,
+		static_assert(std::is_invocable_v<Flush&>);
-	                                 PageFaultAccess access = PageFaultAccess::Write) noexcept;
+		CheckNotInUploadCallback();
-	[[nodiscard]] bool CompleteCpuFault(uint64_t vaddr, uint64_t size, PageFaultAccess access,
+		ValidateRange(vaddr, size);
-	                                    bool downloaded) noexcept;
+
-	[[nodiscard]] bool InvalidateRegion(uint64_t vaddr, uint64_t size,
+		const auto update_cpu_state = [this, vaddr, size] {
-	                                    PageFaultPhase phase) noexcept;
+			std::lock_guard             access(m_access_mutex);
-	[[nodiscard]] bool InvalidateVirtualGpuWrite(PageFaultAccess access, uint64_t vaddr,
+			std::vector<RegionManager*> managers;
-	                                             uint64_t size, PageFaultPhase phase) noexcept;
+			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,
+	                           const char* operation) const noexcept;
+	void ValidateGpuDirtyOwnership(const RangeSet& dirty, uint64_t vaddr, uint64_t size,
+	                               const char* operation);
+#else
+	void ValidateGpuDirtyPages(const RangeSet&, uint64_t, uint64_t, const char*) const noexcept {}
+	void ValidateGpuDirtyOwnership(const RangeSet&, uint64_t, uint64_t, const char*) {}
+#endif
 
 	template <bool clear, typename Preflight, typename Func>
 	void ForEachDownloadRange(uint64_t vaddr, uint64_t size, Preflight&& preflight, Func&& func) {
 		static_assert(std::is_nothrow_invocable_v<Preflight&, uint64_t, uint64_t>);
 		static_assert(std::is_nothrow_invocable_v<Func&, uint64_t, uint64_t>);
 		CheckNotInUploadCallback();
-		std::lock_guard access(m_access_mutex);
+		std::lock_guard             access(m_access_mutex);
-		RequireMapped(vaddr, size);
 		std::vector<RegionManager*> managers;
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t, uint64_t) {
 			managers.push_back(manager);
@@ -57,9 +96,6 @@ public:
 		}
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 			const auto address = manager->GetCpuAddr() + offset;
-			if (manager->HasPendingFault(address, bytes)) {
-				EXIT("GPU download synchronization raced a pending CPU fault\n");
-			}
 			manager->template ForEachModifiedRange<DirtySource::Gpu, false>(address, bytes,
 			                                                                preflight);
 		});
@@ -71,10 +107,8 @@ public:
 			Iterate<false>(vaddr, size,
 			               [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 				               const auto address = manager->GetCpuAddr() + offset;
-				               const auto changed =
+				               manager->template ForEachModifiedRange<DirtySource::Gpu, true>(
-				                   manager->template ForEachModifiedRange<DirtySource::Gpu, true>(
+				                   address, bytes, [](uint64_t, uint64_t) noexcept {});
-				                       address, bytes, [](uint64_t, uint64_t) noexcept {});
-				               manager->ApplyGpuProtection(changed, false, m_gpu_watch_mode);
 			               });
 		}
 	}
@@ -85,11 +119,6 @@ public:
 		    vaddr, size, [](uint64_t, uint64_t) noexcept {}, std::forward<Func>(func));
 	}
 
-#if defined(KYTY_MEMORY_TRACKER_TESTS)
-	using UnmapContentionHook = void (*)() noexcept;
-	static void SetUnmapContentionHook(UnmapContentionHook hook) noexcept;
-#endif
-
 	template <typename RangeFunc, typename UploadFunc>
 	void ForEachUploadRange(uint64_t vaddr, uint64_t size, bool is_written, RangeFunc&& range_func,
 	                        UploadFunc&& upload_func) {
@@ -97,12 +126,10 @@ public:
 		static_assert(std::is_nothrow_invocable_v<UploadFunc&>);
 		CheckNotInUploadCallback();
 		std::unique_lock access(m_access_mutex);
-		RequireMapped(vaddr, size);
 		Iterate<true>(vaddr, size, [](RegionManager*, uint64_t, uint64_t) {});
-		s_upload_owner = this;
+		const auto* previous_upload_owner = std::exchange(s_upload_owner, this);
 		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
 			manager->lock.lock();
-			manager->Track(manager->GetCpuAddr() + offset, bytes);
 			manager->ForEachModifiedRange<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset,
 			                                                      bytes, range_func);
 			if (!is_written) {
@@ -111,23 +138,22 @@ public:
 		});
 		upload_func();
 		if (is_written) {
-			Iterate<false>(
+			Iterate<false>(vaddr, size,
-			    vaddr, size, [this](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+			               [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    const auto changed = manager->template ChangeState<DirtySource::Gpu, true>(
+				               manager->template ChangeState<DirtySource::Gpu, true>(
-				        manager->GetCpuAddr() + offset, bytes);
+				                   manager->GetCpuAddr() + offset, bytes);
-				    manager->ApplyGpuProtection(changed, true, m_gpu_watch_mode);
+				               manager->lock.unlock();
-				    manager->lock.unlock();
+			               });
-			    });
 		}
-		s_upload_owner = nullptr;
+		s_upload_owner = previous_upload_owner;
 	}
 
 private:
 	static constexpr size_t REGION_COUNT = TRACKER_ADDRESS_SIZE / TRACKER_REGION_SIZE;
 	inline static thread_local const MemoryTracker* s_upload_owner = nullptr;
 
-	static void CheckNotInUploadCallback() noexcept {
+	void CheckNotInUploadCallback() const noexcept {
-		if (s_upload_owner != nullptr) {
+		if (s_upload_owner == this) {
 			EXIT("memory tracker re-entered from upload callback\n");
 		}
 	}
@@ -162,14 +188,8 @@ private:
 		return false;
 	}
 
-	static void ValidateRange(uint64_t vaddr, uint64_t size);
+	static void    ValidateRange(uint64_t vaddr, uint64_t size);
-	void        UntrackMemoryLocked(uint64_t vaddr, uint64_t size);
+	void           UntrackMemoryLocked(uint64_t vaddr, uint64_t size);
-	void        RequireMapped(uint64_t vaddr, uint64_t size) const {
-		ValidateRange(vaddr, size);
-		if (!m_page_manager.IsMapped(vaddr, size)) {
-			EXIT("memory tracker range is not mapped\n");
-		}
-	}
 	RegionManager* GetOrCreateRegion(uint64_t index);
 
 	std::unique_ptr<std::atomic<RegionManager*>[]> m_regions;
@@ -177,7 +197,6 @@ private:
 	std::mutex                                     m_region_mutex;
 	std::mutex                                     m_access_mutex;
 	PageManager&                                   m_page_manager;
-	PageWatchMode                                  m_gpu_watch_mode = PageWatchMode::ReadWrite;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/objects/label.cpp

@@ -1,348 +0,0 @@
-#include "graphics/host_gpu/objects/label.h"
-
-#include "common/assert.h"
-#include "common/threads.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <algorithm>
-#include <memory>
-#include <vector>
-
-namespace Libs::Graphics {
-
-enum LabelStatus {
-	New,
-	Active,
-	ActiveDeleted,
-	NotActive,
-};
-
-struct LabelCallbacks {
-	LabelCallback callback_1           = nullptr;
-	LabelCallback callback_2           = nullptr;
-	uint64_t      args[LABEL_ARGS_MAX] = {};
-};
-
-struct LabelEvent final {
-	vk::Device device = nullptr;
-	vk::Event  event  = nullptr;
-
-	~LabelEvent() {
-		if (event != nullptr) {
-			device.destroyEvent(event, nullptr);
-		}
-	}
-};
-
-struct LabelSubmission {
-	std::shared_ptr<LabelEvent> completion;
-	LabelCallbacks              callbacks;
-};
-
-struct Label {
-	vk::Device                   device = nullptr;
-	LabelStatus                  status = LabelStatus::New;
-	LabelCallbacks               callbacks;
-	std::vector<LabelSubmission> submissions;
-};
-
-class LabelManager {
-public:
-	LabelManager() {
-		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
-		Common::Thread t(ThreadRun, this);
-		t.Detach();
-	}
-	~LabelManager() { KYTY_NOT_IMPLEMENTED; }
-	KYTY_CLASS_NO_COPY(LabelManager);
-
-	Label* Create(LabelCallback callback_1, LabelCallback callback_2, const uint64_t* args);
-	void   Delete(Label& label);
-	void   Set(CommandBuffer& buffer, Label& label);
-	void   Drain();
-
-private:
-	static void ThreadRun(void* data);
-
-	bool        Remove(Label& label);
-	static void Destroy(Label& label);
-
-	Common::Mutex       m_mutex;
-	Common::CondVar     m_cond_var;
-	std::vector<Label*> m_labels;
-	uint64_t            m_callbacks_in_flight = 0;
-};
-
-static LabelManager*     g_label_manager     = nullptr;
-static thread_local bool g_in_label_callback = false;
-
-class LabelCallbackScope final {
-public:
-	LabelCallbackScope() {
-		if (g_in_label_callback) {
-			EXIT("recursive GPU label callback\n");
-		}
-		g_in_label_callback = true;
-	}
-	~LabelCallbackScope() {
-		if (!g_in_label_callback) {
-			EXIT("GPU label callback scope is not active\n");
-		}
-		g_in_label_callback = false;
-	}
-};
-
-void LabelManager::ThreadRun(void* data) {
-	auto* manager = static_cast<LabelManager*>(data);
-
-	for (;;) {
-		manager->m_mutex.Lock();
-
-		uint64_t active_count = 0;
-
-		std::vector<Label*>          deleted_labels;
-		std::vector<LabelCallbacks>  fired_labels;
-		std::vector<LabelSubmission> finished_submissions;
-		deleted_labels.reserve(manager->m_labels.size());
-
-		for (auto& label: manager->m_labels) {
-			for (auto it = label->submissions.begin(); it != label->submissions.end();) {
-				active_count++;
-
-				if (it->completion == nullptr || it->completion->device == nullptr ||
-				    it->completion->event == nullptr) {
-					EXIT("GPU label submission has no completion event\n");
-				}
-				const auto status = it->completion->device.getEventStatus(it->completion->event);
-				switch (status) {
-					case vk::Result::eEventSet:
-						fired_labels.push_back(it->callbacks);
-						finished_submissions.push_back(*it);
-						it = label->submissions.erase(it);
-						break;
-					case vk::Result::eEventReset: ++it; break;
-					default: EXIT("vkGetEventStatus returned an unexpected result\n");
-				}
-			}
-
-			if (label->submissions.empty()) {
-				switch (label->status) {
-					case LabelStatus::ActiveDeleted: deleted_labels.push_back(label); break;
-					case LabelStatus::Active: label->status = LabelStatus::NotActive; break;
-					default: break;
-				}
-			}
-		}
-
-		if (active_count == 0) {
-			manager->m_cond_var.Wait(&manager->m_mutex);
-		}
-		if (fired_labels.size() > UINT64_MAX - manager->m_callbacks_in_flight) {
-			EXIT("GPU label callback count overflow\n");
-		}
-		manager->m_callbacks_in_flight += fired_labels.size();
-
-		for (auto& label: deleted_labels) {
-			bool removed = manager->Remove(*label);
-			EXIT_NOT_IMPLEMENTED(!removed);
-		}
-
-		manager->m_mutex.Unlock();
-
-		// Each completion event is shared with the recording command buffer's fence retainer.
-		// The event is destroyed only after both the label thread observed it and that command
-		// buffer completed, even when either side wins the race.
-		(void)finished_submissions;
-
-		for (auto& label: deleted_labels) {
-			Destroy(*label);
-		}
-
-		for (auto& label: fired_labels) {
-			LabelCallbackScope callback_scope;
-
-			if (label.callback_1 != nullptr) {
-				(void)label.callback_1(label.args);
-			}
-
-			if (label.callback_2 != nullptr) {
-				label.callback_2(label.args);
-			}
-		}
-
-		if (!fired_labels.empty()) {
-			Common::LockGuard lock(manager->m_mutex);
-			if (manager->m_callbacks_in_flight < fired_labels.size()) {
-				EXIT("GPU label callback count underflow\n");
-			}
-			manager->m_callbacks_in_flight -= fired_labels.size();
-			manager->m_cond_var.SignalAll();
-		}
-
-		Common::Thread::SleepMicro(100);
-	}
-}
-
-Label* LabelManager::Create(LabelCallback callback_1, LabelCallback callback_2,
-                            const uint64_t* args) {
-	Common::LockGuard lock(m_mutex);
-
-	auto* label = new Label;
-
-	label->status               = LabelStatus::New;
-	label->device               = GetRenderContext().GetGraphics().device;
-	label->callbacks.callback_1 = callback_1;
-	label->callbacks.callback_2 = callback_2;
-
-	if (args != nullptr) {
-		for (int i = 0; i < LABEL_ARGS_MAX; i++) {
-			label->callbacks.args[i] = args[i];
-		}
-	}
-
-	m_labels.push_back(label);
-
-	return label;
-}
-
-bool LabelManager::Remove(Label& label) {
-	EXIT_IF(label.device == nullptr);
-
-	Common::LockGuard lock(m_mutex);
-
-	const auto it = std::find(m_labels.begin(), m_labels.end(), &label);
-	EXIT_NOT_IMPLEMENTED(it == m_labels.end());
-
-	EXIT_NOT_IMPLEMENTED(label.status != LabelStatus::NotActive &&
-	                     label.status != LabelStatus::Active &&
-	                     label.status != LabelStatus::ActiveDeleted);
-
-	if (!label.submissions.empty()) {
-		label.status = LabelStatus::ActiveDeleted;
-
-		return false;
-	}
-
-	m_labels.erase(it);
-
-	return true;
-}
-
-void LabelManager::Destroy(Label& label) {
-	EXIT_IF(label.device == nullptr);
-
-	EXIT_NOT_IMPLEMENTED(!label.submissions.empty());
-
-	delete &label;
-}
-
-void LabelManager::Delete(Label& label) {
-	if (Remove(label)) {
-		Destroy(label);
-	}
-}
-
-void LabelManager::Set(CommandBuffer& buffer, Label& label) {
-	EXIT_IF(buffer.IsInvalid());
-	EXIT_IF(label.device == nullptr);
-
-	Common::LockGuard lock(m_mutex);
-
-	const auto it = std::find(m_labels.begin(), m_labels.end(), &label);
-	EXIT_NOT_IMPLEMENTED(it == m_labels.end());
-
-	EXIT_NOT_IMPLEMENTED(label.status != LabelStatus::New &&
-	                     label.status != LabelStatus::NotActive &&
-	                     label.status != LabelStatus::Active);
-
-	label.status = LabelStatus::Active;
-
-	LabelSubmission submission {};
-	submission.callbacks          = label.callbacks;
-	submission.completion         = std::make_shared<LabelEvent>();
-	submission.completion->device = label.device;
-
-	auto vk_buffer = buffer.Handle();
-
-	EXIT_NOT_IMPLEMENTED(vk_buffer == nullptr);
-
-	vk::EventCreateInfo create_info {};
-	create_info.sType = vk::StructureType::eEventCreateInfo;
-	create_info.pNext = nullptr;
-	create_info.flags = {};
-
-	const auto create_result =
-	    label.device.createEvent(&create_info, nullptr, &submission.completion->event);
-	if (create_result != vk::Result::eSuccess || submission.completion->event == nullptr) {
-		EXIT("failed to create label event: %s (%d)\n", VulkanToString(create_result).c_str(),
-		     static_cast<int>(create_result));
-	}
-	buffer.RetainResourceUntilFence(submission.completion);
-
-	// Labels can be reused before an earlier end-of-pipe event has been
-	// observed by the polling thread. Capture a separate Vulkan event and
-	// callback snapshot for each set so older writes are not lost.
-	const auto reset_result = label.device.resetEvent(submission.completion->event);
-	if (reset_result != vk::Result::eSuccess) {
-		EXIT("failed to reset label event: %s (%d)\n", VulkanToString(reset_result).c_str(),
-		     static_cast<int>(reset_result));
-	}
-	vk_buffer.setEvent(submission.completion->event, vk::PipelineStageFlagBits::eBottomOfPipe);
-
-	label.submissions.push_back(submission);
-
-	m_cond_var.SignalAll();
-}
-
-void LabelManager::Drain() {
-	m_mutex.Lock();
-	for (;;) {
-		const bool pending = std::any_of(m_labels.begin(), m_labels.end(), [](const Label* label) {
-			return !label->submissions.empty();
-		});
-		if (!pending && m_callbacks_in_flight == 0) {
-			m_mutex.Unlock();
-			return;
-		}
-		m_cond_var.SignalAll();
-		m_cond_var.Wait(&m_mutex);
-	}
-}
-
-void LabelInit() {
-	EXIT_IF(g_label_manager != nullptr);
-
-	g_label_manager = new LabelManager;
-}
-
-Label* LabelCreate(LabelCallback callback_1, LabelCallback callback_2, const uint64_t* args) {
-	EXIT_IF(g_label_manager == nullptr);
-
-	return g_label_manager->Create(callback_1, callback_2, args);
-}
-
-void LabelDelete(Label& label) {
-	EXIT_IF(g_label_manager == nullptr);
-
-	g_label_manager->Delete(label);
-}
-
-void LabelSet(CommandBuffer& buffer, Label& label) {
-	EXIT_IF(g_label_manager == nullptr);
-
-	g_label_manager->Set(buffer, label);
-}
-
-void LabelDrain() {
-	EXIT_IF(g_label_manager == nullptr);
-	g_label_manager->Drain();
-}
-
-bool LabelInCallback() noexcept {
-	return g_in_label_callback;
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/objects/label.h

@@ -1,26 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_LABEL_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_LABEL_H_
-
-#include "common/abi.h"
-#include "common/common.h"
-
-namespace Libs::Graphics {
-
-struct Label;
-class CommandBuffer;
-struct GraphicContext;
-
-void LabelInit();
-
-constexpr int LABEL_ARGS_MAX = 5;
-using LabelCallback          = bool (*)(const uint64_t* args);
-
-Label* LabelCreate(LabelCallback callback_1, LabelCallback callback_2, const uint64_t* args);
-void   LabelDelete(Label& label);
-void   LabelSet(CommandBuffer& buffer, Label& label);
-void   LabelDrain();
-[[nodiscard]] bool LabelInCallback() noexcept;
-
-} // namespace Libs::Graphics
-
-#endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_LABEL_H_ */

src/graphics/host_gpu/objects/textureCommon.h

@@ -1,137 +0,0 @@
-#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_TEXTURECOMMON_H_
-#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_TEXTURECOMMON_H_
-
-#include "common/abi.h"
-#include "common/common.h"
-#include "graphics/guest_gpu/gpu_defs.h"
-#include "graphics/guest_gpu/tile.h"
-#include "graphics/host_gpu/transfer.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <vector>
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-struct VulkanImage;
-
-enum class TextureFormatUsage : uint32_t {
-	None    = 0,
-	Sampled = 1u << 0u,
-	Storage = 1u << 1u,
-};
-
-constexpr TextureFormatUsage operator|(TextureFormatUsage lhs, TextureFormatUsage rhs) {
-	return static_cast<TextureFormatUsage>(static_cast<uint32_t>(lhs) | static_cast<uint32_t>(rhs));
-}
-
-constexpr TextureFormatUsage operator&(TextureFormatUsage lhs, TextureFormatUsage rhs) {
-	return static_cast<TextureFormatUsage>(static_cast<uint32_t>(lhs) & static_cast<uint32_t>(rhs));
-}
-
-constexpr TextureFormatUsage operator~(TextureFormatUsage usage) {
-	return static_cast<TextureFormatUsage>(~static_cast<uint32_t>(usage));
-}
-
-constexpr TextureFormatUsage& operator|=(TextureFormatUsage& lhs, TextureFormatUsage rhs) {
-	lhs = lhs | rhs;
-	return lhs;
-}
-
-constexpr bool TextureHasFormatUsage(TextureFormatUsage usage, TextureFormatUsage flag) {
-	return (static_cast<uint32_t>(usage & flag) == static_cast<uint32_t>(flag));
-}
-
-enum class TextureUploadDestination { MipLevels, MipAtlas };
-
-struct RenderTargetFormatInfo {
-	vk::Format                      format            = vk::Format::eUndefined;
-	uint32_t                        bytes_per_element = 0;
-	Prospero::ColorComponentMapping export_mapping;
-};
-
-struct TextureUploadLayout {
-	uint32_t        tile                = 0;
-	uint32_t        pitch               = 0;
-	uint64_t        slice_stride        = 0;
-	uint64_t        source_slice_stride = 0;
-	uint32_t        first_tail_level    = 16;
-	TileBlockFamily tile_family         = TileBlockFamily::Count;
-	bool            volume_texture      = false;
-	TileSizeOffset  level_sizes[16]     = {};
-	TilePaddedSize  padded_sizes[16]    = {};
-};
-
-struct TextureImageCreateParams {
-	uint32_t                 fmt                      = 0;
-	uint64_t                 width                    = 0;
-	uint64_t                 height                   = 0;
-	uint32_t                 base_level               = 0;
-	uint64_t                 levels                   = 1;
-	uint32_t                 depth                    = 1;
-	uint64_t                 type                     = 0;
-	uint64_t                 swizzle                  = 0;
-	TextureFormatUsage       format_usage             = TextureFormatUsage::Sampled;
-	TextureFormatUsage       required_format_usage    = TextureFormatUsage::Sampled;
-	TextureFormatUsage       view_usage               = TextureFormatUsage::Sampled;
-	TextureUploadDestination image_layout             = TextureUploadDestination::MipLevels;
-	bool                     allow_cube_view          = false;
-	bool                     compatible_format_views  = false;
-	bool                     storage_swizzle_fallback = false;
-	const char*              owner                    = nullptr;
-};
-
-vk::ComponentSwizzle TextureGetComponentSwizzle(uint8_t s);
-vk::ComponentMapping TextureGetComponentMapping(uint32_t swizzle);
-bool                 TextureCheckFormat(vk::ImageCreateInfo& image_info);
-bool TextureCheckStorageSwizzle(vk::ImageCreateInfo& image_info, vk::ComponentMapping& components);
-vk::ImageUsageFlags    TextureGetUsage(TextureFormatUsage usage);
-vk::ImageUsageFlags    TextureGetViewUsage(TextureFormatUsage usage);
-vk::Format             TextureGetFormat(uint32_t fmt);
-RenderTargetFormatInfo TextureGetRenderTargetFormat(uint32_t layout, uint32_t type, uint32_t order);
-uint32_t TextureGetAtlasSliceYStride(vk::Format format, uint32_t mip_height, uint32_t depth,
-                                     uint64_t levels);
-uint32_t TextureCalcStackedImageHeight(vk::Format format, uint32_t height, uint32_t depth,
-                                       uint64_t levels);
-uint32_t TextureCalcMipmapAtlasImageHeight(vk::Format format, uint32_t width, uint32_t height,
-                                           uint32_t depth, uint64_t levels);
-bool     TextureIs3DTexture(uint64_t type);
-bool     TextureIsCubeTexture(uint64_t type);
-bool     TextureIsLayeredTexture(uint64_t type);
-bool     TextureCanCreateCubeView(uint64_t type, uint32_t base_array, uint32_t layer_count);
-vk::ComponentMapping TextureCreateImage(VulkanImage& image,
-                                        const TextureImageCreateParams& params);
-void TextureCreateImageViews(VulkanImage& vk_obj,
-                             vk::ComponentMapping components, uint64_t type, uint32_t base_array,
-                             uint32_t base_level, uint32_t level_count, uint32_t depth,
-                             bool allow_cube_view, TextureFormatUsage view_usage);
-TextureUploadLayout TextureCalcUploadLayout(uint32_t fmt, uint64_t width, uint64_t height,
-                                            uint64_t levels, uint32_t depth, uint64_t pitch,
-                                            uint64_t tile, uint64_t upload_size,
-                                            bool allow_depth_tile, bool volume_texture,
-                                            const char* owner);
-uint64_t TextureUploadSliceSourceOffset(const TextureUploadLayout& layout, uint32_t level,
-                                        uint32_t slice);
-uint64_t TextureCalcUploadSize(const TextureUploadLayout&          layout,
-                               const std::vector<BufferImageCopy>& regions, uint64_t levels,
-                               uint32_t depth);
-std::vector<BufferImageCopy> TextureBuildUploadRegions(const TextureUploadLayout& layout,
-                                                       vk::Format image_format, uint32_t width,
-                                                       uint32_t height, uint32_t depth,
-                                                       uint64_t levels, bool array_texture,
-                                                       bool                     volume_texture,
-                                                       TextureUploadDestination destination);
-std::vector<ImageBufferCopy>
-TextureBuildDownloadRegions(const std::vector<BufferImageCopy>& upload_regions);
-bool TextureBuildGpuTileInfos(uint64_t size, const std::vector<BufferImageCopy>& regions,
-                              const TextureUploadLayout& layout, uint32_t fmt, uint32_t depth,
-                              uint64_t levels, std::vector<GpuTileInfo>& infos);
-void TextureUploadGuestImage(VulkanImage& vk_obj, const void* src_data,
-                             uint64_t size, const std::vector<BufferImageCopy>& regions,
-                             const TextureUploadLayout& layout, uint32_t fmt, uint64_t width,
-                             uint64_t height, uint32_t depth, uint64_t levels, const char* owner,
-                             vk::ImageLayout dst_layout);
-
-} // namespace Libs::Graphics
-
-#endif /* EMULATOR_INCLUDE_EMULATOR_GRAPHICS_OBJECTS_TEXTURECOMMON_H_ */

src/graphics/host_gpu/pageManager.cpp

@@ -1,13 +1,14 @@
 #include "graphics/host_gpu/pageManager.h"
 
 #include "graphics/host_gpu/regionDefinitions.h"
+#include "kernel/memory.h"
 
+#include <algorithm>
 #include <array>
 #include <atomic>
 #include <cstdarg>
 #include <cstdio>
 #include <cstdlib>
-#include <limits>
 #include <memory>
 #include <mutex>
 #include <vector>
@@ -19,6 +20,11 @@
 #include <windows.h>
 #undef min
 #undef max
+#elif defined(__APPLE__)
+#include <unistd.h>
+#else
+#include <execinfo.h>
+#include <unistd.h>
 #endif
 
 namespace Libs::Graphics {
@@ -28,9 +34,19 @@ constexpr uint64_t PAGE_SIZE    = TRACKER_PAGE_SIZE;
 constexpr uint64_t REGION_SIZE  = TRACKER_REGION_SIZE;
 constexpr uint64_t ADDRESS_SIZE = TRACKER_ADDRESS_SIZE;
 constexpr uint64_t REGION_COUNT = ADDRESS_SIZE / REGION_SIZE;
+
+#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
+// The tracker reuses Win32 memory-protection tags as internal page-state values.
+// Mirror their canonical numeric values so the shared state-machine logic is identical.
+constexpr uint32_t PAGE_NOACCESS  = 0x01;
+constexpr uint32_t PAGE_READONLY  = 0x02;
+constexpr uint32_t PAGE_READWRITE = 0x04;
+#endif
 constexpr uint64_t REGION_PAGES = REGION_SIZE / PAGE_SIZE;
 
-thread_local bool g_in_fault_resolution = false;
+constexpr uint32_t NO_ACCESS_PROTECTION  = PAGE_NOACCESS;
+constexpr uint32_t READ_ONLY_PROTECTION  = PAGE_READONLY;
+constexpr uint32_t READ_WRITE_PROTECTION = PAGE_READWRITE;
 
 [[noreturn]] void FailFast(const char* reason = nullptr) noexcept {
 	std::fputs("PageManager fail-fast: ", stderr);
@@ -46,6 +62,10 @@ thread_local bool g_in_fault_resolution = false;
 		std::fprintf(stderr, "  frame[%u]=0x%016" PRIxPTR " image_rva=0x%016" PRIxPTR "\n", i,
 		             address, address >= image_base ? address - image_base : 0);
 	}
+#elif !defined(__APPLE__)
+	void*     frames[16] {};
+	const int frame_count = ::backtrace(frames, static_cast<int>(std::size(frames)));
+	::backtrace_symbols_fd(frames, frame_count, STDERR_FILENO);
 #endif
 	std::fflush(stderr);
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
@@ -65,12 +85,13 @@ thread_local bool g_in_fault_resolution = false;
 	std::_Exit(322);
 }
 
-uint32_t CurrentThread() noexcept {
+Common::VirtualMemory::Mode ToMemoryMode(uint32_t protection) {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	switch (protection) {
-	return GetCurrentThreadId();
+		case NO_ACCESS_PROTECTION: return Common::VirtualMemory::Mode::NoAccess;
-#else
+		case READ_ONLY_PROTECTION: return Common::VirtualMemory::Mode::Read;
-	FailFast();
+		case READ_WRITE_PROTECTION: return Common::VirtualMemory::Mode::ReadWrite;
-#endif
+		default: Fatal("unmappable protection 0x%08" PRIx32, protection);
+	}
 }
 
 class SpinGuard final {
@@ -106,28 +127,61 @@ uint64_t PageEnd(uint64_t vaddr, uint64_t size) {
 
 struct PageManager::Impl {
 	struct PageState {
-		std::atomic_flag lock                 = ATOMIC_FLAG_INIT;
+		uint8_t write_watchers  : 7 = 0;
-		uint32_t         mappings             = 0;
+		uint8_t access_watchers : 1 = 0;
-		uint32_t         gpu_read_mappings    = 0;
+
-		uint32_t         gpu_write_mappings   = 0;
+		[[nodiscard]] uint32_t Perms() const noexcept {
-		uint32_t         write_watchers       = 0;
+			if (access_watchers != 0) {
-		uint32_t         access_watchers      = 0;
+				return NO_ACCESS_PROTECTION;
-		uint32_t         original_protection  = 0;
+			}
-		uint32_t         backing_writer       = 0;
+			if (write_watchers != 0) {
-		bool             resolving            = false;
+				return READ_ONLY_PROTECTION;
-		bool             resolving_read_write = false;
+			}
-		bool             late_read_pending    = false;
+			return READ_WRITE_PROTECTION;
-		bool             late_write_pending   = false;
+		}
+
+		template <int delta, bool is_read>
+		uint32_t AddDelta(uint64_t address) {
+			static_assert(delta >= -1 && delta <= 1);
+			if constexpr (is_read) {
+				if constexpr (delta == 1) {
+					if (access_watchers != 0) {
+						Fatal("read-watcher overflow at 0x%016" PRIx64, address);
+					}
+					return ++access_watchers;
+				} else if constexpr (delta == -1) {
+					if (access_watchers == 0) {
+						Fatal("read-watcher underflow at 0x%016" PRIx64, address);
+					}
+					return --access_watchers;
+				} else {
+					return access_watchers;
+				}
+			} else {
+				if constexpr (delta == 1) {
+					if (write_watchers == 0x7f) {
+						Fatal("write-watcher overflow at 0x%016" PRIx64, address);
+					}
+					return ++write_watchers;
+				} else if constexpr (delta == -1) {
+					if (write_watchers == 0) {
+						Fatal("write-watcher underflow at 0x%016" PRIx64, address);
+					}
+					return --write_watchers;
+				} else {
+					return write_watchers;
+				}
+			}
+		}
 	};
+	static_assert(sizeof(PageState) == 1);
 
 	struct Region {
+		std::atomic_flag                    lock = ATOMIC_FLAG_INIT;
 		std::array<PageState, REGION_PAGES> pages;
 	};
 
-	Impl(PageFaultHandler handler, void* context): fault_handler(handler), fault_context(context) {
+	Impl() {
-		if (fault_handler == nullptr) {
-			Fatal("null fault handler");
-		}
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 		SYSTEM_INFO info {};
 		GetSystemInfo(&info);
@@ -135,8 +189,16 @@ struct PageManager::Impl {
 			Fatal("unsupported host page size 0x%08" PRIx32,
 			      static_cast<uint32_t>(info.dwPageSize));
 		}
+#elif defined(__APPLE__)
+		// Under Rosetta the host page size is 4 KB, matching TRACKER_PAGE_SIZE.
+		if (static_cast<uint64_t>(getpagesize()) != PAGE_SIZE) {
+			Fatal("unsupported host page size 0x%08" PRIx32, static_cast<uint32_t>(getpagesize()));
+		}
 #else
-		Fatal("page-fault invalidation is not implemented on this platform");
+		const auto host_page_size = ::sysconf(_SC_PAGESIZE);
+		if (host_page_size < 0 || static_cast<uint64_t>(host_page_size) != PAGE_SIZE) {
+			Fatal("unsupported host page size %ld", static_cast<long>(host_page_size));
+		}
 #endif
 		regions = std::make_unique<std::atomic<Region*>[]>(REGION_COUNT);
 		for (uint64_t i = 0; i < REGION_COUNT; i++) {
@@ -146,11 +208,9 @@ struct PageManager::Impl {
 
 	~Impl() {
 		for (const auto& region: region_storage) {
+			SpinGuard lock(region->lock);
 			for (auto& page: region->pages) {
-				SpinGuard lock(page.lock);
+				if (page.write_watchers != 0 || page.access_watchers != 0) {
-				if (page.mappings != 0 || page.gpu_read_mappings != 0 ||
-				    page.gpu_write_mappings != 0 || page.write_watchers != 0 ||
-				    page.access_watchers != 0 || page.backing_writer != 0 || page.resolving) {
 					FailFast("PageManager destroyed with live page state");
 				}
 			}
@@ -178,508 +238,140 @@ struct PageManager::Impl {
 		return ptr;
 	}
 
-	PageState& GetPage(Region& region, uint64_t vaddr) const {
+	void Protect(uint64_t vaddr, uint64_t size, uint32_t protection) noexcept {
-		return region.pages[(vaddr % REGION_SIZE) / PAGE_SIZE];
+		if (!Libs::LibKernel::Memory::ProtectGuestHostMemory(vaddr, size,
-	}
+		                                                     ToMemoryMode(protection))) {
-
+			Fatal("address-space protection failed at 0x%016" PRIx64 ", new=0x%08" PRIx32, vaddr,
-	static uint32_t WatcherProtection(const PageState& page) {
+			      protection);
-		if (page.access_watchers != 0) {
-			return PAGE_NOACCESS;
-		}
-		if (page.write_watchers != 0) {
-			return PAGE_READONLY;
-		}
-		return page.original_protection;
-	}
-
-	static void PublishDelayedFaults(PageState& page, uint32_t old_protection,
-	                                 uint32_t new_protection) {
-		if (old_protection == PAGE_NOACCESS && new_protection != PAGE_NOACCESS) {
-			page.late_read_pending = true;
-		}
-		if ((old_protection == PAGE_NOACCESS || old_protection == PAGE_READONLY) &&
-		    new_protection == PAGE_READWRITE) {
-			page.late_write_pending = true;
 		}
 	}
 
-	static uint32_t QueryProtection(uint64_t vaddr) {
+	template <bool track, bool is_read, bool masked>
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	void UpdateRegionWatchers(Region& region, uint64_t base_addr, size_t first, size_t last,
-		MEMORY_BASIC_INFORMATION info {};
+	                          const RegionBits* mask = nullptr) {
-		if (VirtualQuery(reinterpret_cast<const void*>(static_cast<uintptr_t>(vaddr)), &info,
+		SpinGuard lock(region.lock);
-		                 sizeof(info)) == 0 ||
+		auto      perms                 = region.pages[first].Perms();
-		    info.State != MEM_COMMIT || info.Protect != PAGE_READWRITE) {
+		uint64_t  range_begin           = 0;
-			Fatal("basic path requires PAGE_READWRITE at 0x%016" PRIx64 " (state=0x%08" PRIx32
+		uint64_t  range_bytes           = 0;
-			      ", protection=0x%08" PRIx32 ")",
+		uint64_t  potential_range_bytes = 0;
-			      vaddr, static_cast<uint32_t>(info.State), static_cast<uint32_t>(info.Protect));
-		}
-		return info.Protect;
-#else
-		(void)vaddr;
-		Fatal("page query is unsupported on this platform");
-#endif
-	}
 
-	static bool AllowsAccess(uint64_t vaddr, PageFaultAccess access) noexcept {
+		const auto release_pending = [&] {
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+			if (range_bytes != 0) {
-		MEMORY_BASIC_INFORMATION info {};
+				Protect(base_addr + range_begin * PAGE_SIZE, range_bytes, perms);
-		if (VirtualQuery(reinterpret_cast<const void*>(static_cast<uintptr_t>(vaddr)), &info,
+				range_bytes           = 0;
-		                 sizeof(info)) == 0 ||
+				potential_range_bytes = 0;
-		    info.State != MEM_COMMIT) {
+			}
-			return false;
+		};
-		}
-		switch (access) {
-			case PageFaultAccess::Read:
-				return info.Protect == PAGE_READONLY || info.Protect == PAGE_READWRITE;
-			case PageFaultAccess::Write: return info.Protect == PAGE_READWRITE;
-			default: return false;
-		}
-#else
-		(void)vaddr;
-		return false;
-#endif
-	}
 
-	static void Protect(uint64_t vaddr, uint32_t protection, uint32_t expected_old,
+		for (size_t page_index = first; page_index < last; page_index++) {
-	                    bool fault_path) noexcept {
+			auto&      page    = region.pages[page_index];
-#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+			const auto address = base_addr + page_index * PAGE_SIZE;
-		DWORD old_protection = 0;
+			const bool update  = !masked || mask->Get(page_index);
-		if (VirtualProtect(reinterpret_cast<void*>(static_cast<uintptr_t>(vaddr)), PAGE_SIZE,
+
-		                   protection, &old_protection) == 0 ||
+			const auto old_perms = page.Perms();
-		    old_protection != expected_old) {
+			const auto new_count = update ? page.AddDelta<track ? 1 : -1, is_read>(address)
-			if (fault_path) {
+			                              : page.AddDelta<0, is_read>(address);
-				FailFast("VirtualProtect fault transition did not match expected protection");
+			const auto new_perms = page.Perms();
+
+			if (new_perms != perms) [[unlikely]] {
+				release_pending();
+				perms = new_perms;
+			} else if (range_bytes != 0) {
+				potential_range_bytes += PAGE_SIZE;
+			}
+
+			if (!update) {
+				continue;
+			}
+
+			const bool watcher_edge = (track && new_count == 1) || (!track && new_count == 0);
+			if (watcher_edge && old_perms != new_perms) {
+				if (range_bytes == 0) {
+					range_begin           = page_index;
+					potential_range_bytes = PAGE_SIZE;
+				}
+				range_bytes = potential_range_bytes;
 			}
-			Fatal("invalid protection transition at 0x%016" PRIx64 ", old=0x%08" PRIx32
-			      ", expected=0x%08" PRIx32 ", new=0x%08" PRIx32,
-			      vaddr, static_cast<uint32_t>(old_protection), expected_old, protection);
 		}
-#else
+
-		(void)vaddr;
+		release_pending();
-		(void)protection;
+	}
-		(void)fault_path;
+
-		FailFast("page protection is unsupported on this platform");
+	template <bool track, bool is_read>
-#endif
+	void UpdatePageWatchers(uint64_t vaddr, uint64_t size) {
+		const auto begin = PageStart(vaddr);
+		const auto end   = PageEnd(vaddr, size);
+		for (auto chunk_begin = begin; chunk_begin < end;) {
+			const auto chunk_end   = std::min(end, (chunk_begin / REGION_SIZE + 1) * REGION_SIZE);
+			const auto region_base = chunk_begin / REGION_SIZE * REGION_SIZE;
+			auto*      region = track ? GetOrCreateRegion(chunk_begin) : FindRegion(chunk_begin);
+			if (region == nullptr) {
+				Fatal("untracking unknown page 0x%016" PRIx64, chunk_begin);
+			}
+			const auto first = static_cast<size_t>((chunk_begin - region_base) / PAGE_SIZE);
+			const auto last  = static_cast<size_t>((chunk_end - region_base) / PAGE_SIZE);
+			UpdateRegionWatchers<track, is_read, false>(*region, region_base, first, last);
+			chunk_begin = chunk_end;
+		}
 	}
 
 	std::unique_ptr<std::atomic<Region*>[]> regions;
 	std::vector<std::unique_ptr<Region>>    region_storage;
 	std::mutex                              region_mutex;
-	PageFaultHandler                        fault_handler = nullptr;
-	void*                                   fault_context = nullptr;
 };
 
 static_assert(std::atomic<void*>::is_always_lock_free);
 
-PageManager::PageManager(PageFaultHandler fault_handler, void* fault_context)
+PageManager::PageManager(): m_impl(std::make_unique<Impl>()) {}
-    : m_impl(std::make_unique<Impl>(fault_handler, fault_context)) {}
 
 PageManager::~PageManager() = default;
 
 uint64_t PageManager::GetPageSize() const {
-	if (g_in_fault_resolution) {
-		FailFast("nested page fault while resolving a watched page");
-	}
 	return PAGE_SIZE;
 }
 
-bool PageManager::IsTracked(uint64_t vaddr) const noexcept {
+template <bool track>
-	if (g_in_fault_resolution) {
+void PageManager::UpdatePageWatchers(uint64_t vaddr, uint64_t size) {
-		FailFast("IsTracked called during fault resolution");
+	m_impl->UpdatePageWatchers<track, false>(vaddr, size);
+}
+
+template void PageManager::UpdatePageWatchers<true>(uint64_t, uint64_t);
+template void PageManager::UpdatePageWatchers<false>(uint64_t, uint64_t);
+
+template <bool track, bool is_read>
+void PageManager::UpdatePageWatchersForRegion(uint64_t base_addr, RegionBits& mask) {
+	if (base_addr % REGION_SIZE != 0 || base_addr >= ADDRESS_SIZE ||
+	    REGION_SIZE > ADDRESS_SIZE - base_addr) {
+		Fatal("invalid tracking region base 0x%016" PRIx64, base_addr);
 	}
-	auto* region = m_impl->FindRegion(vaddr);
+
+	const auto start_range = mask.FirstRange();
+	const auto end_range   = mask.LastRange();
+	if (start_range.first == REGION_PAGES) {
+		FailFast("empty region watcher mask");
+	}
+	const auto first = start_range.first;
+	const auto last  = end_range.second;
+	if (start_range.second == end_range.second) {
+		m_impl->UpdatePageWatchers<track, is_read>(base_addr + first * PAGE_SIZE,
+		                                           (last - first) * PAGE_SIZE);
+		return;
+	}
+
+	auto* region = track ? m_impl->GetOrCreateRegion(base_addr) : m_impl->FindRegion(base_addr);
 	if (region == nullptr) {
-		return false;
+		Fatal("untracking unknown region 0x%016" PRIx64, base_addr);
 	}
-	auto&     page = m_impl->GetPage(*region, vaddr);
+	m_impl->UpdateRegionWatchers<track, is_read, true>(*region, base_addr, first, last, &mask);
-	SpinGuard lock(page.lock);
-	return page.write_watchers != 0 || page.access_watchers != 0;
 }
 
-bool PageManager::IsMapped(uint64_t vaddr, uint64_t size) const noexcept {
+template void PageManager::UpdatePageWatchersForRegion<true, true>(uint64_t, RegionBits&);
-	if (g_in_fault_resolution || vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE ||
+template void PageManager::UpdatePageWatchersForRegion<true, false>(uint64_t, RegionBits&);
-	    size > ADDRESS_SIZE - vaddr) {
+template void PageManager::UpdatePageWatchersForRegion<false, true>(uint64_t, RegionBits&);
-		return false;
+template void PageManager::UpdatePageWatchersForRegion<false, false>(uint64_t, RegionBits&);
-	}
-	const auto end = PageStart(vaddr + size - 1) + PAGE_SIZE;
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			return false;
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.mappings == 0) {
-			return false;
-		}
-	}
-	return true;
-}
 
-bool PageManager::HasAnyMapping(uint64_t vaddr, uint64_t size) const noexcept {
+void PageManager::OnGpuMap(uint64_t, uint64_t) {}
-	if (g_in_fault_resolution || vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE ||
-	    size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			continue;
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.mappings != 0) {
-			return true;
-		}
-	}
-	return false;
-}
 
-bool PageManager::HasGpuAccess(uint64_t vaddr, uint64_t size, GpuAccess access) const noexcept {
+void PageManager::OnGpuUnmap(uint64_t, uint64_t) {}
-	if (access != GpuAccess::Read && access != GpuAccess::Write && access != GpuAccess::ReadWrite) {
-		FailFast("HasGpuAccess received an invalid GPU access mode");
-	}
-	const bool need_read  = access == GpuAccess::Read || access == GpuAccess::ReadWrite;
-	const bool need_write = access == GpuAccess::Write || access == GpuAccess::ReadWrite;
-	if (vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE || size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto addr = PageStart(vaddr); addr < end; addr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(addr);
-		if (region == nullptr) {
-			return false;
-		}
-		auto&     page = m_impl->GetPage(*region, addr);
-		SpinGuard lock(page.lock);
-		if ((need_read && page.gpu_read_mappings == 0) ||
-		    (need_write && page.gpu_write_mappings == 0)) {
-			return false;
-		}
-	}
-	return true;
-}
-
-void PageManager::UpdatePageWatchers(bool track, uint64_t vaddr, uint64_t size,
-                                     PageWatchMode mode) {
-	if (g_in_fault_resolution) {
-		FailFast("page watchers changed during fault resolution");
-	}
-	if (mode != PageWatchMode::Write && mode != PageWatchMode::ReadWrite) {
-		Fatal("invalid watcher mode");
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region =
-		    track ? m_impl->GetOrCreateRegion(page_vaddr) : m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			Fatal("untracking unknown page 0x%016" PRIx64, page_vaddr);
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.resolving && track) {
-			FailFast("new page watcher raced active fault resolution");
-		}
-		if (page.mappings == 0) {
-			Fatal("watching unmapped page 0x%016" PRIx64, page_vaddr);
-		}
-		auto& watchers =
-		    (mode == PageWatchMode::ReadWrite ? page.access_watchers : page.write_watchers);
-		if (track) {
-			if (watchers == std::numeric_limits<uint32_t>::max()) {
-				Fatal("watcher overflow at 0x%016" PRIx64, page_vaddr);
-			}
-			const bool first_watcher = page.write_watchers == 0 && page.access_watchers == 0;
-			if (first_watcher) {
-				page.original_protection = Impl::QueryProtection(page_vaddr);
-			}
-			const auto old_protection = Impl::WatcherProtection(page);
-			watchers++;
-			const auto new_protection = Impl::WatcherProtection(page);
-			if (new_protection != old_protection) {
-				Impl::Protect(page_vaddr, new_protection, old_protection, false);
-			}
-			switch (new_protection) {
-				case PAGE_NOACCESS:
-					page.late_read_pending  = false;
-					page.late_write_pending = false;
-					break;
-				case PAGE_READONLY: page.late_write_pending = false; break;
-				default: break;
-			}
-		} else {
-			if (watchers == 0) {
-				Fatal("watcher underflow at 0x%016" PRIx64, page_vaddr);
-			}
-			if (page.backing_writer != 0 && page.backing_writer != CurrentThread()) {
-				Fatal("backing write ownership changed at 0x%016" PRIx64, page_vaddr);
-			}
-			const auto old_protection = Impl::WatcherProtection(page);
-			watchers--;
-			const auto new_protection = Impl::WatcherProtection(page);
-			if (page.backing_writer == 0 && new_protection != old_protection) {
-				Impl::Protect(page_vaddr, new_protection, old_protection, false);
-			}
-			if (page.backing_writer == 0) {
-				Impl::PublishDelayedFaults(page, old_protection, new_protection);
-			}
-			if (page.backing_writer == 0 && page.write_watchers == 0 && page.access_watchers == 0) {
-				page.original_protection = 0;
-			}
-		}
-	}
-}
-
-void PageManager::OnGpuMap(uint64_t vaddr, uint64_t size, GpuAccess access) {
-	if (g_in_fault_resolution) {
-		FailFast("GPU mapping changed during fault resolution");
-	}
-	if (access != GpuAccess::Read && access != GpuAccess::Write && access != GpuAccess::ReadWrite) {
-		FailFast("GPU map received an invalid access mode");
-	}
-	const bool gpu_read  = access == GpuAccess::Read || access == GpuAccess::ReadWrite;
-	const bool gpu_write = access == GpuAccess::Write || access == GpuAccess::ReadWrite;
-	const auto end       = PageEnd(vaddr, size);
-	for (auto addr = PageStart(vaddr); addr < end; addr += PAGE_SIZE) {
-		auto&     page = m_impl->GetPage(*m_impl->GetOrCreateRegion(addr), addr);
-		SpinGuard lock(page.lock);
-		if (page.resolving || page.mappings == std::numeric_limits<uint32_t>::max() ||
-		    (gpu_read && page.gpu_read_mappings == std::numeric_limits<uint32_t>::max()) ||
-		    (gpu_write && page.gpu_write_mappings == std::numeric_limits<uint32_t>::max())) {
-			Fatal("invalid map state at 0x%016" PRIx64, addr);
-		}
-		page.mappings++;
-		page.gpu_read_mappings += gpu_read ? 1u : 0u;
-		page.gpu_write_mappings += gpu_write ? 1u : 0u;
-	}
-}
-
-void PageManager::OnGpuUnmap(uint64_t vaddr, uint64_t size, GpuAccess access) {
-	if (g_in_fault_resolution) {
-		FailFast("GPU unmapping changed during fault resolution");
-	}
-	if (access != GpuAccess::Read && access != GpuAccess::Write && access != GpuAccess::ReadWrite) {
-		FailFast("GPU unmap received an invalid access mode");
-	}
-	const bool gpu_read  = access == GpuAccess::Read || access == GpuAccess::ReadWrite;
-	const bool gpu_write = access == GpuAccess::Write || access == GpuAccess::ReadWrite;
-	const auto end       = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(page_vaddr);
-		if (region == nullptr) {
-			Fatal("unmapping unknown page 0x%016" PRIx64, page_vaddr);
-		}
-		auto&     page = m_impl->GetPage(*region, page_vaddr);
-		SpinGuard lock(page.lock);
-		if (page.resolving || page.mappings == 0 || (gpu_read && page.gpu_read_mappings == 0) ||
-		    (gpu_write && page.gpu_write_mappings == 0) ||
-		    (page.mappings == 1 && (page.write_watchers != 0 || page.access_watchers != 0))) {
-			Fatal("invalid unmap state at 0x%016" PRIx64, page_vaddr);
-		}
-		page.mappings--;
-		page.gpu_read_mappings -= gpu_read ? 1u : 0u;
-		page.gpu_write_mappings -= gpu_write ? 1u : 0u;
-		if (page.mappings == 0) {
-			if (page.gpu_read_mappings != 0 || page.gpu_write_mappings != 0) {
-				FailFast("GPU unmap left nonzero GPU mapping counts");
-			}
-			page.late_read_pending  = false;
-			page.late_write_pending = false;
-		}
-	}
-}
-
-PageManager::BackingWrite::BackingWrite(PageManager& manager, uint64_t vaddr,
-                                        uint64_t size) noexcept
-    : m_manager(manager), m_vaddr(vaddr), m_size(size) {
-	m_manager.BeginBackingWrite(vaddr, size);
-}
-
-PageManager::BackingWrite::~BackingWrite() {
-	m_manager.EndBackingWrite(m_vaddr, m_size);
-}
-
-void PageManager::BeginBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("backing write began during fault resolution");
-	}
-	const auto end    = PageEnd(vaddr, size);
-	const auto writer = CurrentThread();
-	for (auto address = PageStart(vaddr); address < end; address += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(address);
-		if (region == nullptr) {
-			Fatal("backing write reserves an unknown page at 0x%016" PRIx64, address);
-		}
-		auto&     page = m_impl->GetPage(*region, address);
-		SpinGuard lock(page.lock);
-		if (page.mappings == 0 || page.resolving || page.backing_writer != 0 ||
-		    page.access_watchers == 0) {
-			Fatal("backing write races page resolution at 0x%016" PRIx64, address);
-		}
-		page.resolving            = true;
-		page.resolving_read_write = true;
-		page.backing_writer       = writer;
-	}
-}
-
-void PageManager::EndBackingWrite(uint64_t vaddr, uint64_t size) noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("backing write ended during fault resolution");
-	}
-	const auto end    = PageEnd(vaddr, size);
-	const auto writer = CurrentThread();
-	for (auto address = PageStart(vaddr); address < end; address += PAGE_SIZE) {
-		auto* region = m_impl->FindRegion(address);
-		if (region == nullptr) {
-			FailFast("backing write ended for an unknown page");
-		}
-		auto&     page = m_impl->GetPage(*region, address);
-		SpinGuard lock(page.lock);
-		if (!page.resolving || page.backing_writer != writer) {
-			FailFast("backing write ended without matching owner and resolving state");
-		}
-		const auto old_protection = PAGE_NOACCESS;
-		const auto new_protection = Impl::WatcherProtection(page);
-		if (new_protection != old_protection) {
-			Impl::Protect(address, new_protection, old_protection, false);
-		}
-		Impl::PublishDelayedFaults(page, old_protection, new_protection);
-		if (page.write_watchers == 0 && page.access_watchers == 0) {
-			page.original_protection = 0;
-		}
-		page.backing_writer       = 0;
-		page.resolving            = false;
-		page.resolving_read_write = false;
-	}
-}
-
-bool PageManager::HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept {
-	if (g_in_fault_resolution) {
-		FailFast("nested HandleFault call");
-	}
-	auto* region = m_impl->FindRegion(fault_vaddr);
-	if (region == nullptr) {
-		return false;
-	}
-	auto& page   = m_impl->GetPage(*region, fault_vaddr);
-	bool  waited = false;
-	while (true) {
-		SpinGuard lock(page.lock);
-		if (access == PageFaultAccess::Read && page.late_read_pending &&
-		    Impl::AllowsAccess(fault_vaddr, access)) {
-			page.late_read_pending = false;
-			return true;
-		}
-		if (access == PageFaultAccess::Write && page.late_write_pending &&
-		    Impl::AllowsAccess(fault_vaddr, access)) {
-			page.late_write_pending = false;
-			return true;
-		}
-		if (page.resolving) {
-			if (page.backing_writer == CurrentThread()) {
-				FailFast("backing writer faulted on its own reserved page");
-			}
-			if ((!page.resolving_read_write && access != PageFaultAccess::Write) ||
-			    (page.resolving_read_write && access != PageFaultAccess::Read &&
-			     access != PageFaultAccess::Write)) {
-				FailFast("fault access is incompatible with the active resolver");
-			}
-			waited = true;
-			continue;
-		}
-		if (page.write_watchers == 0 && page.access_watchers == 0) {
-			if (access != PageFaultAccess::Read && access != PageFaultAccess::Write) {
-				return false;
-			}
-			bool&      pending = (access == PageFaultAccess::Read ? page.late_read_pending
-			                                                      : page.late_write_pending);
-			const bool allowed = Impl::AllowsAccess(fault_vaddr, access);
-			pending            = false;
-			if (waited && !allowed) {
-				FailFast("page remained inaccessible after waiting for its resolver");
-			}
-			// More than one CPU can fault before a protection transition becomes visible. The first
-			// delayed fault consumes the hint bit; later faults must also resume once the mapped
-			// page already permits the requested access. A genuinely read-only/no-access page still
-			// falls through to the guest exception path.
-			return allowed;
-		}
-		if ((access != PageFaultAccess::Read && access != PageFaultAccess::Write) ||
-		    (access == PageFaultAccess::Read && page.access_watchers == 0)) {
-			FailFast("fault access is incompatible with active page watchers");
-		}
-		page.resolving            = true;
-		page.resolving_read_write = page.access_watchers != 0;
-		break;
-	}
-	g_in_fault_resolution = true;
-	const bool handled    = m_impl->fault_handler(m_impl->fault_context, access, fault_vaddr, 1,
-	                                              PageFaultPhase::Invalidate);
-	g_in_fault_resolution = false;
-	{
-		SpinGuard lock(page.lock);
-		if (!handled || !page.resolving) {
-			FailFast("fault invalidation did not preserve the resolving state");
-		}
-	}
-	g_in_fault_resolution = true;
-	const bool completed  = m_impl->fault_handler(m_impl->fault_context, access, fault_vaddr, 1,
-	                                              PageFaultPhase::Complete);
-	g_in_fault_resolution = false;
-	{
-		SpinGuard lock(page.lock);
-		if (!completed || !page.resolving) {
-			FailFast("fault completion did not preserve the resolving state");
-		}
-		if (page.write_watchers != 0 || page.access_watchers != 0) {
-			const auto old_protection  = Impl::WatcherProtection(page);
-			const bool read_only_fault = access == PageFaultAccess::Read;
-			if (read_only_fault && page.access_watchers == 0) {
-				FailFast("read fault completed without a read/write watcher");
-			}
-			page.access_watchers = 0;
-			if (!read_only_fault) {
-				page.write_watchers = 0;
-			}
-			const auto restored_protection = Impl::WatcherProtection(page);
-			Impl::Protect(PageStart(fault_vaddr), restored_protection, old_protection, true);
-			if (page.write_watchers == 0) {
-				page.original_protection = 0;
-			}
-			Impl::PublishDelayedFaults(page, old_protection, restored_protection);
-		} else if (!Impl::AllowsAccess(fault_vaddr, access)) {
-			FailFast("fault completion left the page inaccessible");
-		}
-		page.resolving            = false;
-		page.resolving_read_write = false;
-	}
-	g_in_fault_resolution = true;
-	const bool released   = m_impl->fault_handler(m_impl->fault_context, access, fault_vaddr, 1,
-	                                              PageFaultPhase::Release);
-	g_in_fault_resolution = false;
-	if (!released) {
-		FailFast("fault release callback failed");
-	}
-	return true;
-}
-
-bool PageManager::HandleWriteRange(uint64_t vaddr, uint64_t size) noexcept {
-	if (g_in_fault_resolution || vaddr == 0 || size == 0 || vaddr >= ADDRESS_SIZE ||
-	    size > ADDRESS_SIZE - vaddr) {
-		return false;
-	}
-	const auto end = PageEnd(vaddr, size);
-	for (auto page_vaddr = PageStart(vaddr); page_vaddr < end; page_vaddr += PAGE_SIZE) {
-		if (!IsMapped(page_vaddr, 1)) {
-			continue;
-		}
-		const auto fault_vaddr = std::max(page_vaddr, vaddr);
-		if (!HandleFault(PageFaultAccess::Write, fault_vaddr)) {
-			return false;
-		}
-	}
-	return true;
-}
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/pageManager.h

@@ -2,57 +2,32 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_PAGEMANAGER_H_
 
 #include "common/common.h"
+#include "graphics/host_gpu/regionDefinitions.h"
 
 #include <memory>
 
 namespace Libs::Graphics {
 
 enum class PageFaultAccess { Read, Write, Execute, Unknown };
-enum class PageFaultPhase { Invalidate, Complete, Release };
-enum class PageWatchMode { Write, ReadWrite };
-enum class GpuAccess { Read, Write, ReadWrite };
-
-using PageFaultHandler = bool (*)(void* context, PageFaultAccess access, uint64_t vaddr,
-                                  uint64_t size, PageFaultPhase phase) noexcept;
 
 class PageManager final {
 public:
-	class BackingWrite final {
+	PageManager();
-	public:
-		BackingWrite(PageManager& manager, uint64_t vaddr, uint64_t size) noexcept;
-		~BackingWrite();
-		KYTY_CLASS_NO_COPY(BackingWrite);
-
-	private:
-		PageManager& m_manager;
-		uint64_t     m_vaddr = 0;
-		uint64_t     m_size  = 0;
-	};
-
-	PageManager(PageFaultHandler fault_handler, void* fault_context);
 	// The owner must stop all PageManager callers before destruction.
 	~PageManager();
 
 	KYTY_CLASS_NO_COPY(PageManager);
 
 	[[nodiscard]] uint64_t GetPageSize() const;
-	[[nodiscard]] bool     IsTracked(uint64_t vaddr) const noexcept;
-	[[nodiscard]] bool     IsMapped(uint64_t vaddr, uint64_t size) const noexcept;
-	[[nodiscard]] bool     HasAnyMapping(uint64_t vaddr, uint64_t size) const noexcept;
-	[[nodiscard]] bool HasGpuAccess(uint64_t vaddr, uint64_t size, GpuAccess access) const noexcept;
 
-	void UpdatePageWatchers(bool track, uint64_t vaddr, uint64_t size,
+	template <bool track>
-	                        PageWatchMode mode = PageWatchMode::Write);
+	void UpdatePageWatchers(uint64_t vaddr, uint64_t size);
-	void OnGpuMap(uint64_t vaddr, uint64_t size, GpuAccess access = GpuAccess::ReadWrite);
+	template <bool track, bool is_read = false>
-	void OnGpuUnmap(uint64_t vaddr, uint64_t size, GpuAccess access = GpuAccess::ReadWrite);
+	void UpdatePageWatchersForRegion(uint64_t base_addr, RegionBits& mask);
-
+	void OnGpuMap(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] bool HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept;
+	void OnGpuUnmap(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] bool HandleWriteRange(uint64_t vaddr, uint64_t size) noexcept;
 
 private:
-	void BeginBackingWrite(uint64_t vaddr, uint64_t size) noexcept;
-	void EndBackingWrite(uint64_t vaddr, uint64_t size) noexcept;
-
 	struct Impl;
 	std::unique_ptr<Impl> m_impl;
 };

src/graphics/host_gpu/rangeSet.h

@@ -59,6 +59,16 @@ public:
 		return result;
 	}
 
+	[[nodiscard]] bool Contains(uint64_t address, uint64_t size) const {
+		const auto end = End(address, size);
+		auto       it  = m_ranges.upper_bound(address);
+		if (it == m_ranges.begin()) {
+			return false;
+		}
+		--it;
+		return it->first <= address && it->second >= end;
+	}
+
 	template <typename Func>
 	void ForEachIntersection(uint64_t address, uint64_t size, Func&& func) const {
 		const auto end = End(address, size);

src/graphics/host_gpu/regionDefinitions.h

@@ -1,10 +1,9 @@
 #ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_REGIONDEFINITIONS_H_
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_REGIONDEFINITIONS_H_
 
+#include "common/bitArray.h"
 #include "common/common.h"
 
-#include <bitset>
-
 namespace Libs::Graphics {
 
 constexpr uint64_t TRACKER_PAGE_SIZE    = 4ull * 1024ull;
@@ -13,7 +12,8 @@ constexpr uint64_t TRACKER_ADDRESS_SIZE = 1ull << 40u;
 constexpr size_t   TRACKER_REGION_PAGES = TRACKER_REGION_SIZE / TRACKER_PAGE_SIZE;
 
 enum class DirtySource { Cpu, Gpu };
-using RegionBits = std::bitset<TRACKER_REGION_PAGES>;
+using RegionBits = Common::BitArray<TRACKER_REGION_PAGES>;
+static_assert(sizeof(RegionBits) == TRACKER_REGION_PAGES / 8);
 
 } // namespace Libs::Graphics
 

src/graphics/host_gpu/regionManager.h

@@ -16,12 +16,15 @@
 #include <windows.h>
 #undef min
 #undef max
+#elif defined(__APPLE__)
+#include <pthread.h>
+#elif defined(__linux__)
+#include <sys/syscall.h>
+#include <unistd.h>
 #endif
 
 namespace Libs::Graphics {
 
-enum class CpuFaultAction { Untracked, Continue, Download };
-
 class TrackingSpinLock final {
 public:
 	void lock() noexcept {
@@ -49,6 +52,12 @@ private:
 	static uint32_t CurrentThread() noexcept {
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 		return GetCurrentThreadId();
+#elif defined(__APPLE__)
+		// mach thread port is a nonzero per-thread id (0 is the "no owner" sentinel).
+		return static_cast<uint32_t>(pthread_mach_thread_np(pthread_self()));
+#elif defined(__linux__)
+		static thread_local const uint32_t tid = static_cast<uint32_t>(::syscall(SYS_gettid));
+		return tid;
 #else
 		EXIT("region tracking thread identity is unsupported on this platform\n");
 #endif
@@ -67,229 +76,93 @@ public:
 		if (m_cpu_addr % TRACKER_REGION_SIZE != 0) {
 			EXIT("invalid region tracking manager construction\n");
 		}
-		m_cpu_dirty.set();
+		m_cpu_dirty.Fill();
-		m_writable.set();
+		m_writable.Fill();
+		m_readable.Fill();
 	}
 
 	KYTY_CLASS_NO_COPY(RegionManager);
 
 	[[nodiscard]] uint64_t GetCpuAddr() const { return m_cpu_addr; }
-	void                   Track(uint64_t vaddr, uint64_t size) {
-		const auto [start, end] = GetPageRange(vaddr, size);
-		for (auto page = start; page < end; page++) {
-			m_tracked.set(page);
-		}
-	}
-	void Untrack(uint64_t vaddr, uint64_t size) {
-		const auto [start, end] = GetPageRange(vaddr, size);
-		for (auto page = start; page < end; page++) {
-			m_tracked.reset(page);
-		}
-	}
 	template <DirtySource source>
 	[[nodiscard]] bool IsModified(uint64_t offset, uint64_t size) const {
 		const auto [start, end] = GetPageRange(m_cpu_addr + offset, size);
 		const auto& bits        = GetBits<source>();
-		for (auto page = start; page < end; page++) {
+		return RegionBits(bits, start, end).Any();
-			if (bits.test(page)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	template <DirtySource source>
-	[[nodiscard]] bool IsFullyModified(uint64_t offset, uint64_t size) const {
-		const auto [start, end] = GetPageRange(m_cpu_addr + offset, size);
-		const auto& bits        = GetBits<source>();
-		for (auto page = start; page < end; page++) {
-			if (!bits.test(page)) {
-				return false;
-			}
-		}
-		return true;
 	}
 
 	template <DirtySource source, bool enable>
-	RegionBits ChangeState(uint64_t vaddr, uint64_t size) {
+	void ChangeState(uint64_t vaddr, uint64_t size) {
 		const auto [start, end] = GetPageRange(vaddr, size);
 		if constexpr (source == DirtySource::Cpu && enable) {
-			for (auto page = start; page < end; page++) {
+			if (RegionBits(m_gpu_dirty, start, end).Any()) {
-				if (m_gpu_dirty.test(page) || m_fault_pending.test(page)) {
+				EXIT("CPU dirty state conflicts with GPU dirty state\n");
-					EXIT("CPU dirty state conflicts with GPU dirty or pending fault state\n");
-				}
 			}
 		}
 		if constexpr (source == DirtySource::Gpu && enable) {
-			for (auto page = start; page < end; page++) {
+			if (RegionBits(m_cpu_dirty, start, end).Any()) {
-				if (m_cpu_dirty.test(page) || m_fault_pending.test(page)) {
+				EXIT("GPU dirty state conflicts with CPU dirty state\n");
-					EXIT("GPU dirty state conflicts with CPU dirty or pending fault state\n");
-				}
 			}
 		}
-		auto& bits    = GetBits<source>();
+		auto& bits = GetBits<source>();
-		auto  changed = bits;
+		if constexpr (enable) {
-		for (auto page = start; page < end; page++) {
+			bits.SetRange(start, end);
-			bits.set(page, enable);
+		} else {
+			bits.UnsetRange(start, end);
 		}
-		changed ^= bits;
 		if constexpr (source == DirtySource::Cpu) {
-			changed    = m_cpu_dirty ^ m_writable;
+			UpdateCpuProtection<!enable>();
-			m_writable = m_cpu_dirty;
+		} else {
+			UpdateGpuProtection<enable>();
 		}
-		return changed;
-	}
-
-	[[nodiscard]] CpuFaultAction BeginCpuFault(uint64_t vaddr, uint64_t size,
-	                                           PageFaultAccess access = PageFaultAccess::Write) {
-		if (access != PageFaultAccess::Read && access != PageFaultAccess::Write) {
-			EXIT("unsupported CPU fault access while beginning ownership transfer\n");
-		}
-		const auto [start, end] = GetPageRange(vaddr, size);
-		const bool tracked      = m_tracked.test(start);
-		for (auto page = start; page < end; page++) {
-			if (m_tracked.test(page) != tracked) {
-				EXIT("CPU fault spans mixed tracked and untracked pages\n");
-			}
-			if (m_fault_pending.test(page)) {
-				return CpuFaultAction::Untracked;
-			}
-			if (m_cpu_dirty.test(page) != m_writable.test(page) ||
-			    (m_gpu_dirty.test(page) && (m_cpu_dirty.test(page) || m_writable.test(page)))) {
-				EXIT("inconsistent CPU fault page state\n");
-			}
-		}
-		if (!tracked) {
-			return CpuFaultAction::Untracked;
-		}
-		bool gpu_dirty = m_gpu_dirty.test(start);
-		bool writable  = m_writable.test(start);
-		for (auto page = start + 1; page < end; page++) {
-			if (m_gpu_dirty.test(page) != gpu_dirty || m_writable.test(page) != writable) {
-				EXIT("CPU fault spans pages with incompatible dirty or writable state\n");
-			}
-		}
-		for (auto page = start; page < end; page++) {
-			if (!gpu_dirty && access == PageFaultAccess::Write) {
-				m_cpu_dirty.set(page);
-				m_writable.set(page);
-			}
-			m_fault_pending.set(page);
-		}
-		return gpu_dirty ? CpuFaultAction::Download : CpuFaultAction::Continue;
-	}
-
-	[[nodiscard]] bool CompleteCpuFault(uint64_t vaddr, uint64_t size, PageFaultAccess access,
-	                                    bool downloaded) {
-		const auto [start, end] = GetPageRange(vaddr, size);
-		for (auto page = start; page < end; page++) {
-			if (!m_fault_pending.test(page)) {
-				return false;
-			}
-		}
-		for (auto page = start; page < end; page++) {
-			const bool gpu_dirty = m_gpu_dirty.test(page);
-			if (gpu_dirty != downloaded) {
-				EXIT("CPU fault download result disagrees with GPU dirty state\n");
-			}
-			if (gpu_dirty) {
-				m_gpu_dirty.reset(page);
-				switch (access) {
-					case PageFaultAccess::Read: break;
-					case PageFaultAccess::Write:
-						m_cpu_dirty.set(page);
-						m_writable.set(page);
-						break;
-					default: EXIT("unsupported CPU fault access after GPU download\n");
-				}
-			}
-			m_fault_pending.reset(page);
-		}
-		return true;
-	}
-
-	[[nodiscard]] bool HasPendingFault(uint64_t vaddr, uint64_t size) const {
-		const auto [start, end] = GetPageRange(vaddr, size);
-		for (auto page = start; page < end; page++) {
-			if (m_fault_pending.test(page)) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	[[nodiscard]] bool CompleteVirtualGpuWrite(uint64_t vaddr, uint64_t size) {
-		const auto [start, end] = GetPageRange(vaddr, size);
-		for (auto page = start; page < end; page++) {
-			if (!m_fault_pending.test(page)) {
-				return false;
-			}
-			if (!m_gpu_dirty.test(page)) {
-				EXIT("virtual GPU write completion found a non-GPU-dirty page\n");
-			}
-		}
-		for (auto page = start; page < end; page++) {
-			m_gpu_dirty.reset(page);
-			m_cpu_dirty.set(page);
-			m_writable.set(page);
-			m_fault_pending.reset(page);
-		}
-		return true;
 	}
 
 	template <DirtySource source, bool clear, typename Func>
-	RegionBits ForEachModifiedRange(uint64_t vaddr, uint64_t size, Func&& func) {
+	void ForEachModifiedRange(uint64_t vaddr, uint64_t size, Func&& func) {
 		const auto [start, end] = GetPageRange(vaddr, size);
-		auto mask               = GetBits<source>();
+		RegionBits mask(GetBits<source>(), start, end);
-		if constexpr (source == DirtySource::Cpu) {
-			mask &= ~m_fault_pending;
-		}
-		for (auto page = 0u; page < start; page++) {
-			mask.reset(page);
-		}
-		for (auto page = end; page < TRACKER_REGION_PAGES; page++) {
-			mask.reset(page);
-		}
 		if constexpr (clear) {
-			auto& bits = GetBits<source>();
+			GetBits<source>().UnsetRange(start, end);
-			for (auto page = start; page < end; page++) {
-				if (mask.test(page)) {
-					bits.reset(page);
-				}
-			}
 		}
 		if constexpr (source == DirtySource::Cpu && clear) {
-			auto changed = m_cpu_dirty ^ m_writable;
+			UpdateCpuProtection<true>();
-			m_writable   = m_cpu_dirty;
-			ApplyProtection(changed, true);
 			ForEachRange(mask, std::forward<Func>(func));
-			return changed;
+			return;
+		}
+		if constexpr (source == DirtySource::Gpu && clear) {
+			UpdateGpuProtection<false>();
 		}
 		ForEachRange(mask, std::forward<Func>(func));
-		if constexpr (clear) {
-			return mask;
-		}
-		return {};
-	}
-
-	void ApplyProtection(const RegionBits& changed, bool track) {
-		ForEachRange(changed, [this, track](uint64_t vaddr, uint64_t size) {
-			m_page_manager.UpdatePageWatchers(track, vaddr, size);
-		});
-	}
-
-	void ApplyGpuProtection(const RegionBits& changed, bool track, PageWatchMode mode) {
-		if (mode != PageWatchMode::Write && mode != PageWatchMode::ReadWrite) {
-			EXIT("unsupported GPU page-watch mode\n");
-		}
-		ForEachRange(changed, [this, track, mode](uint64_t vaddr, uint64_t size) {
-			m_page_manager.UpdatePageWatchers(track, vaddr, size, mode);
-		});
 	}
 
 	TrackingSpinLock lock;
 
 private:
+	template <bool track>
+	void UpdateCpuProtection() {
+		auto mask  = m_cpu_dirty ^ m_writable;
+		m_writable = m_cpu_dirty;
+		if (mask.None()) {
+			return;
+		}
+		m_page_manager.UpdatePageWatchersForRegion<track>(m_cpu_addr, mask);
+	}
+
+	template <bool track>
+	void UpdateGpuProtection() {
+		auto readable = ~m_gpu_dirty;
+		auto mask     = readable ^ m_readable;
+		m_readable    = readable;
+		if (mask.None()) {
+			return;
+		}
+		if constexpr (track) {
+			m_page_manager.UpdatePageWatchersForRegion<true, true>(m_cpu_addr, mask);
+		} else {
+			m_page_manager.UpdatePageWatchersForRegion<false, true>(m_cpu_addr, mask);
+		}
+	}
+
 	template <DirtySource source>
 	RegionBits& GetBits() {
 		if constexpr (source == DirtySource::Cpu) {
@@ -320,18 +193,8 @@ private:
 
 	template <typename Func>
 	void ForEachRange(const RegionBits& bits, Func&& func) const {
-		size_t page = 0;
+		for (const auto [start, end]: bits) {
-		while (page < TRACKER_REGION_PAGES) {
+			func(m_cpu_addr + start * TRACKER_PAGE_SIZE, (end - start) * TRACKER_PAGE_SIZE);
-			while (page < TRACKER_REGION_PAGES && !bits.test(page)) {
-				page++;
-			}
-			const auto start = page;
-			while (page < TRACKER_REGION_PAGES && bits.test(page)) {
-				page++;
-			}
-			if (start != page) {
-				func(m_cpu_addr + start * TRACKER_PAGE_SIZE, (page - start) * TRACKER_PAGE_SIZE);
-			}
 		}
 	}
 
@@ -340,8 +203,7 @@ private:
 	RegionBits   m_cpu_dirty;
 	RegionBits   m_gpu_dirty;
 	RegionBits   m_writable;
-	RegionBits   m_fault_pending;
+	RegionBits   m_readable;
-	RegionBits   m_tracked;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/bufferCache.h

@@ -1,100 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BUFFERCACHE_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BUFFERCACHE_H_
-
-#include "common/abi.h"
-#include "common/common.h"
-#include "common/threads.h"
-#include "graphics/host_gpu/memoryTracker.h"
-#include "graphics/host_gpu/rangeSet.h"
-
-#include <map>
-#include <memory>
-#include <mutex>
-
-namespace Libs::Graphics {
-
-struct GraphicContext;
-struct VulkanBuffer;
-class CommandBuffer;
-class TextureCache;
-class ResourceMutex;
-
-struct BufferImageCopySource {
-	VulkanBuffer* buffer      = nullptr;
-	uint64_t      offset      = 0;
-	uint64_t      address     = 0;
-	uint64_t      size        = 0;
-	bool          cpu_current = false;
-	// True when the guest range was CPU-dirty before coherence resolution. ObtainBufferForImage
-	// may consume that tracker state while publishing the same bytes to a cached buffer.
-	bool cpu_dirty = false;
-};
-
-struct BufferCacheRange {
-	uint64_t address = 0;
-	uint64_t size    = 0;
-};
-
-struct BufferBinding {
-	VulkanBuffer& buffer;
-	uint64_t      offset;
-};
-
-[[nodiscard]] bool MergeOverlappingBufferCacheRange(BufferCacheRange& merged,
-                                                    BufferCacheRange  candidate) noexcept;
-
-class BufferCache {
-public:
-	static constexpr uint64_t CACHING_PAGE_SIZE = 16ull * 1024ull;
-	static constexpr uint64_t GetBufferOffset(uint64_t vaddr) {
-		return vaddr & (CACHING_PAGE_SIZE - 1);
-	}
-
-	BufferCache(GraphicContext& graphics, PageManager& page_manager, ResourceMutex& resource_mutex);
-	~BufferCache();
-	KYTY_CLASS_NO_COPY(BufferCache);
-
-	[[nodiscard]] bool InvalidateMemory(PageFaultAccess access, uint64_t vaddr, uint64_t size,
-	                                    PageFaultPhase phase) noexcept;
-	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,
-	                                         bool is_formatted = false);
-	// Emulator-owned, CPU-current scratch only. Guest ranges must use ObtainBuffer so page
-	// ownership is resolved before any CPU access.
-	[[nodiscard]] bool UploadHostData(CommandBuffer& command, const void* src, uint64_t size,
-	                                  uint64_t alignment, VulkanBuffer*& out_buffer,
-	                                  uint64_t& out_offset, uint64_t& out_range);
-	[[nodiscard]] VulkanBuffer&         ObtainNullBuffer(CommandBuffer& command);
-	[[nodiscard]] BufferImageCopySource ObtainBufferForImage(uint64_t vaddr, uint64_t size);
-	void FillBuffer(CommandBuffer* command, uint64_t vaddr, uint64_t size, uint32_t value);
-	void CopyBuffer(CommandBuffer* command, uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t size);
-	[[nodiscard]] bool HasPageOverlap(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] bool IsRegionCpuModified(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] bool IsRegionGpuModified(uint64_t vaddr, uint64_t size);
-	void               PublishImageBacking(uint64_t vaddr, uint64_t size);
-	void ValidateGpuAccess(uint64_t vaddr, uint64_t size, bool is_read, bool is_written) const;
-	void SetTextureCache(TextureCache& texture_cache);
-
-	void ResetNullBuffer();
-
-private:
-	struct CachedBuffer;
-	struct ReadbackWorker;
-
-	GraphicContext&               m_graphics;
-	Common::Mutex                 m_mutex;
-	std::shared_ptr<VulkanBuffer> m_null_buffer;
-	// TODO: add LRU cache
-	std::map<uint64_t, std::unique_ptr<CachedBuffer>> m_buffers;
-	std::unique_ptr<ReadbackWorker>                   m_readback;
-	RangeSet                                          m_gpu_modified_ranges;
-	MemoryTracker                                     m_memory_tracker;
-	PageManager&                                      m_page_manager;
-	TextureCache*                                     m_texture_cache = nullptr;
-	ResourceMutex&                                    m_resource_mutex;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BUFFERCACHE_H_

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

@@ -0,0 +1,923 @@
+#include "graphics/host_gpu/renderer/cache/bufferCache.h"
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "common/profiler.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 "kernel/memory.h"
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <utility>
+#include <vector>
+
+namespace Libs::Graphics {
+
+namespace {
+
+thread_local const void* g_cache_lock_owner = nullptr;
+
+constexpr uint64_t MiB           = 1024 * 1024;
+constexpr uint64_t GdsBufferSize = 64 * 1024;
+
+class FaultSafeCacheLock final {
+public:
+	FaultSafeCacheLock(const void* owner, Common::Mutex& mutex): m_mutex(mutex) {
+		if (g_cache_lock_owner != nullptr) {
+			EXIT("BufferCache: recursive cache lock acquisition\n");
+		}
+		g_cache_lock_owner = owner;
+		m_mutex.Lock();
+	}
+
+	~FaultSafeCacheLock() {
+		m_mutex.Unlock();
+		g_cache_lock_owner = nullptr;
+	}
+
+private:
+	Common::Mutex& m_mutex;
+};
+
+} // namespace
+
+uint64_t BufferCache::AlignDown(uint64_t value) noexcept {
+	return value & ~(CACHING_PAGE_SIZE - 1);
+}
+
+uint64_t BufferCache::AlignUp(uint64_t value) {
+	if (value > UINT64_MAX - (CACHING_PAGE_SIZE - 1)) {
+		EXIT("BufferCache: address alignment overflow\n");
+	}
+	return (value + CACHING_PAGE_SIZE - 1) & ~(CACHING_PAGE_SIZE - 1);
+}
+
+bool BufferCache::PageOverlaps(uint64_t left, uint64_t left_size, uint64_t right,
+                               uint64_t right_size) noexcept {
+	const auto left_begin  = left & ~(TRACKER_PAGE_SIZE - 1);
+	const auto left_end    = (left + left_size + TRACKER_PAGE_SIZE - 1) & ~(TRACKER_PAGE_SIZE - 1);
+	const auto right_begin = right & ~(TRACKER_PAGE_SIZE - 1);
+	const auto right_end = (right + right_size + TRACKER_PAGE_SIZE - 1) & ~(TRACKER_PAGE_SIZE - 1);
+	return left_begin < right_end && right_begin < left_end;
+}
+
+void BufferCache::Upload(CommandBuffer& command, Buffer& destination, uint64_t destination_offset,
+                         const void* source, uint64_t size) {
+	auto* bytes = static_cast<const uint8_t*>(source);
+	while (size != 0) {
+		const auto chunk        = std::min(size, m_staging_buffer.Size());
+		const auto stage_offset = m_staging_buffer.Copy(bytes, chunk, 4);
+		destination.CopyFrom(command, m_staging_buffer, stage_offset, destination_offset, chunk,
+		                     vk::AccessFlagBits::eHostWrite);
+		bytes += chunk;
+		destination_offset += chunk;
+		size -= chunk;
+	}
+}
+
+bool BufferCache::ResolveOverlap(CacheRange& merged, CacheRange candidate) noexcept {
+	if (merged.address == 0 || merged.size == 0 || candidate.address == 0 || candidate.size == 0 ||
+	    merged.size > UINT64_MAX - merged.address ||
+	    candidate.size > UINT64_MAX - candidate.address) {
+		EXIT("BufferCache: invalid overlap-merge range\n");
+	}
+	const auto merged_end    = merged.address + merged.size;
+	const auto candidate_end = candidate.address + candidate.size;
+	if (merged.address >= candidate_end || candidate.address >= merged_end) {
+		return false;
+	}
+	const auto address = std::min(merged.address, candidate.address);
+	const auto end     = std::max(merged_end, candidate_end);
+	merged             = {.address = address, .size = end - address};
+	return true;
+}
+
+struct BufferCache::CachedBuffer {
+	uint64_t                vaddr = 0;
+	uint64_t                size  = 0;
+	std::shared_ptr<Buffer> buffer;
+	uint64_t                tick_accessed_last = 0;
+};
+
+struct BufferCache::DownloadCopy {
+	std::shared_ptr<Buffer> owner;
+	uint64_t                source_offset = 0;
+	uint64_t                address       = 0;
+	uint64_t                size          = 0;
+};
+
+struct BufferCache::DownloadRange {
+	uint64_t address = 0;
+	uint64_t size    = 0;
+	uint64_t offset  = 0;
+};
+
+struct BufferCache::RetiredBuffer {
+	uint64_t                address = 0;
+	uint64_t                size    = 0;
+	std::shared_ptr<Buffer> owner;
+};
+
+std::pair<uint64_t, uint64_t> BufferCache::DownloadEnvelope(const DownloadCopy& copy) {
+	if (copy.owner == nullptr || copy.size == 0 || copy.source_offset > copy.owner->Size() ||
+	    copy.size > copy.owner->Size() - copy.source_offset) {
+		EXIT("BufferCache: invalid download copy\n");
+	}
+	const auto begin = copy.source_offset & ~uint64_t {3};
+	if (copy.source_offset > UINT64_MAX - copy.size ||
+	    copy.source_offset + copy.size > UINT64_MAX - 3) {
+		EXIT("BufferCache: download copy alignment overflow\n");
+	}
+	const auto end = (copy.source_offset + copy.size + 3) & ~uint64_t {3};
+	if (end > copy.owner->Size()) {
+		EXIT("BufferCache: aligned download copy exceeds its owner\n");
+	}
+	return {begin, end - begin};
+}
+
+std::vector<BufferCache::DownloadRange>
+BufferCache::RecordDownloads(std::span<const DownloadCopy> copies) {
+	uint64_t reservation_size = 0;
+	for (const auto& copy: copies) {
+		const auto [source_begin, envelope_size] = DownloadEnvelope(copy);
+		(void)source_begin;
+		if (envelope_size > UINT64_MAX - (DOWNLOAD_ALIGNMENT - 1)) {
+			EXIT("BufferCache: download batch alignment overflow\n");
+		}
+		const auto aligned_size = AlignDownload(envelope_size);
+		if (aligned_size > UINT64_MAX - reservation_size) {
+			EXIT("BufferCache: download batch overflow\n");
+		}
+		reservation_size += aligned_size;
+	}
+	if (reservation_size == 0) {
+		return {};
+	}
+
+	auto& download                   = m_download_buffer;
+	const auto [mapped, base_offset] = download.Map(reservation_size, DOWNLOAD_ALIGNMENT);
+	if (mapped == nullptr) {
+		EXIT("BufferCache: download batch could not reserve the shared stream\n");
+	}
+
+	std::vector<DownloadRange> downloads;
+	downloads.reserve(copies.size());
+	uint64_t cursor = 0;
+	for (const auto& copy: copies) {
+		const auto [source_begin, envelope_size] = DownloadEnvelope(copy);
+		const auto prefix                        = copy.source_offset - source_begin;
+		download.CopyFrom(m_scheduler.Current(), *copy.owner, source_begin, base_offset + cursor,
+		                  envelope_size, vk::AccessFlagBits::eMemoryWrite, vk::AccessFlags {},
+		                  vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite,
+		                  vk::AccessFlagBits::eHostRead);
+		downloads.push_back({copy.address, copy.size, base_offset + cursor + prefix});
+		cursor += AlignDownload(envelope_size);
+	}
+	download.Commit();
+	return downloads;
+}
+
+void BufferCache::PublishDownloads(std::span<const DownloadRange> downloads) {
+	for (const auto& range: downloads) {
+		m_download_buffer.Invalidate(range.offset, range.size);
+		Libs::LibKernel::Memory::WriteBacking(
+		    range.address, m_download_buffer.Mapped().data() + range.offset, range.size);
+	}
+}
+
+void BufferCache::QueueGarbageDownload(std::span<const DownloadCopy> copies, RetiredBuffer retire) {
+	if (copies.empty()) {
+		return;
+	}
+	auto downloads = RecordDownloads(copies);
+	m_scheduler.DeferOperation(
+	    [this, downloads = std::move(downloads), retire = std::move(retire)]() mutable {
+		    PublishDownloads(downloads);
+		    {
+			    FaultSafeCacheLock lock(this, m_mutex);
+			    for (const auto& range: downloads) {
+				    m_gpu_modified_ranges.Subtract(range.address, range.size);
+			    }
+			    // ForEachDownloadRange reports full tracker pages, and every exact GPU-owned
+			    // interval on those pages was downloaded and removed. Clearing the original
+			    // query therefore cannot orphan a dirty sibling on an edge page.
+			    m_memory_tracker.UnmarkRegionAsGpuModified(retire.address, retire.size);
+			    if (m_memory_tracker.IsRegionGpuModified(retire.address, retire.size) ||
+			        !m_gpu_modified_ranges.Intersections(retire.address, retire.size).empty()) {
+				    EXIT("BufferCache: asynchronous garbage collection retained GPU ownership\n");
+			    }
+			    m_memory_tracker.UntrackMemory(retire.address, retire.size);
+		    }
+	    });
+}
+
+BufferCache::BufferCache(GraphicContext& graphics, CommandScheduler& scheduler,
+                         PageManager& page_manager, TextureCache& texture_cache,
+                         ResourceMutex& resource_mutex)
+    : m_graphics(graphics), m_scheduler(scheduler),
+      m_gds_buffer(graphics, scheduler, MemoryUsage::Stream, 0, AllFlags, GdsBufferSize),
+      m_memory_tracker(page_manager),
+      m_staging_buffer(graphics, scheduler, MemoryUsage::Upload, 512 * MiB),
+      m_stream_buffer(graphics, scheduler, MemoryUsage::Stream, 64 * MiB),
+      m_download_buffer(graphics, scheduler, MemoryUsage::Download, 32 * MiB),
+      m_device_buffer(graphics, scheduler, MemoryUsage::DeviceLocal, 128 * MiB),
+      m_texture_cache(texture_cache), m_resource_mutex(resource_mutex) {
+	std::memset(m_gds_buffer.Mapped().data(), 0, static_cast<size_t>(m_gds_buffer.Size()));
+	m_gds_buffer.Flush(0, m_gds_buffer.Size());
+	if (!m_graphics.CanReportMemoryUsage()) {
+		return;
+	}
+	constexpr int64_t GiB              = 1024ll * 1024 * 1024;
+	constexpr int64_t target_threshold = 8 * GiB;
+	const auto        budget =
+	    static_cast<int64_t>(std::min<uint64_t>(m_graphics.GetTotalMemoryBudget(), INT64_MAX));
+	const auto threshold = std::min(budget, target_threshold);
+	const auto expected  = std::min(budget - 6 * threshold / 10, budget - GiB);
+	const auto critical  = std::min(budget - 2 * threshold / 10, budget - GiB / 2);
+	m_trigger_gc_memory  = static_cast<uint64_t>(std::max<int64_t>(expected, GiB));
+	m_critical_gc_memory = static_cast<uint64_t>(std::max<int64_t>(critical, 2 * GiB));
+}
+
+BufferCache::~BufferCache() {
+	if (!m_gpu_modified_ranges.Empty()) {
+		EXIT("BufferCache: destroyed with pending GPU-modified ranges\n");
+	}
+	for (const auto& [vaddr, cached]: m_buffers) {
+		(void)vaddr;
+		if (m_memory_tracker.IsRegionGpuModified(cached->vaddr, cached->size)) {
+			EXIT("BufferCache: destroyed with GPU-modified buffer\n");
+		}
+	}
+	m_buffers.clear();
+}
+
+StreamBuffer& BufferCache::GetUtilityBuffer(MemoryUsage usage) noexcept {
+	switch (usage) {
+		case MemoryUsage::Upload: return m_staging_buffer;
+		case MemoryUsage::Stream: return m_stream_buffer;
+		case MemoryUsage::Download: return m_download_buffer;
+		case MemoryUsage::DeviceLocal: return m_device_buffer;
+	}
+	EXIT("BufferCache: invalid utility-buffer usage\n");
+}
+
+BufferBinding BufferCache::UploadTransient(const void* data, uint64_t size, uint64_t alignment) {
+	EXIT_IF(data == nullptr || size == 0);
+	if (auto [mapped, offset] = m_stream_buffer.Map(size, alignment, false); mapped != nullptr) {
+		std::memcpy(mapped, data, static_cast<size_t>(size));
+		m_stream_buffer.Commit();
+		return {{}, m_stream_buffer.Handle(), offset};
+	}
+	auto owner =
+	    std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::Upload, 0, AllFlags, size);
+	owner->Write(0, data, size);
+	return {owner, owner->Handle(), 0};
+}
+
+void BufferCache::InvalidateMemory(uint64_t vaddr, uint64_t size) {
+	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
+	    size > TRACKER_ADDRESS_SIZE - vaddr) {
+		EXIT("BufferCache: invalid memory-invalidation range\n");
+	}
+	if (!HasPageOverlap(vaddr, size)) {
+		return;
+	}
+	m_memory_tracker.InvalidateRegion(vaddr, size,
+	                                  [this, vaddr, size] { ReadMemory(vaddr, size); });
+}
+
+void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size) {
+	std::vector<DownloadCopy> copies;
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		m_memory_tracker.ForEachDownloadRange<false>(
+		    vaddr, size,
+		    [&](uint64_t address, uint64_t bytes) noexcept {
+			    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, bytes,
+			                                           "memory invalidation");
+		    },
+		    [&](uint64_t address, uint64_t bytes) noexcept {
+			    for (const auto range: m_gpu_modified_ranges.Intersections(address, bytes)) {
+				    for (uint64_t copied = 0; copied < range.size;) {
+					    const auto copy_address = range.address + copied;
+					    auto       owner        = m_buffers.upper_bound(copy_address);
+					    if (owner == m_buffers.begin()) {
+						    EXIT("BufferCache: invalidation readback has no buffer owner\n");
+					    }
+					    auto& cached = *std::prev(owner)->second;
+					    if (!cached.buffer->IsInBounds(copy_address, 1)) {
+						    EXIT(
+						        "BufferCache: invalidation readback is outside its buffer owner\n");
+					    }
+					    const auto copy_size = std::min(range.size - copied,
+					                                    cached.vaddr + cached.size - copy_address);
+					    copies.push_back({cached.buffer, cached.buffer->Offset(copy_address),
+					                      copy_address, copy_size});
+					    copied += copy_size;
+				    }
+			    }
+		    });
+	}
+	if (copies.empty()) {
+		return;
+	}
+	auto downloads = RecordDownloads(copies);
+	m_scheduler.FinishCurrent();
+	PublishDownloads(downloads);
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		for (const auto& range: downloads) {
+			m_gpu_modified_ranges.Subtract(range.address, range.size);
+		}
+		// The enumeration above covered whole dirty pages and every exact interval on them.
+		m_memory_tracker.UnmarkRegionAsGpuModified(vaddr, size);
+	}
+}
+
+void BufferCache::UnmapMemory(uint64_t vaddr, uint64_t size) {
+	if (vaddr == 0 || size == 0 || size > UINT64_MAX - vaddr) {
+		EXIT("BufferCache: invalid unmap range\n");
+	}
+	std::vector<DownloadCopy>                  copies;
+	std::vector<std::pair<uint64_t, uint64_t>> modified_buffers;
+	std::vector<std::pair<uint64_t, uint64_t>> retired_buffers;
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		for (const auto& [begin, cached]: m_buffers) {
+			if (vaddr < begin + cached->size && begin < vaddr + size) {
+				retired_buffers.emplace_back(begin, cached->size);
+			}
+		}
+		for (const auto& [begin, cached]: m_buffers) {
+			if (vaddr >= begin + cached->size || begin >= vaddr + size ||
+			    !m_memory_tracker.IsRegionGpuModified(begin, cached->size)) {
+				continue;
+			}
+			const auto dirty = m_gpu_modified_ranges.Intersections(begin, cached->size);
+			if (dirty.empty()) {
+				EXIT("BufferCache: GPU-modified buffer has no dirty ranges\n");
+			}
+			modified_buffers.emplace_back(begin, cached->size);
+		}
+		for (const auto& [begin, bytes]: modified_buffers) {
+			auto owner = m_buffers.find(begin);
+			if (owner == m_buffers.end() || owner->second->size != bytes) {
+				EXIT("BufferCache: unmap owner changed during collection\n");
+			}
+			auto& cached = *owner->second;
+			m_memory_tracker.ForEachDownloadRange<false>(
+			    begin, cached.size,
+			    [&](uint64_t address, uint64_t bytes) noexcept {
+				    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, bytes,
+				                                           "unmap");
+			    },
+			    [&](uint64_t address, uint64_t bytes) noexcept {
+				    for (const auto& range: m_gpu_modified_ranges.Intersections(address, bytes)) {
+					    copies.push_back(
+					        {cached.buffer, range.address - begin, range.address, range.size});
+				    }
+			    });
+		}
+	}
+	if (!copies.empty()) {
+		auto downloads = RecordDownloads(copies);
+		m_scheduler.FinishCurrent();
+		PublishDownloads(downloads);
+	} else if (!retired_buffers.empty()) {
+		// Image uploads can reference a clean cached buffer without owning it. Submit the active
+		// command stream before removing such backing.
+		m_scheduler.FinishCurrent();
+	}
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		for (const auto& [begin, bytes]: modified_buffers) {
+			m_gpu_modified_ranges.Subtract(begin, bytes);
+			m_memory_tracker.UnmarkRegionAsGpuModified(begin, bytes);
+		}
+		for (const auto& [begin, bytes]: retired_buffers) {
+			m_memory_tracker.MarkRegionAsCpuModified(begin, bytes);
+		}
+		if (!m_gpu_modified_ranges.Intersections(vaddr, size).empty()) {
+			EXIT("BufferCache: unmap retained dirty byte ranges\n");
+		}
+		m_memory_tracker.UntrackMemory(vaddr, size);
+		for (auto it = m_buffers.begin(); it != m_buffers.end();) {
+			if (vaddr < it->first + it->second->size && it->first < vaddr + size) {
+				if (it->second->size > m_total_used_memory) {
+					EXIT("BufferCache: allocation accounting underflow\n");
+				}
+				m_total_used_memory -= it->second->size;
+				it = m_buffers.erase(it);
+			} else {
+				++it;
+			}
+		}
+	}
+}
+
+BufferCache::CachedBuffer& BufferCache::GetOrCreateBuffer(CommandBuffer& command, uint64_t vaddr,
+                                                          uint64_t size) {
+	const auto begin = AlignDown(vaddr);
+	const auto end   = AlignUp(vaddr + size);
+	auto       it    = m_buffers.upper_bound(vaddr);
+	if (it != m_buffers.begin()) {
+		auto previous = std::prev(it);
+		if (previous->second->buffer->IsInBounds(vaddr, size)) {
+			it = previous;
+		}
+	}
+	if (it != m_buffers.end() && it->second->buffer->IsInBounds(vaddr, size)) {
+		it->second->tick_accessed_last = m_gc_tick;
+		return *it->second;
+	}
+
+	CacheRange merged {.address = begin, .size = end - begin};
+	using Iterator = decltype(m_buffers.begin());
+	std::vector<Iterator> overlaps;
+	auto                  first = m_buffers.lower_bound(begin);
+	if (first != m_buffers.begin()) {
+		auto previous = std::prev(first);
+		if (ResolveOverlap(merged, {previous->second->vaddr, previous->second->size})) {
+			first = previous;
+		}
+	}
+	for (auto candidate = first; candidate != m_buffers.end(); ++candidate) {
+		if (candidate->first >= merged.address + merged.size) {
+			break;
+		}
+		if (ResolveOverlap(merged, {candidate->second->vaddr, candidate->second->size})) {
+			overlaps.push_back(candidate);
+		}
+	}
+	for (const auto overlap: overlaps) {
+		auto&                                      old = *overlap->second;
+		std::vector<std::pair<uint64_t, uint64_t>> uploads;
+		m_memory_tracker.ForEachUploadRange(
+		    old.vaddr, old.size, false,
+		    [&](uint64_t address, uint64_t bytes) noexcept {
+			    uploads.emplace_back(address, bytes);
+		    },
+		    [&]() noexcept {
+			    for (const auto& [address, bytes]: uploads) {
+				    Upload(command, *old.buffer, old.buffer->Offset(address),
+				           reinterpret_cast<const void*>(address), bytes);
+			    }
+		    });
+	}
+
+	auto cached                = std::make_unique<CachedBuffer>();
+	cached->vaddr              = merged.address;
+	cached->size               = merged.size;
+	cached->tick_accessed_last = m_gc_tick;
+	cached->buffer = std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::DeviceLocal,
+	                                          merged.address, AllFlags, merged.size);
+	for (const auto overlap: overlaps) {
+		const auto& old = *overlap->second;
+		cached->buffer->CopyFrom(command, *old.buffer, 0, old.vaddr - cached->vaddr, old.size);
+		command.RetainResourceUntilFence(old.buffer);
+	}
+	for (const auto overlap: overlaps) {
+		if (overlap->second->size > m_total_used_memory) {
+			EXIT("BufferCache: allocation accounting underflow\n");
+		}
+		m_total_used_memory -= overlap->second->size;
+		m_buffers.erase(overlap);
+	}
+	m_total_used_memory += cached->size;
+	return *m_buffers.emplace(cached->vaddr, std::move(cached)).first->second;
+}
+
+BufferBinding BufferCache::ObtainBuffer(CommandBuffer& command, uint64_t vaddr, uint64_t size,
+                                        bool is_written, bool is_read, bool is_formatted) {
+	if (command.IsInvalid() || command.IsExecute()) {
+		EXIT("BufferCache: buffer request requires a recording command buffer\n");
+	}
+	std::lock_guard transaction(m_resource_mutex);
+
+	if (is_read && !is_written && size <= CACHING_PAGE_SIZE &&
+	    !m_memory_tracker.IsRegionGpuModified(vaddr, size) &&
+	    m_memory_tracker.IsRegionCpuModified(vaddr, size)) {
+		const auto alignment = std::max<uint64_t>(
+		    m_graphics.physical_device_properties.limits.minUniformBufferOffsetAlignment, 1);
+		if (auto [mapped, offset] = m_stream_buffer.Map(size, alignment, false);
+		    mapped != nullptr) {
+			if (Libs::LibKernel::Memory::TryReadBacking(vaddr, mapped, size)) {
+				m_stream_buffer.Commit();
+				return {{}, m_stream_buffer.Handle(), offset};
+			}
+		} else {
+			auto owner = std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::Upload, 0,
+			                                      AllFlags, size);
+			if (Libs::LibKernel::Memory::TryReadBacking(vaddr, owner->Mapped().data(), size)) {
+				owner->Flush(0, size);
+				return {owner, owner->Handle(), 0};
+			}
+		}
+	}
+
+	if (is_formatted && is_written) {
+		(void)m_texture_cache.InvalidateMemoryFromGPU(vaddr, size, true);
+	}
+
+	FaultSafeCacheLock                         lock(this, m_mutex);
+	auto&                                      cached = GetOrCreateBuffer(command, vaddr, size);
+	std::vector<std::pair<uint64_t, uint64_t>> uploads;
+	m_memory_tracker.ForEachUploadRange(
+	    vaddr, size, is_written,
+	    [&](uint64_t address, uint64_t bytes) noexcept { uploads.emplace_back(address, bytes); },
+	    [&]() noexcept {
+		    for (const auto& [address, bytes]: uploads) {
+			    Upload(command, *cached.buffer, cached.buffer->Offset(address),
+			           reinterpret_cast<const void*>(address), bytes);
+		    }
+	    });
+	if (is_written) {
+		m_gpu_modified_ranges.Add(vaddr, size);
+	}
+	if (is_formatted && is_read && !is_written) {
+		(void)SynchronizeBufferFromImage(*cached.buffer, vaddr, size);
+	}
+	return {cached.buffer, cached.buffer->Handle(), cached.buffer->Offset(vaddr)};
+}
+
+std::shared_ptr<Buffer> BufferCache::ObtainNullBuffer() {
+	std::shared_ptr<Buffer> buffer;
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		if (m_null_buffer != nullptr) {
+			return m_null_buffer;
+		}
+		m_null_buffer = std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::DeviceLocal,
+		                                         0, AllFlags, 16);
+		buffer        = m_null_buffer;
+	}
+	const std::array<uint8_t, 16> zeros {};
+	Upload(m_scheduler.Current(), *buffer, 0, zeros.data(), zeros.size());
+	return buffer;
+}
+
+ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t size) {
+	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
+	    size > TRACKER_ADDRESS_SIZE - vaddr) {
+		EXIT("BufferCache: invalid image source\n");
+	}
+	auto find_owner = [&]() {
+		auto owner = m_buffers.upper_bound(vaddr);
+		if (owner == m_buffers.begin()) {
+			return m_buffers.end();
+		}
+		--owner;
+		return owner->second->buffer->IsInBounds(vaddr, size) ? owner : m_buffers.end();
+	};
+
+	{
+		FaultSafeCacheLock lock(this, m_mutex);
+		const bool         cpu_modified = m_memory_tracker.IsRegionCpuModified(vaddr, size);
+		const bool         gpu_modified = m_memory_tracker.IsRegionGpuModified(vaddr, size);
+		const auto         dirty        = m_gpu_modified_ranges.Intersections(vaddr, size);
+		const bool         has_dirty_buffer_source = !dirty.empty();
+		m_memory_tracker.ValidateGpuDirtyOwnership(m_gpu_modified_ranges, vaddr, size,
+		                                           "image source");
+
+		auto owner = find_owner();
+		if (has_dirty_buffer_source && owner == m_buffers.end()) {
+			CacheRange merged {.address = AlignDown(vaddr),
+			                   .size    = AlignUp(vaddr + size) - AlignDown(vaddr)};
+			using Iterator = decltype(m_buffers.begin());
+			std::vector<Iterator> overlaps;
+			auto                  first = m_buffers.lower_bound(merged.address);
+			if (first != m_buffers.begin()) {
+				auto previous = std::prev(first);
+				if (ResolveOverlap(merged, {previous->second->vaddr, previous->second->size})) {
+					first = previous;
+				}
+			}
+			for (auto candidate = first; candidate != m_buffers.end(); ++candidate) {
+				if (candidate->first >= merged.address + merged.size) {
+					break;
+				}
+				if (ResolveOverlap(merged, {candidate->second->vaddr, candidate->second->size})) {
+					overlaps.push_back(candidate);
+				}
+			}
+			if (overlaps.empty()) {
+				EXIT("BufferCache: GPU-dirty image source has no native buffer\n");
+			}
+
+			auto cached                = std::make_unique<CachedBuffer>();
+			cached->vaddr              = merged.address;
+			cached->size               = merged.size;
+			cached->tick_accessed_last = m_gc_tick;
+			cached->buffer =
+			    std::make_shared<Buffer>(m_graphics, m_scheduler, MemoryUsage::DeviceLocal,
+			                             merged.address, AllFlags, merged.size);
+			for (const auto overlap: overlaps) {
+				const auto& old = *overlap->second;
+				cached->buffer->CopyFrom(m_scheduler.Current(), *old.buffer, 0,
+				                         old.vaddr - cached->vaddr, old.size);
+				m_scheduler.Current().RetainResourceUntilFence(old.buffer);
+			}
+			for (const auto overlap: overlaps) {
+				if (overlap->second->size > m_total_used_memory) {
+					EXIT("BufferCache: allocation accounting underflow\n");
+				}
+				m_total_used_memory -= overlap->second->size;
+				m_buffers.erase(overlap);
+			}
+			m_total_used_memory += cached->size;
+			owner = m_buffers.emplace(cached->vaddr, std::move(cached)).first;
+			if (!owner->second->buffer->IsInBounds(vaddr, size)) {
+				EXIT("BufferCache: merged image source does not contain the requested range\n");
+			}
+		}
+		if (owner != m_buffers.end() && !cpu_modified &&
+		    (!gpu_modified || has_dirty_buffer_source)) {
+			owner->second->tick_accessed_last = m_gc_tick;
+			return {owner->second->buffer.get(), owner->second->buffer->Offset(vaddr)};
+		}
+		if (has_dirty_buffer_source && owner == m_buffers.end()) {
+			EXIT("BufferCache: GPU-dirty image source could not resolve its native owner\n");
+		}
+	}
+
+	auto [staging, stage_offset] = m_staging_buffer.Map(size, 16);
+	if (staging == nullptr || !Libs::LibKernel::Memory::TryReadBacking(vaddr, staging, size)) {
+		EXIT("BufferCache: failed to read mapped guest image backing\n");
+	}
+	m_staging_buffer.Commit();
+
+	FaultSafeCacheLock lock(this, m_mutex);
+	const auto         dirty                   = m_gpu_modified_ranges.Intersections(vaddr, size);
+	const bool         has_dirty_buffer_source = !dirty.empty();
+	auto               owner                   = find_owner();
+	if (has_dirty_buffer_source && owner == m_buffers.end()) {
+		EXIT("BufferCache: GPU-dirty image source lost its native owner\n");
+	}
+	if (owner == m_buffers.end() ||
+	    (m_memory_tracker.IsRegionGpuModified(vaddr, size) && !has_dirty_buffer_source)) {
+		return {&m_staging_buffer, stage_offset};
+	}
+
+	auto& cached              = *owner->second;
+	cached.tick_accessed_last = m_gc_tick;
+	std::vector<std::pair<uint64_t, uint64_t>> uploads;
+	m_memory_tracker.ForEachUploadRange(
+	    vaddr, size, false,
+	    [&](uint64_t address, uint64_t upload_size) noexcept {
+		    uploads.emplace_back(address, upload_size);
+	    },
+	    [&]() noexcept {
+		    for (const auto& [address, upload_size]: uploads) {
+			    cached.buffer->CopyFrom(
+			        m_scheduler.Current(), m_staging_buffer, stage_offset + address - vaddr,
+			        cached.buffer->Offset(address), upload_size, vk::AccessFlagBits::eHostWrite);
+		    }
+	    });
+	return {cached.buffer.get(), cached.buffer->Offset(vaddr)};
+}
+
+void BufferCache::WriteHostMemory(uint64_t vaddr, std::span<const uint8_t> data) {
+	if (vaddr == 0 || data.empty() || data.size() > UINT64_MAX - vaddr) {
+		EXIT("BufferCache: invalid host DMA write\n");
+	}
+	Libs::LibKernel::Memory::WriteBacking(vaddr, data.data(), data.size());
+
+	FaultSafeCacheLock lock(this, m_mutex);
+	const auto         end = vaddr + data.size();
+	for (auto& [address, cached]: m_buffers) {
+		const auto cached_end = address + cached->size;
+		const auto begin      = std::max(vaddr, address);
+		const auto range_end  = std::min(end, cached_end);
+		if (begin >= range_end) {
+			continue;
+		}
+		Upload(m_scheduler.Current(), *cached->buffer, cached->buffer->Offset(begin),
+		       data.data() + begin - vaddr, range_end - begin);
+		cached->tick_accessed_last = m_gc_tick;
+	}
+}
+
+void BufferCache::FillBuffer(uint64_t vaddr, uint64_t size, uint32_t value, bool is_gds) {
+	if ((vaddr & 3u) != 0 || size == 0 || (size & 3u) != 0 || size > UINT64_MAX - vaddr) {
+		EXIT("BufferCache: fill range must be dword aligned\n");
+	}
+	if (is_gds) {
+		if (vaddr > m_gds_buffer.Size() || size > m_gds_buffer.Size() - vaddr) {
+			EXIT("BufferCache: GDS fill range is out of bounds\n");
+		}
+		m_gds_buffer.Fill(vaddr, size, value);
+		return;
+	}
+	if (vaddr == 0) {
+		EXIT("BufferCache: invalid fill memory address\n");
+	}
+	(void)m_texture_cache.ClearMeta(vaddr);
+	{
+		std::lock_guard transaction(m_resource_mutex);
+		const auto      region = m_texture_cache.QueryRegion(vaddr, size);
+		if (!HasGpuDirtyBytes(vaddr, size) && !region.gpu_image_bytes) {
+			if (region.image_bytes) {
+				m_texture_cache.InvalidateMemory(vaddr, size);
+			}
+			std::array<uint32_t, 4096> values;
+			values.fill(value);
+			const std::span<const uint8_t> bytes {reinterpret_cast<const uint8_t*>(values.data()),
+			                                      sizeof(values)};
+			for (uint64_t offset = 0; offset < size;) {
+				const auto chunk = std::min<uint64_t>(size - offset, bytes.size());
+				WriteHostMemory(vaddr + offset, bytes.first(chunk));
+				offset += chunk;
+			}
+			return;
+		}
+	}
+
+	auto& command = m_scheduler.Current();
+	auto  dst     = ObtainBuffer(command, vaddr, size, true, false, true);
+	EXIT_IF(dst.buffer == nullptr || dst.owner == nullptr);
+	command.RetainResourceUntilFence(dst.owner);
+	auto owner = std::static_pointer_cast<Buffer>(dst.owner);
+	owner->Fill(dst.offset, size, value);
+}
+
+void BufferCache::CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t size, bool dst_gds,
+                             bool src_gds) {
+	const bool dst_memory = !dst_gds;
+	const bool src_memory = !src_gds;
+	if ((dst_memory && dst_vaddr == 0) || (src_memory && src_vaddr == 0) || size == 0 ||
+	    ((dst_vaddr | src_vaddr | size) & 3u) != 0 || size > UINT64_MAX - dst_vaddr ||
+	    size > UINT64_MAX - src_vaddr || (dst_gds && src_gds) ||
+	    (dst_gds == src_gds && src_vaddr < dst_vaddr + size && dst_vaddr < src_vaddr + size) ||
+	    (dst_gds && (dst_vaddr > m_gds_buffer.Size() || size > m_gds_buffer.Size() - dst_vaddr)) ||
+	    (src_gds && (src_vaddr > m_gds_buffer.Size() || size > m_gds_buffer.Size() - src_vaddr))) {
+		EXIT("BufferCache: invalid or overlapping copy range\n");
+	}
+	if (src_memory || dst_memory) {
+		std::lock_guard transaction(m_resource_mutex);
+		const auto      src_region =
+		    src_memory ? m_texture_cache.QueryRegion(src_vaddr, size) : TextureCache::RegionInfo {};
+		const auto dst_region =
+		    dst_memory ? m_texture_cache.QueryRegion(dst_vaddr, size) : TextureCache::RegionInfo {};
+		if (src_memory && dst_memory && !HasGpuDirtyBytes(src_vaddr, size) &&
+		    !HasGpuDirtyBytes(dst_vaddr, size) && !src_region.gpu_image_bytes &&
+		    !dst_region.gpu_image_bytes) {
+			if (dst_region.image_bytes) {
+				m_texture_cache.InvalidateMemory(dst_vaddr, size);
+			}
+			std::array<uint8_t, 64 * 1024> bytes;
+			for (uint64_t offset = 0; offset < size;) {
+				const auto chunk = std::min<uint64_t>(size - offset, bytes.size());
+				if (!Libs::LibKernel::Memory::TryReadBacking(src_vaddr + offset, bytes.data(),
+				                                             chunk)) {
+					EXIT("BufferCache: host DMA source has no direct backing\n");
+				}
+				WriteHostMemory(dst_vaddr + offset, std::span {bytes}.first(chunk));
+				offset += chunk;
+			}
+			return;
+		}
+	}
+
+	auto& command = m_scheduler.Current();
+	auto  src = src_memory ? ObtainBuffer(command, src_vaddr, size, false, true, true)
+	                       : BufferBinding {.buffer = m_gds_buffer.Handle(), .offset = src_vaddr};
+	auto  dst = dst_memory ? ObtainBuffer(command, dst_vaddr, size, true, false, true)
+	                       : BufferBinding {.buffer = m_gds_buffer.Handle(), .offset = dst_vaddr};
+	EXIT_IF(src.buffer == nullptr || dst.buffer == nullptr || (dst_memory && dst.owner == nullptr));
+	if (src.owner != nullptr) {
+		command.RetainResourceUntilFence(src.owner);
+	}
+	if (dst.owner != nullptr) {
+		command.RetainResourceUntilFence(dst.owner);
+	}
+	if (src.buffer == dst.buffer && src.offset < dst.offset + size &&
+	    dst.offset < src.offset + size) {
+		EXIT("BufferCache: resolved Vulkan copy ranges overlap\n");
+	}
+	auto& source = src.owner != nullptr ? *std::static_pointer_cast<Buffer>(src.owner)
+	               : src_gds            ? m_gds_buffer
+	                                    : m_stream_buffer;
+	auto& destination =
+	    dst.owner != nullptr ? *std::static_pointer_cast<Buffer>(dst.owner) : m_gds_buffer;
+	if (source.Handle() != src.buffer || destination.Handle() != dst.buffer) {
+		EXIT("BufferCache: resolved copy owner does not match its Vulkan handle\n");
+	}
+	destination.CopyFrom(command, source, src.offset, dst.offset, size);
+}
+
+bool BufferCache::HasPageOverlap(uint64_t vaddr, uint64_t size) {
+	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
+	    size > TRACKER_ADDRESS_SIZE - vaddr) {
+		EXIT("BufferCache: invalid page-overlap query\n");
+	}
+	FaultSafeCacheLock lock(this, m_mutex);
+	for (const auto& [address, cached]: m_buffers) {
+		if (PageOverlaps(vaddr, size, address, cached->size)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool BufferCache::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
+	return m_memory_tracker.IsRegionGpuModified(vaddr, size);
+}
+
+bool BufferCache::HasGpuDirtyBytes(uint64_t vaddr, uint64_t size) {
+	FaultSafeCacheLock lock(this, m_mutex);
+	return !m_gpu_modified_ranges.Intersections(vaddr, size).empty();
+}
+
+bool BufferCache::IsRegionCpuModified(uint64_t vaddr, uint64_t size) {
+	return m_memory_tracker.IsRegionCpuModified(vaddr, size);
+}
+
+void BufferCache::RunGarbageCollector() {
+	std::lock_guard transaction(m_resource_mutex);
+	const auto      tick = m_gc_tick++;
+	if (m_graphics.CanReportMemoryUsage()) {
+		m_total_used_memory = m_graphics.GetDeviceMemoryUsage();
+	}
+	if (m_total_used_memory < m_trigger_gc_memory) {
+		return;
+	}
+
+	const bool     aggressive = m_total_used_memory >= m_critical_gc_memory;
+	const uint64_t age        = std::min<uint64_t>(aggressive ? 80 : 160, tick);
+	const size_t   limit      = aggressive ? 64 : 32;
+
+	std::vector<RetiredBuffer>                                       retires;
+	std::vector<std::pair<RetiredBuffer, std::vector<DownloadCopy>>> dirty_retires;
+	{
+		FaultSafeCacheLock    lock(this, m_mutex);
+		std::vector<uint64_t> candidates;
+		for (const auto& [address, owner]: m_buffers) {
+			const auto& cached = *owner;
+			if (tick - std::min(tick, cached.tick_accessed_last) < age) {
+				continue;
+			}
+			candidates.push_back(address);
+		}
+		std::ranges::sort(candidates, [&](uint64_t left, uint64_t right) {
+			return m_buffers.at(left)->tick_accessed_last < m_buffers.at(right)->tick_accessed_last;
+		});
+		if (candidates.size() > limit) {
+			candidates.resize(limit);
+		}
+		for (const auto address: candidates) {
+			auto& cached = *m_buffers.at(address);
+			m_memory_tracker.ValidateGpuDirtyOwnership(m_gpu_modified_ranges, cached.vaddr,
+			                                           cached.size, "garbage collection");
+			retires.push_back({address, cached.size, cached.buffer});
+			// GC runs immediately before submission. Preserve every source referenced by commands
+			// already recorded in the active batch.
+			m_scheduler.Current().RetainResourceUntilFence(cached.buffer);
+		}
+		for (const auto& retire: retires) {
+			if (!m_memory_tracker.IsRegionGpuModified(retire.address, retire.size)) {
+				continue;
+			}
+			auto& copies = dirty_retires.emplace_back(retire, std::vector<DownloadCopy> {}).second;
+			m_memory_tracker.ForEachDownloadRange<false>(
+			    retire.address, retire.size,
+			    [&](uint64_t address, uint64_t size) noexcept {
+				    m_memory_tracker.ValidateGpuDirtyPages(m_gpu_modified_ranges, address, size,
+				                                           "garbage collection");
+			    },
+			    [&](uint64_t address, uint64_t size) noexcept {
+				    for (const auto range: m_gpu_modified_ranges.Intersections(address, size)) {
+					    copies.push_back({retire.owner, range.address - retire.address,
+					                      range.address, range.size});
+				    }
+			    });
+		}
+	}
+
+	for (auto& [retire, copies]: dirty_retires) {
+		QueueGarbageDownload(copies, std::move(retire));
+	}
+
+	FaultSafeCacheLock lock(this, m_mutex);
+	for (const auto& retire: retires) {
+		auto found = m_buffers.find(retire.address);
+		if (found == m_buffers.end() || found->second->size != retire.size ||
+		    found->second->buffer != retire.owner) {
+			EXIT("BufferCache: garbage-collection owner changed during download\n");
+		}
+		if (!m_memory_tracker.IsRegionGpuModified(retire.address, retire.size)) {
+			m_memory_tracker.UntrackMemory(retire.address, retire.size);
+		}
+		if (retire.size > m_total_used_memory) {
+			EXIT("BufferCache: allocation accounting underflow\n");
+		}
+		m_total_used_memory -= retire.size;
+		m_buffers.erase(found);
+	}
+}
+
+} // namespace Libs::Graphics

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

@@ -0,0 +1,123 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BUFFERCACHE_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BUFFERCACHE_H_
+
+#include "common/abi.h"
+#include "common/common.h"
+#include "common/threads.h"
+#include "graphics/host_gpu/memoryTracker.h"
+#include "graphics/host_gpu/rangeSet.h"
+#include "graphics/host_gpu/renderer/cache/streamBuffer.h"
+
+#include <map>
+#include <memory>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace Libs::Graphics {
+
+struct GraphicContext;
+class CommandBuffer;
+class CommandScheduler;
+class TextureCache;
+class ResourceMutex;
+
+struct BufferBinding {
+	std::shared_ptr<void> owner;
+	vk::Buffer            buffer = nullptr;
+	uint64_t              offset = 0;
+};
+
+struct ImageBufferSource {
+	Buffer*  buffer = nullptr;
+	uint64_t offset = 0;
+};
+
+class BufferCache {
+public:
+	static constexpr uint64_t CACHING_PAGE_SIZE = 16ull * 1024ull;
+	static constexpr uint64_t GetBufferOffset(uint64_t vaddr) {
+		return vaddr & (CACHING_PAGE_SIZE - 1);
+	}
+
+	BufferCache(GraphicContext& graphics, CommandScheduler& scheduler, PageManager& page_manager,
+	            TextureCache& texture_cache, ResourceMutex& resource_mutex);
+	~BufferCache();
+	KYTY_CLASS_NO_COPY(BufferCache);
+
+	void                        InvalidateMemory(uint64_t vaddr, uint64_t size);
+	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,
+	                                         bool is_formatted = false);
+	[[nodiscard]] StreamBuffer& GetUtilityBuffer(MemoryUsage usage) noexcept;
+	[[nodiscard]] Buffer&       GetGdsBuffer() noexcept { return m_gds_buffer; }
+	[[nodiscard]] const Buffer& GetGdsBuffer() const noexcept { return m_gds_buffer; }
+	[[nodiscard]] BufferBinding UploadTransient(const void* data, uint64_t size,
+	                                            uint64_t alignment);
+	[[nodiscard]] std::shared_ptr<Buffer> ObtainNullBuffer();
+	[[nodiscard]] ImageBufferSource       ObtainBufferForImage(uint64_t vaddr, uint64_t size);
+	void FillBuffer(uint64_t vaddr, uint64_t size, uint32_t value, bool is_gds = false);
+	void CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t size, bool dst_gds = false,
+	                bool src_gds = false);
+	[[nodiscard]] bool HasPageOverlap(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] bool HasGpuDirtyBytes(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] bool IsRegionCpuModified(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] bool IsRegionGpuModified(uint64_t vaddr, uint64_t size);
+	void               RunGarbageCollector();
+
+private:
+	friend struct BufferCacheTestAccess;
+
+	struct CacheRange {
+		uint64_t address = 0;
+		uint64_t size    = 0;
+	};
+	struct CachedBuffer;
+	struct DownloadCopy;
+	struct DownloadRange;
+	struct RetiredBuffer;
+	static constexpr uint64_t               DOWNLOAD_ALIGNMENT = 64;
+	[[nodiscard]] static uint64_t           AlignDown(uint64_t value) noexcept;
+	[[nodiscard]] static uint64_t           AlignUp(uint64_t value);
+	[[nodiscard]] static constexpr uint64_t AlignDownload(uint64_t size) noexcept {
+		return (size + DOWNLOAD_ALIGNMENT - 1) & ~(DOWNLOAD_ALIGNMENT - 1);
+	}
+	[[nodiscard]] static bool PageOverlaps(uint64_t left, uint64_t left_size, uint64_t right,
+	                                       uint64_t right_size) noexcept;
+	[[nodiscard]] static std::pair<uint64_t, uint64_t> DownloadEnvelope(const DownloadCopy& copy);
+	[[nodiscard]] static bool ResolveOverlap(CacheRange& merged, CacheRange candidate) noexcept;
+	void Upload(CommandBuffer& command, Buffer& destination, uint64_t destination_offset,
+	            const void* source, uint64_t size);
+	[[nodiscard]] CachedBuffer& GetOrCreateBuffer(CommandBuffer& command, uint64_t vaddr,
+	                                              uint64_t size);
+	[[nodiscard]] bool SynchronizeBufferFromImage(Buffer& buffer, uint64_t vaddr, uint64_t size);
+	[[nodiscard]] std::vector<DownloadRange> RecordDownloads(std::span<const DownloadCopy> copies);
+	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);
+
+	GraphicContext&                                   m_graphics;
+	CommandScheduler&                                 m_scheduler;
+	Buffer                                            m_gds_buffer;
+	Common::Mutex                                     m_mutex;
+	std::shared_ptr<Buffer>                           m_null_buffer;
+	std::map<uint64_t, std::unique_ptr<CachedBuffer>> m_buffers;
+	RangeSet                                          m_gpu_modified_ranges;
+	MemoryTracker                                     m_memory_tracker;
+	StreamBuffer                                      m_staging_buffer;
+	StreamBuffer                                      m_stream_buffer;
+	StreamBuffer                                      m_download_buffer;
+	StreamBuffer                                      m_device_buffer;
+	TextureCache&                                     m_texture_cache;
+	ResourceMutex&                                    m_resource_mutex;
+	uint64_t                                          m_total_used_memory = 0;
+	uint64_t m_trigger_gc_memory  = 1ull * 1024 * 1024 * 1024;
+	uint64_t m_critical_gc_memory = 2ull * 1024 * 1024 * 1024;
+	uint64_t m_gc_tick            = 0;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BUFFERCACHE_H_

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

@@ -0,0 +1,140 @@
+#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 {
+
+GpuResourceManager::GpuResourceManager(GraphicContext& graphics, CommandScheduler& scheduler)
+    : m_scheduler(scheduler),
+      m_buffer_cache(graphics, scheduler, m_page_manager, m_texture_cache, m_resource_mutex),
+      m_texture_cache(graphics, scheduler, m_page_manager, m_buffer_cache, m_resource_mutex) {}
+
+GpuResourceManager::~GpuResourceManager() = default;
+
+bool GpuResourceManager::HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept {
+	constexpr uint64_t fault_size = 8;
+	if (!IsMapped(fault_vaddr, fault_size)) {
+		return false;
+	}
+	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));
+	}
+	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;
+	}
+	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;
+}
+
+bool GpuResourceManager::IsMapped(uint64_t vaddr, uint64_t size) const noexcept {
+	if (vaddr == 0 || size == 0 || vaddr >= TRACKER_ADDRESS_SIZE ||
+	    size > TRACKER_ADDRESS_SIZE - vaddr) {
+		return false;
+	}
+	std::shared_lock lock(m_mapped_ranges_mutex);
+	return m_mapped_ranges.Contains(vaddr, size);
+}
+
+void GpuResourceManager::MapMemory(uint64_t vaddr, uint64_t size) {
+	{
+		std::lock_guard lock(m_mapped_ranges_mutex);
+		m_mapped_ranges.Add(vaddr, size);
+	}
+	m_page_manager.OnGpuMap(vaddr, size);
+}
+
+void GpuResourceManager::UnmapMemory(uint64_t vaddr, uint64_t size) {
+	if (CommandScheduler::InDeferredOperation()) {
+		EXIT("unsupported memory unmap from an asynchronous GPU completion, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported memory unmap from a pre-owned resource transaction, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	const auto unmap = [this, vaddr, size] {
+		if (m_scheduler.Active()) {
+			const auto tick = m_scheduler.CurrentTick();
+			m_scheduler.FinishCurrent();
+			m_scheduler.WaitPriorityOperations(tick);
+		}
+		m_buffer_cache.UnmapMemory(vaddr, size);
+		m_texture_cache.UnmapMemory(vaddr, size);
+		m_page_manager.OnGpuUnmap(vaddr, size);
+		std::lock_guard lock(m_mapped_ranges_mutex);
+		m_mapped_ranges.Subtract(vaddr, size);
+	};
+	if (m_gpu == nullptr) {
+		unmap();
+		return;
+	}
+	m_gpu->SendCommandSync(unmap);
+}
+
+void GpuResourceManager::RunGarbageCollector() {
+	m_texture_cache.ProcessDownloadImages();
+	m_texture_cache.RunGarbageCollector();
+	m_buffer_cache.RunGarbageCollector();
+}
+
+} // namespace Libs::Graphics

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

@@ -0,0 +1,49 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GPURESOURCEMANAGER_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GPURESOURCEMANAGER_H_
+
+#include "common/abi.h"
+#include "common/common.h"
+#include "graphics/host_gpu/pageManager.h"
+#include "graphics/host_gpu/renderer/cache/bufferCache.h"
+#include "graphics/host_gpu/renderer/cache/resourceMutex.h"
+#include "graphics/host_gpu/renderer/cache/textureCache.h"
+
+#include <cstdint>
+#include <shared_mutex>
+
+namespace Libs::Graphics {
+
+class CommandScheduler;
+class Gpu;
+
+class GpuResourceManager {
+public:
+	GpuResourceManager(GraphicContext& graphics, CommandScheduler& scheduler);
+	~GpuResourceManager();
+	KYTY_CLASS_NO_COPY(GpuResourceManager);
+
+	[[nodiscard]] BufferCache&  GetBufferCache() { return m_buffer_cache; }
+	[[nodiscard]] TextureCache& GetTextureCache() { return m_texture_cache; }
+	void                        SetGpu(Gpu* gpu) noexcept { m_gpu = gpu; }
+
+	[[nodiscard]] bool HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept;
+	[[nodiscard]] bool InvalidateMemory(uint64_t vaddr, uint64_t size);
+	[[nodiscard]] bool IsMapped(uint64_t vaddr, uint64_t size) const noexcept;
+	void               MapMemory(uint64_t vaddr, uint64_t size);
+	void               UnmapMemory(uint64_t vaddr, uint64_t size);
+	void               RunGarbageCollector();
+
+private:
+	PageManager               m_page_manager;
+	ResourceMutex             m_resource_mutex;
+	CommandScheduler&         m_scheduler;
+	BufferCache               m_buffer_cache;
+	TextureCache              m_texture_cache;
+	mutable std::shared_mutex m_mapped_ranges_mutex;
+	RangeSet                  m_mapped_ranges;
+	Gpu*                      m_gpu = nullptr;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GPURESOURCEMANAGER_H_

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

@@ -0,0 +1,272 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_
+
+#include "common/assert.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace Libs::Graphics {
+
+// Sparse two-level lookup for texture-cache page ownership.
+// Entries are selected by guest page number; queries never allocate L1 buckets.
+template <typename EntryT, size_t PageBits = 20, size_t AddressSpaceBits = 40,
+          size_t FirstLevelBits = 10>
+class MultiLevelPageTable final {
+public:
+	using Entry = EntryT;
+
+	static_assert(AddressSpaceBits < 64);
+	static_assert(PageBits < AddressSpaceBits);
+	static_assert(FirstLevelBits > 0 && FirstLevelBits <= AddressSpaceBits - PageBits);
+
+	static constexpr size_t   kPageBits          = PageBits;
+	static constexpr size_t   kAddressSpaceBits  = AddressSpaceBits;
+	static constexpr size_t   kFirstLevelBits    = FirstLevelBits;
+	static constexpr size_t   kSecondLevelBits   = AddressSpaceBits - FirstLevelBits - PageBits;
+	static constexpr size_t   kFirstLevelEntries = size_t {1} << FirstLevelBits;
+	static constexpr size_t   kBucketEntries     = size_t {1} << kSecondLevelBits;
+	static constexpr size_t   kPageCount         = size_t {1} << (AddressSpaceBits - PageBits);
+	static constexpr uint64_t kAddressSpaceSize  = uint64_t {1} << AddressSpaceBits;
+
+	struct PageRange final {
+		size_t first          = 0;
+		size_t last_exclusive = 0;
+	};
+
+	MultiLevelPageTable(): m_first_level(kFirstLevelEntries) {}
+
+	[[nodiscard]] Entry* Find(size_t page) {
+		if (!IsValidPage(page)) {
+			return nullptr;
+		}
+		auto& bucket = m_first_level[FirstLevelIndex(page)];
+		return bucket == nullptr ? nullptr : &(*bucket)[SecondLevelIndex(page)];
+	}
+
+	[[nodiscard]] const Entry* Find(size_t page) const {
+		if (!IsValidPage(page)) {
+			return nullptr;
+		}
+		const auto& bucket = m_first_level[FirstLevelIndex(page)];
+		return bucket == nullptr ? nullptr : &(*bucket)[SecondLevelIndex(page)];
+	}
+
+	[[nodiscard]] Entry& GetOrCreate(size_t page) {
+		if (!IsValidPage(page)) {
+			EXIT("MultiLevelPageTable page is outside the guest address space");
+		}
+		auto& bucket = m_first_level[FirstLevelIndex(page)];
+		if (bucket == nullptr) {
+			bucket = std::make_unique<Bucket>();
+			++m_allocated_buckets;
+		}
+		return (*bucket)[SecondLevelIndex(page)];
+	}
+
+	[[nodiscard]] Entry& operator[](size_t page) { return GetOrCreate(page); }
+
+	[[nodiscard]] static constexpr bool IsValidPage(size_t page) { return page < kPageCount; }
+
+	// Returns the half-open page interval touched by a non-empty byte range.
+	// An end exactly at 2^AddressSpaceBits is valid; wrapping or crossing it is not.
+	[[nodiscard]] static constexpr bool TryGetPageRange(uint64_t address, uint64_t size,
+	                                                    PageRange& range) {
+		if (size == 0 || address >= kAddressSpaceSize || size > kAddressSpaceSize - address) {
+			return false;
+		}
+		const uint64_t end   = address + size;
+		range.first          = static_cast<size_t>(address >> PageBits);
+		range.last_exclusive = static_cast<size_t>(((end - 1) >> PageBits) + 1);
+		return true;
+	}
+
+	[[nodiscard]] size_t AllocatedBucketCount() const { return m_allocated_buckets; }
+
+private:
+	using Bucket = std::array<Entry, kBucketEntries>;
+
+	[[nodiscard]] static constexpr size_t FirstLevelIndex(size_t page) {
+		return page >> kSecondLevelBits;
+	}
+	[[nodiscard]] static constexpr size_t SecondLevelIndex(size_t page) {
+		return page & (kBucketEntries - 1);
+	}
+
+	std::vector<std::unique_ptr<Bucket>> m_first_level;
+	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) {
+	const auto it = std::find(owners.begin(), owners.end(), owner);
+	if (it == owners.end()) {
+		return false;
+	}
+	owners.erase(it);
+	return true;
+}
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_

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

@@ -1,4 +1,4 @@
-#include "graphics/host_gpu/renderer/resourceMutex.h"
+#include "graphics/host_gpu/renderer/cache/resourceMutex.h"
 
 #include "common/assert.h"
 

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

@@ -1,4 +1,4 @@
-#include "graphics/host_gpu/renderer/samplerCache.h"
+#include "graphics/host_gpu/renderer/cache/samplerCache.h"
 
 #include "common/assert.h"
 #include "common/logging/log.h"
@@ -7,6 +7,13 @@
 
 namespace Libs::Graphics {
 
+SamplerCache::~SamplerCache() {
+	for (const auto& [key, sampler]: m_samplers) {
+		(void)key;
+		m_graphics.device.destroySampler(sampler, nullptr);
+	}
+}
+
 vk::Sampler SamplerCache::GetSampler(const ShaderSamplerResource& r) {
 	Common::LockGuard lock(m_mutex);
 
@@ -49,7 +56,10 @@ vk::Sampler SamplerCache::GetSampler(const ShaderSamplerResource& r) {
 			case Prospero::SamplerAnisoRatio::kFour: aniso_ratio = 4.0f; break;
 			case Prospero::SamplerAnisoRatio::kEight: aniso_ratio = 8.0f; break;
 			case Prospero::SamplerAnisoRatio::kSixteen: aniso_ratio = 16.0f; break;
-			default: EXIT("unknown ratio: %d\n", static_cast<int>(r.MaxAnisoRatio()));
+			default:
+				EXIT("unknown ratio: %d dwords=%08x,%08x,%08x,%08x\n",
+				     static_cast<int>(r.MaxAnisoRatio()), r.fields[0], r.fields[1], r.fields[2],
+				     r.fields[3]);
 		}
 	}
 

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

@@ -21,7 +21,7 @@ public:
 	explicit SamplerCache(GraphicContext& graphics): m_graphics(graphics) {
 		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
 	}
-	~SamplerCache() { KYTY_NOT_IMPLEMENTED; }
+	~SamplerCache();
 	KYTY_CLASS_NO_COPY(SamplerCache);
 
 	vk::Sampler GetSampler(const ShaderSamplerResource& r);

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

@@ -0,0 +1,358 @@
+#include "graphics/host_gpu/renderer/cache/streamBuffer.h"
+
+#include "common/assert.h"
+#include "common/profiler.h"
+#include "graphics/host_gpu/graphicContext.h"
+#include "graphics/host_gpu/renderer/commandScheduler.h"
+#include "graphics/host_gpu/vma.h"
+
+#include <cstring>
+#include <limits>
+#include <numeric>
+#include <vk_mem_alloc.h>
+
+namespace Libs::Graphics {
+
+namespace {
+
+constexpr size_t WATCHES_INITIAL_RESERVE = 0x4000;
+constexpr size_t WATCHES_RESERVE_CHUNK   = 0x1000;
+
+[[nodiscard]] VmaAllocationCreateFlags AllocationFlags(MemoryUsage usage) {
+	switch (usage) {
+		case MemoryUsage::Upload:
+		case MemoryUsage::Stream:
+			return VMA_ALLOCATION_CREATE_MAPPED_BIT |
+			       VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT;
+		case MemoryUsage::Download:
+			return VMA_ALLOCATION_CREATE_MAPPED_BIT | VMA_ALLOCATION_CREATE_HOST_ACCESS_RANDOM_BIT;
+		case MemoryUsage::DeviceLocal: return {};
+	}
+	return {};
+}
+
+[[nodiscard]] VmaMemoryUsage AllocationUsage(MemoryUsage usage) {
+	switch (usage) {
+		case MemoryUsage::DeviceLocal:
+		case MemoryUsage::Stream: return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
+		case MemoryUsage::Upload:
+		case MemoryUsage::Download: return VMA_MEMORY_USAGE_AUTO_PREFER_HOST;
+	}
+	return VMA_MEMORY_USAGE_AUTO_PREFER_DEVICE;
+}
+
+[[nodiscard]] bool AlignUp(uint64_t value, uint64_t alignment, uint64_t& result) {
+	if (alignment == 0) {
+		result = value;
+		return true;
+	}
+	const auto remainder = value % alignment;
+	if (remainder == 0) {
+		result = value;
+		return true;
+	}
+	const auto increment = alignment - remainder;
+	if (value > std::numeric_limits<uint64_t>::max() - increment) {
+		return false;
+	}
+	result = value + increment;
+	return true;
+}
+
+} // namespace
+
+Buffer::Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsage usage,
+               uint64_t cpu_address, vk::BufferUsageFlags flags, uint64_t size)
+    : m_graphics(&graphics), m_scheduler(&scheduler), m_usage(usage), m_cpu_address(cpu_address),
+      m_size(size), m_buffer(std::make_unique<VulkanBuffer>()) {
+	KYTY_PROFILER_FUNCTION();
+	EXIT_IF(graphics.allocator == nullptr || size == 0);
+
+	vk::BufferCreateInfo buffer_info {};
+	buffer_info.size        = size;
+	buffer_info.usage       = flags;
+	buffer_info.sharingMode = vk::SharingMode::eExclusive;
+
+	VmaAllocationCreateInfo allocation_info {};
+	allocation_info.flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | AllocationFlags(usage);
+	allocation_info.usage = AllocationUsage(usage);
+	allocation_info.preferredFlags = usage == MemoryUsage::DeviceLocal
+	                                     ? VkMemoryPropertyFlags {}
+	                                     : VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+
+	VmaAllocationInfo allocation_result {};
+	VkBuffer          native_buffer = VK_NULL_HANDLE;
+	const auto        result        = static_cast<vk::Result>(vmaCreateBuffer(
+	    graphics.allocator, static_cast<const VkBufferCreateInfo*>(buffer_info), &allocation_info,
+	    &native_buffer, &m_buffer->memory.allocation, &allocation_result));
+	if (result != vk::Result::eSuccess) {
+		graphics.LogMemoryBudget();
+	}
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
+
+	m_buffer->buffer                 = native_buffer;
+	m_buffer->usage                  = flags;
+	m_buffer->buffer_size            = size;
+	m_buffer->memory.allocation_info = allocation_result;
+	m_buffer->memory.memory          = allocation_result.deviceMemory;
+	m_buffer->memory.offset          = allocation_result.offset;
+	m_buffer->memory.type            = allocation_result.memoryType;
+	m_buffer->memory.unique_id       = VulkanNextMemoryUniqueId();
+	graphics.device.getBufferMemoryRequirements(m_buffer->buffer, &m_buffer->memory.requirements);
+
+	VkMemoryPropertyFlags properties = 0;
+	vmaGetAllocationMemoryProperties(graphics.allocator, m_buffer->memory.allocation, &properties);
+	m_buffer->memory.property = vk::MemoryPropertyFlags(properties);
+	m_is_coherent             = (properties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
+	if (allocation_result.pMappedData != nullptr) {
+		m_mapped = {static_cast<uint8_t*>(allocation_result.pMappedData),
+		            static_cast<size_t>(size)};
+	}
+	VulkanTrackAllocation(m_buffer->memory);
+}
+
+Buffer::~Buffer() {
+	if (m_buffer->buffer != nullptr) {
+		VulkanUntrackAllocation(m_buffer->memory);
+		vmaDestroyBuffer(m_graphics->allocator, m_buffer->buffer, m_buffer->memory.allocation);
+	}
+}
+
+vk::Buffer Buffer::Handle() const noexcept {
+	return m_buffer->buffer;
+}
+
+bool Buffer::IsInBounds(uint64_t address, uint64_t size) const noexcept {
+	return address >= m_cpu_address && size <= m_size && address - m_cpu_address <= m_size - size;
+}
+
+void Buffer::Write(uint64_t offset, const void* source, uint64_t size) {
+	EXIT_IF(source == nullptr || m_mapped.empty() || offset > m_size || size > m_size - offset);
+	std::memcpy(m_mapped.data() + offset, source, static_cast<size_t>(size));
+	Flush(offset, size);
+}
+
+void Buffer::Flush(uint64_t offset, uint64_t size) {
+	EXIT_IF(m_mapped.empty() || offset > m_size || size > m_size - offset);
+	if (!m_is_coherent && size != 0) {
+		const auto result =
+		    vmaFlushAllocation(m_graphics->allocator, m_buffer->memory.allocation, offset, size);
+		EXIT_NOT_IMPLEMENTED(static_cast<vk::Result>(result) != vk::Result::eSuccess);
+	}
+}
+
+vk::BufferMemoryBarrier Buffer::Barrier(uint64_t offset, uint64_t size, vk::AccessFlags source,
+                                        vk::AccessFlags destination) const {
+	if (Handle() == nullptr || size == 0 || offset > m_size || size > m_size - offset) {
+		EXIT("Buffer: invalid DMA barrier, handle=%p offset=0x%016" PRIx64 " size=0x%016" PRIx64
+		     " capacity=0x%016" PRIx64 "\n",
+		     static_cast<const void*>(Handle()), offset, size, m_size);
+	}
+	vk::BufferMemoryBarrier barrier {};
+	barrier.sType               = vk::StructureType::eBufferMemoryBarrier;
+	barrier.srcAccessMask       = source;
+	barrier.dstAccessMask       = destination;
+	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	barrier.buffer              = Handle();
+	barrier.offset              = offset;
+	barrier.size                = size;
+	return barrier;
+}
+
+void Buffer::CopyFrom(CommandBuffer& command, const Buffer& source, uint64_t source_offset,
+                      uint64_t destination_offset, uint64_t size, vk::AccessFlags source_before,
+                      vk::AccessFlags destination_before, vk::AccessFlags source_after,
+                      vk::AccessFlags destination_after) {
+	if (size == 0 || source_offset > source.m_size || size > source.m_size - source_offset ||
+	    destination_offset > m_size || size > m_size - destination_offset) {
+		EXIT("Buffer: invalid copy range\n");
+	}
+	if (source.Handle() == Handle() && source_offset < destination_offset + size &&
+	    destination_offset < source_offset + size) {
+		EXIT("Buffer: overlapping self-copy\n");
+	}
+	command.EndRendering();
+	const vk::BufferMemoryBarrier before[] = {
+	    source.Barrier(source_offset, size, source_before, vk::AccessFlagBits::eTransferRead),
+	    Barrier(destination_offset, size, destination_before, vk::AccessFlagBits::eTransferWrite),
+	};
+	const auto host_access  = vk::AccessFlagBits::eHostRead | vk::AccessFlagBits::eHostWrite;
+	auto       before_stage = vk::PipelineStageFlags {vk::PipelineStageFlagBits::eAllCommands};
+	if (static_cast<bool>((source_before | destination_before) & host_access)) {
+		before_stage |= vk::PipelineStageFlagBits::eHost;
+	}
+	const auto native = command.Handle();
+	native.pipelineBarrier(before_stage, vk::PipelineStageFlagBits::eTransfer,
+	                       vk::DependencyFlagBits::eByRegion, 0, nullptr, 2, before, 0, nullptr);
+	const vk::BufferCopy copy {source_offset, destination_offset, size};
+	native.copyBuffer(source.Handle(), Handle(), 1, &copy);
+	const vk::BufferMemoryBarrier after[] = {
+	    source.Barrier(source_offset, size, vk::AccessFlagBits::eTransferRead, source_after),
+	    Barrier(destination_offset, size, vk::AccessFlagBits::eTransferWrite, destination_after),
+	};
+	auto after_stage = vk::PipelineStageFlags {vk::PipelineStageFlagBits::eAllCommands};
+	if (static_cast<bool>((source_after | destination_after) & host_access)) {
+		after_stage |= vk::PipelineStageFlagBits::eHost;
+	}
+	native.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, after_stage,
+	                       vk::DependencyFlagBits::eByRegion, 0, nullptr, 2, after, 0, nullptr);
+}
+
+void Buffer::Fill(uint64_t offset, uint64_t size, uint32_t value) {
+	if (((offset | size) & 3u) != 0) {
+		EXIT("Buffer: fill range must be dword aligned\n");
+	}
+	auto& command = Scheduler().Current();
+	command.EndRendering();
+	const auto before =
+	    Barrier(offset, size, vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite,
+	            vk::AccessFlagBits::eTransferWrite);
+	const auto native = command.Handle();
+	native.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands,
+	                       vk::PipelineStageFlagBits::eTransfer, vk::DependencyFlagBits::eByRegion,
+	                       0, nullptr, 1, &before, 0, nullptr);
+	native.fillBuffer(Handle(), offset, size, value);
+	const auto after = Barrier(offset, size, vk::AccessFlagBits::eTransferWrite,
+	                           vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite);
+	native.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+	                       vk::PipelineStageFlagBits::eAllCommands,
+	                       vk::DependencyFlagBits::eByRegion, 0, nullptr, 1, &after, 0, nullptr);
+}
+
+StreamBuffer::StreamBuffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsage usage,
+                           uint64_t size)
+    : Buffer(graphics, scheduler, usage, 0, AllFlags, size) {
+	ReserveWatches(m_current_watches, WATCHES_INITIAL_RESERVE);
+	ReserveWatches(m_previous_watches, WATCHES_INITIAL_RESERVE);
+}
+
+bool StreamBuffer::NormalizeReservation(bool coherent, uint64_t atom, uint64_t& size,
+                                        uint64_t& alignment) {
+	if (coherent) {
+		return true;
+	}
+	if (!AlignUp(size, atom, size)) {
+		return false;
+	}
+	const auto divisor = std::gcd(alignment, atom);
+	if (alignment != 0 && alignment / divisor > UINT64_MAX / atom) {
+		return false;
+	}
+	alignment = alignment == 0 ? atom : alignment / divisor * atom;
+	return true;
+}
+
+std::pair<uint8_t*, uint64_t> StreamBuffer::Map(uint64_t size, uint64_t alignment,
+                                                bool allow_wait) {
+	if (Mapped().empty()) {
+		return {nullptr, 0};
+	}
+	uint64_t   mapped_size = size;
+	const auto atom        = Graphics().physical_device_properties.limits.nonCoherentAtomSize;
+	if (!NormalizeReservation(IsCoherent(), atom, mapped_size, alignment)) {
+		return {nullptr, 0};
+	}
+	if (mapped_size > Size()) {
+		return {nullptr, 0};
+	}
+
+	uint64_t aligned_offset = 0;
+	if (!AlignUp(m_offset, alignment, aligned_offset)) {
+		return {nullptr, 0};
+	}
+
+	const bool wrap = aligned_offset > Size() - mapped_size;
+	if (wrap) {
+		aligned_offset = 0;
+	}
+
+	auto wait_cursor = wrap ? size_t {0} : m_wait_cursor;
+	auto wait_bound  = wrap ? uint64_t {0} : m_wait_bound;
+	auto invalidation_mark =
+	    wrap ? std::optional<size_t> {m_current_watch_cursor} : m_invalidation_mark;
+	auto& pending_watches = wrap ? m_current_watches : m_previous_watches;
+	if (!WaitPendingOperations(pending_watches, invalidation_mark, aligned_offset + mapped_size,
+	                           allow_wait, wait_cursor, wait_bound)) {
+		return {nullptr, 0};
+	}
+
+	if (wrap) {
+		m_invalidation_mark    = invalidation_mark;
+		m_current_watch_cursor = 0;
+		std::swap(m_previous_watches, m_current_watches);
+	}
+	m_wait_cursor = wait_cursor;
+	m_wait_bound  = wait_bound;
+	m_offset      = aligned_offset;
+	m_mapped_size = mapped_size;
+	return {Mapped().data() + m_offset, m_offset};
+}
+
+void StreamBuffer::Commit() {
+	if (!IsCoherent() && Usage() != MemoryUsage::Download && m_mapped_size != 0) {
+		const auto result = vmaFlushAllocation(
+		    Graphics().allocator, NativeBuffer().memory.allocation, m_offset, m_mapped_size);
+		EXIT_NOT_IMPLEMENTED(static_cast<vk::Result>(result) != vk::Result::eSuccess);
+	}
+
+	m_offset += m_mapped_size;
+	const auto tick = Scheduler().CurrentTick();
+	if (m_current_watch_cursor != 0 && m_current_watches[m_current_watch_cursor - 1].tick == tick) {
+		m_current_watches[m_current_watch_cursor - 1].upper_bound = m_offset;
+		return;
+	}
+	if (m_current_watch_cursor + 1 >= m_current_watches.size()) {
+		ReserveWatches(m_current_watches, WATCHES_RESERVE_CHUNK);
+	}
+	auto& watch       = m_current_watches[m_current_watch_cursor++];
+	watch.upper_bound = m_offset;
+	watch.tick        = tick;
+}
+
+void StreamBuffer::Invalidate(uint64_t offset, uint64_t size) {
+	EXIT_IF(Usage() != MemoryUsage::Download || offset > Size() || size > Size() - offset);
+	if (IsCoherent() || size == 0) {
+		return;
+	}
+	const auto result = vmaInvalidateAllocation(Graphics().allocator,
+	                                            NativeBuffer().memory.allocation, offset, size);
+	EXIT_NOT_IMPLEMENTED(static_cast<vk::Result>(result) != vk::Result::eSuccess);
+}
+
+uint64_t StreamBuffer::Copy(const void* source, uint64_t size, uint64_t alignment) {
+	EXIT_IF(source == nullptr);
+	const auto [data, offset] = Map(size, alignment);
+	EXIT_IF(data == nullptr);
+	std::memcpy(data, source, static_cast<size_t>(size));
+	Commit();
+	return offset;
+}
+
+void StreamBuffer::ReserveWatches(std::vector<Watch>& watches, size_t grow_size) {
+	watches.resize(watches.size() + grow_size);
+}
+
+bool StreamBuffer::WaitPendingOperations(const std::vector<Watch>& watches,
+                                         std::optional<size_t>     invalidation_mark,
+                                         uint64_t requested_upper_bound, bool allow_wait,
+                                         size_t& wait_cursor, uint64_t& wait_bound) {
+	if (!invalidation_mark.has_value()) {
+		return true;
+	}
+	while (requested_upper_bound > wait_bound && wait_cursor < *invalidation_mark) {
+		const auto& watch = watches[wait_cursor];
+		if (!Scheduler().IsFree(watch.tick) && !allow_wait) {
+			return false;
+		}
+		Scheduler().Wait(watch.tick);
+		if (Usage() == MemoryUsage::Download) {
+			Scheduler().WaitPriorityOperations(watch.tick);
+		}
+		wait_bound = watch.upper_bound;
+		++wait_cursor;
+	}
+	return true;
+}
+
+} // namespace Libs::Graphics

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

@@ -0,0 +1,129 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_STREAMBUFFER_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_STREAMBUFFER_H_
+
+#include "common/abi.h"
+#include "common/common.h"
+#include "graphics/host_gpu/vulkanCommon.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace Libs::Graphics {
+
+class CommandBuffer;
+class CommandScheduler;
+struct StreamBufferTestAccess;
+struct GraphicContext;
+struct VulkanBuffer;
+
+enum class MemoryUsage : uint8_t {
+	DeviceLocal,
+	Upload,
+	Download,
+	Stream,
+};
+
+inline constexpr vk::BufferUsageFlags ReadFlags =
+    vk::BufferUsageFlagBits::eTransferSrc | vk::BufferUsageFlagBits::eUniformBuffer |
+    vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eVertexBuffer |
+    vk::BufferUsageFlagBits::eIndirectBuffer;
+
+inline constexpr vk::BufferUsageFlags AllFlags =
+    ReadFlags | vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eStorageBuffer;
+
+class Buffer {
+public:
+	Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsage usage,
+	       uint64_t cpu_address, vk::BufferUsageFlags flags, uint64_t size);
+	~Buffer();
+	KYTY_CLASS_NO_COPY(Buffer);
+
+	[[nodiscard]] vk::Buffer         Handle() const noexcept;
+	[[nodiscard]] uint64_t           Size() const noexcept { return m_size; }
+	[[nodiscard]] std::span<uint8_t> Mapped() const noexcept { return m_mapped; }
+	[[nodiscard]] bool               IsCoherent() const noexcept { return m_is_coherent; }
+	[[nodiscard]] MemoryUsage        Usage() const noexcept { return m_usage; }
+	[[nodiscard]] uint64_t           CpuAddress() const noexcept { return m_cpu_address; }
+	[[nodiscard]] uint64_t           Offset(uint64_t address) const noexcept {
+		return address - m_cpu_address;
+	}
+	[[nodiscard]] bool IsInBounds(uint64_t address, uint64_t size) const noexcept;
+	void               Write(uint64_t offset, const void* source, uint64_t size);
+	void               Flush(uint64_t offset, uint64_t size);
+	void CopyFrom(CommandBuffer& command, const Buffer& source, uint64_t source_offset,
+	              uint64_t destination_offset, uint64_t size,
+	              vk::AccessFlags source_before      = vk::AccessFlagBits::eMemoryWrite,
+	              vk::AccessFlags destination_before = vk::AccessFlagBits::eMemoryRead |
+	                                                   vk::AccessFlagBits::eMemoryWrite,
+	              vk::AccessFlags source_after       = vk::AccessFlagBits::eMemoryRead |
+	                                                   vk::AccessFlagBits::eMemoryWrite,
+	              vk::AccessFlags destination_after  = vk::AccessFlagBits::eMemoryRead |
+	                                                   vk::AccessFlagBits::eMemoryWrite);
+	void Fill(uint64_t offset, uint64_t size, uint32_t value);
+
+protected:
+	[[nodiscard]] GraphicContext&   Graphics() const noexcept { return *m_graphics; }
+	[[nodiscard]] CommandScheduler& Scheduler() const noexcept { return *m_scheduler; }
+	[[nodiscard]] VulkanBuffer&     NativeBuffer() noexcept { return *m_buffer; }
+
+private:
+	[[nodiscard]] vk::BufferMemoryBarrier Barrier(uint64_t offset, uint64_t size,
+	                                              vk::AccessFlags source,
+	                                              vk::AccessFlags destination) const;
+
+	GraphicContext*               m_graphics    = nullptr;
+	CommandScheduler*             m_scheduler   = nullptr;
+	MemoryUsage                   m_usage       = MemoryUsage::DeviceLocal;
+	uint64_t                      m_cpu_address = 0;
+	uint64_t                      m_size        = 0;
+	std::unique_ptr<VulkanBuffer> m_buffer;
+	std::span<uint8_t>            m_mapped;
+	bool                          m_is_coherent = false;
+};
+
+class StreamBuffer final: public Buffer {
+public:
+	StreamBuffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsage usage,
+	             uint64_t size);
+
+	[[nodiscard]] std::pair<uint8_t*, uint64_t> Map(uint64_t size, uint64_t alignment = 0,
+	                                                bool allow_wait = true);
+	void                                        Commit();
+	// Download mappings become visible to the CPU only after their GPU completion tick is free.
+	// Call this from the scheduler's deferred completion operation before reading Mapped().
+	void                   Invalidate(uint64_t offset, uint64_t size);
+	[[nodiscard]] uint64_t Copy(const void* source, uint64_t size, uint64_t alignment = 0);
+
+private:
+	friend struct StreamBufferTestAccess;
+
+	struct Watch {
+		uint64_t tick        = 0;
+		uint64_t upper_bound = 0;
+	};
+
+	void                      ReserveWatches(std::vector<Watch>& watches, size_t grow_size);
+	[[nodiscard]] static bool NormalizeReservation(bool coherent, uint64_t atom, uint64_t& size,
+	                                               uint64_t& alignment);
+	[[nodiscard]] bool        WaitPendingOperations(const std::vector<Watch>& watches,
+	                                                std::optional<size_t>     invalidation_mark,
+	                                                uint64_t requested_upper_bound, bool allow_wait,
+	                                                size_t& wait_cursor, uint64_t& wait_bound);
+
+	uint64_t              m_offset      = 0;
+	uint64_t              m_mapped_size = 0;
+	std::vector<Watch>    m_current_watches;
+	size_t                m_current_watch_cursor = 0;
+	std::optional<size_t> m_invalidation_mark;
+	std::vector<Watch>    m_previous_watches;
+	size_t                m_wait_cursor = 0;
+	uint64_t              m_wait_bound  = 0;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_STREAMBUFFER_H_

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

@@ -0,0 +1,194 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_TEXTURECACHE_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_TEXTURECACHE_H_
+
+#include "common/abi.h"
+#include "common/common.h"
+#include "common/lruCache.h"
+#include "graphics/host_gpu/pageManager.h"
+#include "graphics/host_gpu/regionManager.h"
+#include "graphics/host_gpu/renderer/cache/multiLevelPageTable.h"
+#include "graphics/host_gpu/renderer/image/blitHelper.h"
+#include "graphics/host_gpu/renderer/image/image.h"
+
+#include <compare>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace Libs::Graphics {
+
+struct GraphicContext;
+class Buffer;
+class BufferCache;
+class CommandBuffer;
+class CommandScheduler;
+class ResourceMutex;
+class RenderExecutor;
+class StreamBuffer;
+class TileManager;
+struct TextureCacheTestAccess;
+
+class TextureCache {
+public:
+	enum class BindingType : uint8_t { Texture, Storage, RenderTarget, DepthTarget, VideoOut };
+
+	struct ImageDesc {
+		ImageInfo     info;
+		ImageViewInfo view_info;
+		BindingType   type = BindingType::Texture;
+	};
+
+	struct RegionInfo {
+		bool image_pages     = false;
+		bool image_bytes     = false;
+		bool gpu_image_bytes = false;
+	};
+
+	TextureCache(GraphicContext& graphics, CommandScheduler& scheduler, PageManager& page_manager,
+	             BufferCache& buffer_cache, ResourceMutex& resource_mutex);
+	~TextureCache();
+	KYTY_CLASS_NO_COPY(TextureCache);
+
+	[[nodiscard]] ImageId       FindImage(ImageDesc& desc, bool exact_format = false);
+	[[nodiscard]] ImageId       FindImageFromRange(uint64_t address, uint64_t size,
+	                                               bool ensure_valid = true);
+	[[nodiscard]] vk::ImageView FindTexture(ImageId id, const ImageDesc& desc);
+	[[nodiscard]] vk::ImageView FindRenderTarget(ImageId id, const ImageDesc& desc);
+	[[nodiscard]] vk::ImageView FindDepthTarget(ImageId id, const ImageDesc& desc);
+	[[nodiscard]] Image&        GetImage(ImageId id);
+	[[nodiscard]] const Image&  GetImage(ImageId id) const;
+	void                        MarkGpuWritten(ImageId id);
+
+	[[nodiscard]] bool ClearImageFromBuffer(CommandBuffer& command, uint64_t address, uint64_t size,
+	                                        uint32_t packed_clear);
+	void               InvalidateMemory(uint64_t address, uint64_t size);
+	[[nodiscard]] bool InvalidateMemoryFromGPU(uint64_t address, uint64_t size,
+	                                           bool formatted_buffer_write = false);
+	[[nodiscard]] RegionInfo QueryRegion(uint64_t address, uint64_t size);
+
+	[[nodiscard]] bool IsMeta(uint64_t address);
+	[[nodiscard]] bool IsMetaCleared(uint64_t address, uint32_t slice);
+	[[nodiscard]] bool ClearMeta(uint64_t address);
+	[[nodiscard]] bool TouchMeta(uint64_t address, uint32_t slice, bool is_clear);
+
+	void UnmapMemory(uint64_t address, uint64_t size);
+	void ProcessDownloadImages();
+	void RunGarbageCollector();
+
+private:
+	enum class TransferDirection { Upload, Download };
+	struct ColorTransferPlan;
+	struct DownloadPlan;
+
+	struct Slot {
+		std::shared_ptr<Image> image;
+		uint32_t               generation = 1;
+	};
+
+	struct MetaDataInfo {
+		uint32_t clear_mask = 0;
+	};
+
+	struct OverlapResult {
+		ImageId image;
+		int32_t mip   = -1;
+		int32_t layer = -1;
+	};
+
+	using ImageIds       = InlinePageOwnerList<ImageId, 16>;
+	using ImagePageTable = MultiLevelPageTable<ImageIds, 20, 40, 10>;
+
+	[[nodiscard]] Image&                 ResolveImage(ImageId id);
+	[[nodiscard]] const Image&           ResolveImage(ImageId id) const;
+	[[nodiscard]] std::shared_ptr<Image> ResolveOwner(ImageId id) const;
+	[[nodiscard]] ImageId                InsertImage(const ImageInfo& info);
+	[[nodiscard]] ImageId                GetNullImage(const ImageDesc& desc);
+	void                                 RegisterImage(ImageId id);
+	void                                 UnregisterImage(ImageId id);
+	void                                 DeleteImage(ImageId id);
+	void DeleteImages(std::span<const ImageId> ids, std::optional<ImageId> native_source = {});
+	void RetainImage(CommandBuffer& command, ImageId id);
+	void TouchImage(Image& image);
+	void TrackImage(ImageId id);
+	void TrackImageHead(ImageId id);
+	void TrackImageTail(ImageId id);
+	void UntrackImage(ImageId id);
+	void UntrackImageHead(ImageId id);
+	void UntrackImageTail(ImageId id);
+	void TrackImageDownload(ImageId id);
+	void TrackImageDownloadLocked(ImageId id, Image& image);
+	[[nodiscard]] static bool SameBacking(const ImageInfo& cached, const ImageInfo& requested,
+	                                      bool exact_format);
+	[[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]] OverlapResult ResolveOverlap(const ImageInfo& requested, BindingType binding,
+	                                           ImageId cached, ImageId merged);
+	[[nodiscard]] ImageId       ResolveDepthOverlap(const ImageInfo& requested, BindingType binding,
+	                                                ImageId cached);
+	[[nodiscard]] ImageId       ExpandImage(const ImageInfo& info, ImageId source);
+	void                        RefreshImage(ImageId id, const ImageDesc& desc);
+	void                        InitializeImage(ImageId id, const ImageDesc& desc);
+	[[nodiscard]] ColorTransferPlan BuildColorTransfer(const Image& image, BindingType binding,
+	                                                   TransferDirection direction) const;
+	[[nodiscard]] DownloadPlan      BuildDownload(const Image& image) const;
+	void UploadImage(Image& image, const ImageDesc& desc, Buffer& source, uint64_t source_offset);
+	void DownloadImageData(Image& image, Buffer& destination, uint64_t destination_offset,
+	                       uint64_t destination_size, DownloadPlan plan);
+	void DownloadDepth(Image& image, Buffer& destination, uint64_t destination_offset);
+	void CommitGpuWrite(Image& image);
+	void PrepareImageCopy(Image& image);
+	void RefreshCopySource(ImageId id);
+	[[nodiscard]] bool CopyD16(Image& destination, Image& source);
+	void               CopyImage(ImageId destination, ImageId source);
+	void               AssociateStencil(ImageId depth, GuestRange stencil);
+	void               AssociateStencilLocked(ImageId depth, GuestRange stencil);
+	void CopyImageMip(ImageId destination, ImageId source, uint32_t mip, uint32_t layer);
+	void ValidateImageDesc(const ImageDesc& desc) const;
+
+	void InvalidateCpuAliases(uint64_t address, uint64_t size);
+	void ClearGpuModified(ImageId id);
+
+	void                                        DownloadImage(ImageId id);
+	[[nodiscard]] bool                          TryDownloadImage(ImageId id);
+	[[nodiscard]] std::pair<uint8_t*, uint64_t> MapDownload(uint64_t size, uint64_t alignment);
+	void QueueDownload(GuestRange range, StreamBuffer& download, uint8_t* mapped, uint64_t offset);
+
+	GraphicContext&                                   m_graphics;
+	CommandScheduler&                                 m_scheduler;
+	TrackingSpinLock                                  m_lock;
+	PageManager&                                      m_page_manager;
+	BlitHelper                                        m_blit_helper;
+	std::unique_ptr<TileManager>                      m_tiler;
+	BufferCache&                                      m_buffer_cache;
+	ResourceMutex&                                    m_resource_mutex;
+	std::vector<Slot>                                 m_slots;
+	std::vector<uint32_t>                             m_free_slots;
+	ImagePageTable                                    m_image_page_table;
+	std::map<vk::Format, ImageId>                     m_null_images;
+	Common::LeastRecentlyUsedCache<ImageId, uint64_t> m_lru_cache;
+	std::set<ImageId>                                 m_download_images;
+	std::map<uint64_t, MetaDataInfo>                  m_surface_metas;
+	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;
+
+	friend struct TextureCacheTestAccess;
+	friend class BufferCache;
+	friend class RenderExecutor;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_TEXTURECACHE_H_

src/graphics/host_gpu/renderer/colorRenderTarget.cpp

@@ -7,15 +7,12 @@
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/guest_gpu/tile.h"
 #include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/objects/textureCommon.h"
 #include "graphics/host_gpu/renderer/debug.h"
-#include "graphics/host_gpu/renderer/descriptorCache.h"
+#include "graphics/host_gpu/renderer/image/textureCommon.h"
-#include "graphics/host_gpu/renderer/framebufferCache.h"
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/transfer.h"
 #include "graphics/host_gpu/vulkanCommon.h"
-#include "graphics/presentation/displayBuffer.h"
 
 #include <algorithm>
 #include <atomic>
@@ -25,9 +22,11 @@ namespace Libs::Graphics {
 static std::atomic<uint32_t> g_render_color_log_count = 0;
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, RenderColorInfo& r,
+void RenderExecutor::ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer,
-                              uint32_t render_target_slice_offset, uint32_t render_target_slot,
+                                              RenderColorInfo& r,
-                              bool ignore_target_mask, bool reuse_existing_render_texture) {
+                                              uint32_t         render_target_slice_offset,
+                                              uint32_t render_target_slot, bool ignore_target_mask,
+                                              bool exact_format) {
 	KYTY_PROFILER_FUNCTION();
 	const auto& hw = buffer.GetRegisters();
 
@@ -57,14 +56,17 @@ void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 
 		// No color output
 		r.type               = RenderColorType::NoColorOutput;
+		r.desc               = {};
 		r.base_addr          = 0;
-		r.vulkan_buffer      = nullptr;
+		r.image_id           = {};
-		r.vulkan_view        = nullptr;
+		r.image_view         = nullptr;
 		r.format             = vk::Format::eUndefined;
 		r.extent             = {};
 		r.base_mip_level     = 0;
+		r.base_array_layer   = 0;
 		r.buffer_size        = 0;
 		r.samples            = 1;
+		r.export_mapping     = {};
 		r.color_clear_enable = false;
 		r.color_clear_value  = {};
 		return;
@@ -77,10 +79,8 @@ void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	const auto view = ResolveTargetViewInfo(
 	    rt.view.base_array_slice_index, rt.view.last_array_slice_index, render_target_slice_offset);
 	switch (view.type) {
-		case TargetViewType::Image2D: break;
+		case TargetViewType::Image2D:
-		case TargetViewType::Image2DArray:
+		case TargetViewType::Image2DArray: break;
-			EXIT("layered render-target views are unsupported: base=%u count=%u\n", view.base_layer,
-			     view.layer_count);
 		case TargetViewType::Unsupported:
 			EXIT("invalid render-target view: base=%u last=%u draw_offset=%u\n",
 			     rt.view.base_array_slice_index, rt.view.last_array_slice_index,
@@ -119,7 +119,18 @@ void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	uint32_t   pitch  = 0;
 	uint64_t   size   = 0;
 	bool       tile   = false;
-	const bool standard64 =
+	const bool volume = rt.attrib3.dimension == 2;
+	if (rt.attrib3.dimension != 1 && !volume) {
+		EXIT("unsupported render-target dimension: %u\n", rt.attrib3.dimension);
+	}
+	if (!volume && rt.attrib3.depth != 0) {
+		EXIT("2D render target has nonzero depth: %u\n", rt.attrib3.depth);
+	}
+	if (volume && samples != 1) {
+		EXIT("multisampled 3D render targets are unsupported\n");
+	}
+	const uint32_t depth = volume ? rt.attrib3.depth + 1u : 1u;
+	const bool     standard64 =
 	    rt.attrib3.tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kStandard64KB);
 
 	switch (rt.attrib3.tile_mode) {
@@ -145,6 +156,7 @@ void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	if (bytes_per_element == 0) {
 		EXIT("render-target format has no valid element size\n");
 	}
+	const auto transfer_format = ImageOps::RenderTargetTransferFormat(bytes_per_element);
 	if (standard64 &&
 	    (rt.attrib3.dimension != 1 || rt.attrib3.depth != 0 || levels != 1 ||
 	     rt.view.current_mip_level != 0 || view.base_layer != 0 || view.image_layers != 1 ||
@@ -165,10 +177,14 @@ void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	if (rt.pitch.pitch_div8_minus1 != 0) {
 		pitch = (rt.pitch.pitch_div8_minus1 + 1u) << 3u;
 	} else if (tile) {
-		pitch = standard64
+		if (volume) {
-		            ? TileGetTexturePitch(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float),
+			pitch = TileGetTexturePitch(transfer_format, width, levels, rt.attrib3.tile_mode);
-		                                  width, levels, rt.attrib3.tile_mode)
+		} else if (standard64) {
-		            : TileGetRenderTargetPitch(width, bytes_per_element, rt.attrib.num_fragments);
+			pitch = TileGetTexturePitch(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float),
+			                            width, levels, rt.attrib3.tile_mode);
+		} else {
+			pitch = TileGetRenderTargetPitch(width, bytes_per_element, rt.attrib.num_fragments);
+		}
 		if (pitch == 0) {
 			EXIT("unsupported render-target pitch: width=%u bytes=%u\n", width, bytes_per_element);
 		}
@@ -176,156 +192,148 @@ void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 		pitch = width;
 	}
 
-	if (tile) {
+	TileSizeOffset   mip_sizes[16] {};
+	TilePaddedSize   mip_padded[16] {};
+	TileVolumeLayout volume_layout {};
+	uint64_t         backing_size = 0;
+	if (volume) {
+		if (!tile || !TileGetTextureVolumeLayout(transfer_format, width, height, depth, levels,
+		                                         rt.attrib3.tile_mode, volume_layout)) {
+			EXIT("unsupported 3D render-target layout: %ux%ux%u levels=%u tile=%u\n", width, height,
+			     depth, levels, rt.attrib3.tile_mode);
+		}
+		size         = volume_layout.block_slice_size;
+		backing_size = volume_layout.total_size;
+	} else if (tile) {
 		TileSizeAlign layout {};
 		bool          valid_layout = false;
 		if (standard64) {
 			TileGetTextureSize(Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float), width,
-			                   height, pitch, levels, rt.attrib3.tile_mode, &layout, nullptr,
+			                   height, pitch, levels, rt.attrib3.tile_mode, &layout, mip_sizes,
-			                   nullptr);
+			                   mip_padded);
 			valid_layout = layout.size != 0 && layout.align == 65536;
 		} else {
 			valid_layout =
 			    levels == 1 ? TileGetRenderTargetSize(width, height, pitch, bytes_per_element,
 			                                          layout, rt.attrib.num_fragments)
 			                : TileGetRenderTargetMipLayout(width, height, pitch, bytes_per_element,
-			                                               levels, layout, nullptr, nullptr);
+			                                               levels, layout, mip_sizes, mip_padded);
 		}
 		if (!valid_layout) {
 			EXIT("unsupported render-target layout: %ux%u pitch=%u bytes=%u levels=%u\n", width,
 			     height, pitch, bytes_per_element, levels);
 		}
 		size = layout.size;
-		if (rt.slice.slice_div64_minus1 != 0 &&
+		EXIT_IF(size > UINT32_MAX);
-		    (static_cast<uint64_t>(rt.slice.slice_div64_minus1) + 1u) * 64u != size) {
+		if (levels == 1) {
-			EXIT("render-target slice span mismatch: encoded=0x%016" PRIx64 " derived=0x%016" PRIx64
+			mip_sizes[0]  = {static_cast<uint32_t>(size), 0, 0, 0, 0, 0};
-			     "\n",
+			mip_padded[0] = {pitch, height};
-			     (static_cast<uint64_t>(rt.slice.slice_div64_minus1) + 1u) * 64u, size);
 		}
 	} else {
 		size = static_cast<uint64_t>(pitch) * height * bytes_per_element * samples;
+		if (size > UINT32_MAX) {
+			EXIT("linear render-target slice exceeds the supported layout size\n");
+		}
+		mip_sizes[0]  = {static_cast<uint32_t>(size), 0, 0, 0, 0, 0};
+		mip_padded[0] = {pitch, height};
 	}
-	if (size == 0 || size > UINT64_MAX / view.image_layers) {
+	if (rt.slice.slice_div64_minus1 != 0 &&
+	    (static_cast<uint64_t>(rt.slice.slice_div64_minus1) + 1u) * 64u != size) {
+		EXIT("render-target slice span mismatch: encoded=0x%016" PRIx64 " derived=0x%016" PRIx64
+		     "\n",
+		     (static_cast<uint64_t>(rt.slice.slice_div64_minus1) + 1u) * 64u, size);
+	}
+	if (size == 0 || (!volume && size > UINT64_MAX / view.image_layers)) {
 		EXIT("render-target memory footprint is invalid\n");
 	}
-	const auto backing_size = size * view.image_layers;
+	if (!volume) {
+		backing_size = size * view.image_layers;
+	}
+	if (backing_size == 0) {
+		EXIT("render-target backing is empty\n");
+	}
 	if (backing_size > TRACKER_ADDRESS_SIZE - rt.base.addr) {
 		EXIT("render-target backing range is invalid\n");
 	}
 
-	auto video_image = Presentation::DisplayBufferFind(rt.base.addr, true);
-	if (video_image.image != nullptr &&
-	    !IsSupportedDisplayRenderTargetTileMode(rt.attrib3.tile_mode)) {
-		EXIT("unsupported display render-target tile mode: tile=%u expected=%u addr=0x%010" PRIx64
-		     " backing_size=0x%016" PRIx64 " video_size=0x%016" PRIx64 "\n",
-		     rt.attrib3.tile_mode, Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget),
-		     rt.base.addr, backing_size, video_image.size);
-	}
-	bool render_to_texture = view.base_layer != 0 || video_image.image == nullptr;
-	if (!render_to_texture && (levels != 1 || rt.view.current_mip_level != 0)) {
-		EXIT("mipmapped display render targets are unsupported\n");
-	}
 	const vk::Extent2D view_extent = {std::max(width >> rt.view.current_mip_level, 1u),
 	                                  std::max(height >> rt.view.current_mip_level, 1u)};
+	const uint32_t     view_depth  = std::max(depth >> rt.view.current_mip_level, 1u);
+	if (volume &&
+	    (view.base_layer >= view_depth || view.layer_count > view_depth - view.base_layer)) {
+		EXIT("3D render-target view exceeds mip depth: base=%u count=%u depth=%u mip=%u\n",
+		     view.base_layer, view.layer_count, view_depth, rt.view.current_mip_level);
+	}
 
 	auto decision_log_id = g_render_color_log_count.fetch_add(1);
-	if (decision_log_id < 128 || !render_to_texture) {
+	if (decision_log_id < 128) {
 		LOGF("RenderColorTarget: slot=%" PRIu32 " addr=0x%010" PRIx64 " size=0x%016" PRIx64
-		     " extent=%ux%u view_mip=%u view_extent=%ux%u levels=%u pitch=%u"
+		     " extent=%ux%ux%u view_mip=%u view_extent=%ux%u levels=%u pitch=%u"
-		     " fmt=0x%08" PRIx32 " nfmt=0x%08" PRIx32 " order=0x%08" PRIx32
+		     " fmt=0x%08" PRIx32 " nfmt=0x%08" PRIx32 " order=0x%08" PRIx32 " samples=%u tile=%s\n",
-		     " samples=%u tile=%s target=%s video_size=0x%016" PRIx64 " video_pitch=%" PRIu64 "\n",
+		     rt_slot, rt.base.addr, backing_size, width, height, depth, rt.view.current_mip_level,
-		     rt_slot, rt.base.addr, backing_size, width, height, rt.view.current_mip_level,
 		     view_extent.width, view_extent.height, levels, pitch, rt.info.format,
-		     rt.info.channel_type, rt.info.channel_order, samples, tile ? "tiled" : "linear",
+		     rt.info.channel_type, rt.info.channel_order, samples, tile ? "tiled" : "linear");
-		     render_to_texture ? "RenderTexture" : "DisplayBuffer", video_image.size,
-		     video_image.pitch);
 	}
 
-	if (render_to_texture) {
+	TextureCache::ImageDesc desc {};
-		(void)reuse_existing_render_texture;
+	desc.type              = TextureCache::BindingType::RenderTarget;
-		RenderTargetInfo target {};
+	desc.info.data         = {rt.base.addr, backing_size};
-		target.address           = rt.base.addr;
+	desc.info.pixel_format = target_format.format;
-		target.size              = backing_size;
+	desc.info.guest_format = transfer_format;
-		target.format            = target_format.format;
+	desc.info.type         = volume ? Prospero::ImageType::kColor3D : Prospero::ImageType::kColor2D;
-		target.width             = width;
+	desc.info.extent       = {width, height, depth};
-		target.height            = height;
+	desc.info.resources    = {levels, volume ? 1u : view.image_layers};
-		target.pitch             = pitch;
+	desc.info.pitch        = pitch;
-		target.bytes_per_element = target_format.bytes_per_element;
+	desc.info.bytes_per_block = bytes_per_element;
-		target.tile_mode         = rt.attrib3.tile_mode;
+	desc.info.samples         = samples;
-		target.levels            = levels;
+	desc.info.tile_mode       = rt.attrib3.tile_mode;
-		target.layers            = view.image_layers;
+	for (uint32_t level = 0; level < levels; level++) {
-		target.samples           = samples;
+		if (volume) {
-		auto& texture_cache      = GetRenderContext().GetTextureCache();
+			desc.info.mip_layout[level] = {
-		auto& buffer_vulkan      = texture_cache.FindRenderTarget(buffer, target);
+			    volume_layout.level_offsets[level],
-		r.type                   = RenderColorType::RenderTexture;
+			    volume_layout.level_sizes[level],
-		r.base_addr              = rt.base.addr;
+			    volume_layout.level_widths[level],
-		r.vulkan_buffer          = &buffer_vulkan;
+			    volume_layout.level_heights[level],
-		r.vulkan_view            = texture_cache.GetRenderTargetAttachmentView(
+			};
-		    buffer_vulkan, target.format, rt.view.current_mip_level, view.base_layer,
+			continue;
-		    view.layer_count);
-		r.format             = target.format;
-		r.extent             = view_extent;
-		r.base_mip_level     = rt.view.current_mip_level;
-		r.buffer_size        = backing_size;
-		r.samples            = samples;
-		r.export_mapping     = target_format.export_mapping;
-		r.color_clear_enable = buffer_vulkan.initial_clear_pending;
-		r.color_clear_value  = {};
-	} else {
-		if (samples != 1) {
-			EXIT("multisampled display render targets are unsupported\n");
-		}
-		const auto layout = static_cast<Prospero::ChannelLayout>(rt.info.format);
-		const auto type   = static_cast<Prospero::ChannelType>(rt.info.channel_type);
-		const auto order  = static_cast<Prospero::ChannelOrder>(rt.info.channel_order);
-
-		bool supported_display_format =
-		    (layout == Prospero::ChannelLayout::k8_8_8_8 &&
-		     (type == Prospero::ChannelType::kSrgb || type == Prospero::ChannelType::kUNorm) &&
-		     (order == Prospero::ChannelOrder::kStandard ||
-		      order == Prospero::ChannelOrder::kAlt)) ||
-		    (layout == Prospero::ChannelLayout::k10_10_10_2 &&
-		     type == Prospero::ChannelType::kUNorm &&
-		     (order == Prospero::ChannelOrder::kStandard ||
-		      order == Prospero::ChannelOrder::kAlt)) ||
-		    (layout == Prospero::ChannelLayout::k16_16_16_16 &&
-		     type == Prospero::ChannelType::kFloat &&
-		     (order == Prospero::ChannelOrder::kStandard || order == Prospero::ChannelOrder::kAlt));
-
-		EXIT_NOT_IMPLEMENTED(!supported_display_format);
-
-		// Display buffer
-		if (video_image.size != size) {
-			LOGF("RenderColorTarget: display buffer size differs from render target span, "
-			     "video_size=0x%016" PRIx64 " render_size=0x%016" PRIx64 "\n",
-			     video_image.size, size);
-		}
-		EXIT_NOT_IMPLEMENTED(video_image.size < size);
-		EXIT_NOT_IMPLEMENTED(video_image.pitch != pitch);
-		r.type           = RenderColorType::DisplayBuffer;
-		r.base_addr      = rt.base.addr;
-		r.vulkan_buffer  = video_image.image;
-		r.vulkan_view    = video_image.image->image_view[VulkanImage::VIEW_DEFAULT];
-		r.format         = video_image.image->format;
-		r.extent         = video_image.image->extent;
-		r.base_mip_level = 0;
-		r.buffer_size    = video_image.size;
-		r.samples        = 1;
-		r.export_mapping = target_format.export_mapping;
-	}
-}
-
-void MarkRenderTargetGpuWritten(const RenderColorInfo& target) {
-	const bool with_color = target.vulkan_buffer != nullptr;
-
-	if (with_color) {
-		if (target.type == RenderColorType::RenderTexture ||
-		    target.type == RenderColorType::DisplayBuffer) {
-			GetRenderContext().GetTextureCache().MarkGpuWritten(*target.vulkan_buffer);
-		} else {
-			EXIT("unknown writable render-color resource type\n");
 		}
+		const auto level_offset =
+		    mip_sizes[level].src_size != 0 ? mip_sizes[level].src_offset : mip_sizes[level].offset;
+		const auto level_size =
+		    static_cast<uint64_t>(mip_sizes[level].src_size != 0 ? mip_sizes[level].src_size
+		                                                         : mip_sizes[level].size) *
+		    view.image_layers;
+		desc.info.mip_layout[level] = {
+		    level_offset,
+		    level_size,
+		    mip_padded[level].width,
+		    mip_padded[level].height,
+		};
 	}
+	desc.view_info.format = target_format.format;
+	desc.view_info.type =
+	    view.layer_count == 1 ? vk::ImageViewType::e2D : vk::ImageViewType::e2DArray;
+	desc.view_info.aspect      = vk::ImageAspectFlagBits::eColor;
+	desc.view_info.base_level  = rt.view.current_mip_level;
+	desc.view_info.level_count = 1;
+	desc.view_info.base_layer  = view.base_layer;
+	desc.view_info.layer_count = view.layer_count;
+	desc.view_info.usage       = vk::ImageUsageFlagBits::eColorAttachment;
+	auto& texture_cache        = m_context.GetTextureCache();
+	r.desc                     = std::move(desc);
+	r.image_id                 = texture_cache.FindImage(r.desc, exact_format);
+	r.type                     = RenderColorType::RenderTexture;
+	r.base_addr                = rt.base.addr;
+	r.image_view               = nullptr;
+	r.format                   = r.desc.view_info.format;
+	r.extent                   = view_extent;
+	r.base_mip_level           = rt.view.current_mip_level;
+	r.buffer_size              = backing_size;
+	r.samples                  = samples;
+	r.export_mapping           = target_format.export_mapping;
+	r.color_clear_enable       = false;
+	r.color_clear_value        = {};
+	BindRenderTarget(r.image_id);
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/colorRenderTarget.h

@@ -2,6 +2,7 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_COLORRENDERTARGET_H_
 
 #include "graphics/guest_gpu/gpu_defs.h"
+#include "graphics/host_gpu/renderer/cache/textureCache.h"
 #include "graphics/host_gpu/renderer/renderTarget.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 
@@ -10,18 +11,17 @@
 namespace Libs::Graphics {
 
 class RenderCommandBuffer;
-struct VulkanImage;
 
 enum class RenderColorType {
 	NoColorOutput,
-	DisplayBuffer,
 	RenderTexture,
 };
 
 struct RenderColorInfo {
-	RenderColorType                 type             = RenderColorType::NoColorOutput;
+	RenderColorType                 type = RenderColorType::NoColorOutput;
-	VulkanImage*                    vulkan_buffer    = nullptr;
+	TextureCache::ImageDesc         desc;
-	vk::ImageView                   vulkan_view      = nullptr;
+	ImageId                         image_id;
+	vk::ImageView                   image_view       = nullptr;
 	vk::Format                      format           = vk::Format::eUndefined;
 	vk::Extent2D                    extent           = {};
 	uint32_t                        base_mip_level   = 0;
@@ -35,13 +35,6 @@ struct RenderColorInfo {
 	vk::ClearColorValue             color_clear_value {};
 };
 
-void ResolveRenderColorTarget(uint64_t submit_id, RenderCommandBuffer& buffer, RenderColorInfo& r,
-                              uint32_t render_target_slice_offset    = 0,
-                              uint32_t render_target_slot            = UINT32_MAX,
-                              bool     ignore_target_mask            = false,
-                              bool     reuse_existing_render_texture = false);
-void MarkRenderTargetGpuWritten(const RenderColorInfo& target);
-
 } // namespace Libs::Graphics
 
 #endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_COLORRENDERTARGET_H_

src/graphics/host_gpu/renderer/commandScheduler.cpp

@@ -0,0 +1,401 @@
+#include "graphics/host_gpu/renderer/commandScheduler.h"
+
+#include "common/assert.h"
+#include "graphics/host_gpu/graphicContext.h"
+
+#include <algorithm>
+
+namespace Libs::Graphics {
+
+static thread_local CommandScheduler* g_deferred_callback_scheduler = nullptr;
+
+void CommandSlot::Reset() {
+	EXIT_IF(buffer == nullptr);
+	const auto result = buffer.reset(vk::CommandBufferResetFlagBits::eReleaseResources);
+	if (result != vk::Result::eSuccess) {
+		EXIT("failed to reset Vulkan command buffer: %s (%d)\n", VulkanToString(result).c_str(),
+		     static_cast<int>(result));
+	}
+}
+
+CommandScheduler::CommandPool::~CommandPool() {
+	Destroy();
+}
+
+void CommandScheduler::CommandPool::Create(GraphicContext& graphics) {
+	EXIT_IF(m_pool != nullptr || m_graphics != nullptr ||
+	        graphics.queue_family == static_cast<uint32_t>(-1));
+	m_graphics = &graphics;
+
+	vk::CommandPoolCreateInfo create {};
+	create.sType            = vk::StructureType::eCommandPoolCreateInfo;
+	create.queueFamilyIndex = graphics.queue_family;
+	create.flags            = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
+	const auto result       = graphics.device.createCommandPool(&create, nullptr, &m_pool);
+	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess || m_pool == nullptr);
+}
+
+CommandSlot* CommandScheduler::CommandPool::CreateSlot() {
+	EXIT_IF(m_graphics == nullptr);
+	auto& graphics = *m_graphics;
+
+	vk::CommandBufferAllocateInfo allocate {};
+	allocate.sType              = vk::StructureType::eCommandBufferAllocateInfo;
+	allocate.commandPool        = m_pool;
+	allocate.level              = vk::CommandBufferLevel::ePrimary;
+	allocate.commandBufferCount = 1;
+	vk::CommandBuffer buffer    = nullptr;
+	EXIT_IF(graphics.device.allocateCommandBuffers(&allocate, &buffer) != vk::Result::eSuccess);
+
+	vk::FenceCreateInfo fence_create {};
+	fence_create.sType = vk::StructureType::eFenceCreateInfo;
+	fence_create.flags = vk::FenceCreateFlagBits::eSignaled;
+	vk::Fence fence    = nullptr;
+	if (graphics.device.createFence(&fence_create, nullptr, &fence) != vk::Result::eSuccess) {
+		graphics.device.freeCommandBuffers(m_pool, 1, &buffer);
+		EXIT("failed to create command-buffer fence\n");
+	}
+
+	auto& slot      = m_slots.emplace_back();
+	slot.pool_mutex = &m_mutex;
+	slot.id         = static_cast<uint32_t>(m_slots.size() - 1);
+	slot.buffer     = buffer;
+	slot.fence      = fence;
+	return &slot;
+}
+
+CommandSlot* CommandScheduler::CommandPool::Allocate(GraphicContext& graphics) {
+	Common::LockGuard lock(m_mutex);
+	if (m_pool == nullptr) {
+		Create(graphics);
+	}
+	EXIT_IF(m_graphics != &graphics);
+	auto  found = std::ranges::find_if(m_slots, [](const auto& slot) { return !slot.busy; });
+	auto* slot  = found != m_slots.end() ? &*found : CreateSlot();
+	slot->busy  = true;
+	slot->Reset();
+	return slot;
+}
+
+void CommandScheduler::CommandPool::Destroy() {
+	Common::LockGuard lock(m_mutex);
+	if (m_pool == nullptr) {
+		return;
+	}
+	EXIT_IF(std::ranges::any_of(m_slots, [](const auto& slot) { return slot.busy; }));
+	EXIT_IF(m_graphics == nullptr);
+	for (const auto& slot: m_slots) {
+		m_graphics->device.destroyFence(slot.fence, nullptr);
+	}
+	m_graphics->device.destroyCommandPool(m_pool, nullptr);
+	m_slots.clear();
+	m_pool     = nullptr;
+	m_graphics = nullptr;
+}
+
+bool CommandScheduler::InDeferredOperation() noexcept {
+	return g_deferred_callback_scheduler != nullptr;
+}
+
+CommandScheduler::CommandScheduler(RenderContext& context, GraphicContext& graphics)
+    : m_master(graphics), m_context(context), m_graphics(graphics),
+      m_priority_thread([this](std::stop_token stop) { PriorityOperationsThread(stop); }) {}
+
+CommandScheduler::~CommandScheduler() {
+	Shutdown();
+}
+
+void CommandScheduler::Shutdown() {
+	{
+		std::unique_lock lock(m_operation_mutex);
+		if (m_operation_state == OperationState::Closed) {
+			return;
+		}
+		if (g_deferred_callback_scheduler == this) {
+			EXIT_IF(m_operation_state == OperationState::Open);
+			// A priority callback cannot join its own runner, while a normal callback can be
+			// executing inside the shutdown owner's final PopPendingOperations. The owning
+			// thread will finish shutdown after this callback returns.
+			return;
+		}
+		if (m_operation_state == OperationState::Draining) {
+			m_operation_available.wait(
+			    lock, [this] { return m_operation_state == OperationState::Closed; });
+			return;
+		}
+		m_operation_state = OperationState::Draining;
+	}
+	if (Active() && m_recording) {
+		Finish();
+	}
+	DrainPriorityOperations();
+	m_priority_thread.request_stop();
+	m_operation_available.notify_all();
+	if (m_priority_thread.joinable()) {
+		m_priority_thread.join();
+	}
+	{
+		std::lock_guard lock(m_operation_mutex);
+		EXIT_IF(!m_pending_operations.empty() || !m_priority_operations.empty() ||
+		        m_priority_active);
+		m_operation_state = OperationState::Closed;
+	}
+	m_operation_available.notify_all();
+}
+
+void CommandScheduler::Begin(HW::Context& registers, HW::UserConfig& user_config,
+                             HW::Shader& shaders) {
+	{
+		std::lock_guard lock(m_operation_mutex);
+		EXIT_IF(m_operation_state != OperationState::Open);
+	}
+	m_registers   = &registers;
+	m_user_config = &user_config;
+	m_shaders     = &shaders;
+
+	if (!Active()) {
+		for (auto& buffer: m_buffers) {
+			buffer = std::make_unique<RenderCommandBuffer>(*this);
+		}
+		m_current = 0;
+	}
+
+	BindCurrent();
+	if (!m_recording) {
+		Current().Begin();
+		m_recording = true;
+	}
+}
+
+void CommandScheduler::BeginRendering(const RenderState& state) {
+	Current().BeginRendering(state);
+}
+
+void CommandScheduler::EndRendering() {
+	if (Active() && m_recording) {
+		Current().EndRendering();
+	}
+}
+
+void CommandScheduler::Flush() {
+	SubmitInfo submit;
+	Flush(submit);
+}
+
+void CommandScheduler::Flush(SubmitInfo& submit) {
+	SubmitCurrent(submit);
+	BeginNext();
+}
+
+CommandBuffer& CommandScheduler::FlushAndGetSubmitted() {
+	SubmitInfo submit;
+	auto&      submitted = SubmitCurrent(submit);
+	BeginNext();
+	return submitted;
+}
+
+void CommandScheduler::Finish() {
+	CheckActive();
+	const auto tick = CurrentTick();
+	if (m_recording) {
+		SubmitInfo submit;
+		SubmitCurrent(submit);
+	}
+	for (auto& buffer: m_buffers) {
+		buffer->WaitForFenceAndReset();
+	}
+	m_master.Wait(tick);
+	PopPendingOperations();
+	BindCurrent();
+	Current().Begin();
+	m_recording = true;
+}
+
+void CommandScheduler::FinishCurrent() {
+	SubmitInfo submit;
+	auto&      submitted = SubmitCurrent(submit);
+	submitted.WaitForFenceAndReset();
+	m_master.Refresh();
+	PopPendingOperations();
+	submitted.Begin();
+	m_recording = true;
+}
+
+void CommandScheduler::Wait(uint64_t tick) {
+	CheckActive();
+	EXIT_IF(tick > CurrentTick());
+	if (tick >= CurrentTick()) {
+		// A stream-buffer wrap can wait while a draw is being prepared through a reference to
+		// Current(). Recycle the same command object so that reference remains valid.
+		FinishCurrent();
+		return;
+	}
+	m_master.Wait(tick);
+	PopPendingOperations();
+}
+
+void CommandScheduler::PopPendingOperations() {
+	m_master.Refresh();
+	for (;;) {
+		Common::UniqueFunction<void> callback;
+		{
+			std::lock_guard lock(m_operation_mutex);
+			if (m_pending_operations.empty() ||
+			    !m_master.IsFree(m_pending_operations.front().tick)) {
+				return;
+			}
+			callback = std::move(m_pending_operations.front().callback);
+			m_pending_operations.pop();
+		}
+		RunOperation(std::move(callback));
+	}
+}
+
+void CommandScheduler::DeferOperation(Common::UniqueFunction<void>&& operation) {
+	CheckActive();
+	EXIT_IF(!operation);
+	std::unique_lock lock(m_operation_mutex);
+	if (m_operation_state == OperationState::Open) {
+		m_pending_operations.push({std::move(operation), CurrentTick()});
+		return;
+	}
+	if (g_deferred_callback_scheduler == this) {
+		lock.unlock();
+		operation();
+		return;
+	}
+	m_operation_available.wait(lock,
+	                           [this] { return m_operation_state == OperationState::Closed; });
+	lock.unlock();
+	operation();
+}
+
+void CommandScheduler::DeferPriorityOperation(Common::UniqueFunction<void>&& operation) {
+	CheckActive();
+	EXIT_IF(!operation);
+	std::unique_lock lock(m_operation_mutex);
+	if (m_operation_state == OperationState::Open) {
+		m_priority_operations.push({std::move(operation), CurrentTick()});
+		lock.unlock();
+		m_operation_available.notify_one();
+		return;
+	}
+	if (g_deferred_callback_scheduler == this) {
+		lock.unlock();
+		operation();
+		return;
+	}
+	m_operation_available.wait(lock,
+	                           [this] { return m_operation_state == OperationState::Closed; });
+	lock.unlock();
+	operation();
+}
+
+void CommandScheduler::PriorityOperationsThread(std::stop_token stop) {
+	while (!stop.stop_requested()) {
+		PendingOperation operation;
+		{
+			std::unique_lock lock(m_operation_mutex);
+			m_operation_available.wait(lock, [this, &stop] {
+				return stop.stop_requested() || !m_priority_operations.empty();
+			});
+			if (stop.stop_requested()) {
+				return;
+			}
+			operation = std::move(m_priority_operations.front());
+			m_priority_operations.pop();
+			m_priority_active      = true;
+			m_priority_active_tick = operation.tick;
+		}
+		m_master.Wait(operation.tick);
+		if (!stop.stop_requested()) {
+			RunOperation(std::move(operation.callback));
+		}
+		{
+			std::lock_guard lock(m_operation_mutex);
+			m_priority_active      = false;
+			m_priority_active_tick = 0;
+		}
+		m_operation_available.notify_all();
+	}
+}
+
+void CommandScheduler::DrainPriorityOperations() {
+	EXIT_IF(g_deferred_callback_scheduler == this);
+	std::unique_lock lock(m_operation_mutex);
+	m_operation_available.wait(
+	    lock, [this] { return m_priority_operations.empty() && !m_priority_active; });
+}
+
+void CommandScheduler::WaitPriorityOperations(uint64_t tick) {
+	EXIT_IF(g_deferred_callback_scheduler == this);
+	std::unique_lock lock(m_operation_mutex);
+	m_operation_available.wait(lock, [this, tick] {
+		const bool active_before_or_at = m_priority_active && m_priority_active_tick <= tick;
+		const bool queued_before_or_at =
+		    !m_priority_operations.empty() && m_priority_operations.front().tick <= tick;
+		return !active_before_or_at && !queued_before_or_at;
+	});
+}
+
+void CommandScheduler::RunOperation(Common::UniqueFunction<void>&& operation) {
+	auto* previous                = g_deferred_callback_scheduler;
+	g_deferred_callback_scheduler = this;
+	operation();
+	g_deferred_callback_scheduler = previous;
+}
+
+bool CommandScheduler::IsFree(uint64_t tick) {
+	if (m_master.IsFree(tick)) {
+		return true;
+	}
+	m_master.Refresh();
+	return m_master.IsFree(tick);
+}
+
+CommandSlot* CommandScheduler::AllocateCommandBuffer() {
+	return m_command_pool.Allocate(m_graphics);
+}
+
+uint64_t CommandScheduler::NextSubmitSequence() noexcept {
+	return m_submit_sequence.fetch_add(1, std::memory_order_relaxed) + 1;
+}
+
+void CommandScheduler::CheckActive() const {
+	EXIT_IF(!Active() || m_current >= BufferCount);
+}
+
+RenderCommandBuffer& CommandScheduler::Current() const {
+	CheckActive();
+	EXIT_IF(m_buffers[m_current] == nullptr);
+	return *m_buffers[m_current];
+}
+
+void CommandScheduler::BindCurrent() const {
+	EXIT_IF(m_registers == nullptr || m_user_config == nullptr || m_shaders == nullptr);
+	Current().Bind(*m_registers, *m_user_config, *m_shaders);
+}
+
+CommandBuffer& CommandScheduler::SubmitCurrent(SubmitInfo& submit) {
+	CheckActive();
+	EXIT_IF(!m_recording);
+	auto& submitted = Current();
+	submitted.End();
+	const auto signal_tick = m_master.NextTick();
+	submit.AddSignal(m_master.Handle(), signal_tick);
+	submitted.Execute(submit);
+	m_recording = false;
+	return submitted;
+}
+
+void CommandScheduler::BeginNext() {
+	EXIT_IF(m_recording);
+	m_current = (m_current + 1) % BufferCount;
+	Current().WaitForFenceAndReset();
+	PopPendingOperations();
+	BindCurrent();
+	Current().Begin();
+	m_recording = true;
+}
+
+} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/commandScheduler.h

@@ -0,0 +1,127 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_COMMANDSCHEDULER_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_COMMANDSCHEDULER_H_
+
+#include "common/common.h"
+#include "common/uniqueFunction.h"
+#include "graphics/host_gpu/renderer/masterSemaphore.h"
+#include "graphics/host_gpu/renderer/render.h"
+
+#include <array>
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <memory>
+#include <mutex>
+
+#include <queue>
+
+#include <thread>
+
+namespace Libs::Graphics {
+
+struct CommandSlot {
+	Common::Mutex*    pool_mutex = nullptr;
+	uint32_t          id         = 0;
+	vk::CommandBuffer buffer     = nullptr;
+	vk::Fence         fence      = nullptr;
+	bool              busy       = false;
+
+	void Reset();
+};
+
+class CommandScheduler {
+public:
+	static constexpr int BufferCount = 8;
+
+	CommandScheduler(RenderContext& context, GraphicContext& graphics);
+	~CommandScheduler();
+	KYTY_CLASS_NO_COPY(CommandScheduler);
+
+	void           Begin(HW::Context& registers, HW::UserConfig& user_config, HW::Shader& shaders);
+	void           BeginRendering(const RenderState& state);
+	void           EndRendering();
+	void           Flush();
+	void           Flush(SubmitInfo& submit);
+	CommandBuffer& FlushAndGetSubmitted();
+	void           Finish();
+	void           FinishCurrent();
+	// Deferred callbacks can observe an externally owned drain, but cannot initiate shutdown:
+	// the priority runner cannot join itself.
+	void                      Shutdown();
+	void                      Wait(uint64_t tick);
+	void                      PopPendingOperations();
+	void                      DrainPriorityOperations();
+	void                      WaitPriorityOperations(uint64_t tick);
+	void                      DeferOperation(Common::UniqueFunction<void>&& operation);
+	void                      DeferPriorityOperation(Common::UniqueFunction<void>&& operation);
+	[[nodiscard]] static bool InDeferredOperation() noexcept;
+
+	[[nodiscard]] bool            Active() const noexcept { return m_current >= 0; }
+	void                          CheckActive() const;
+	RenderCommandBuffer&          Current() const;
+	[[nodiscard]] uint64_t        CurrentTick() const noexcept { return m_master.CurrentTick(); }
+	[[nodiscard]] bool            IsFree(uint64_t tick);
+	[[nodiscard]] RenderContext&  Context() const noexcept { return m_context; }
+	[[nodiscard]] GraphicContext& Graphics() const noexcept { return m_graphics; }
+
+private:
+	class CommandPool {
+	public:
+		CommandPool() = default;
+		~CommandPool();
+		KYTY_CLASS_NO_COPY(CommandPool);
+
+		CommandSlot* Allocate(GraphicContext& graphics);
+
+	private:
+		void         Create(GraphicContext& graphics);
+		CommandSlot* CreateSlot();
+		void         Destroy();
+
+		GraphicContext*         m_graphics = nullptr;
+		Common::Mutex           m_mutex;
+		vk::CommandPool         m_pool = nullptr;
+		std::deque<CommandSlot> m_slots;
+	};
+
+	enum class OperationState { Open, Draining, Closed };
+
+	struct PendingOperation {
+		Common::UniqueFunction<void> callback;
+		uint64_t                     tick = 0;
+	};
+
+	void                       BindCurrent() const;
+	CommandBuffer&             SubmitCurrent(SubmitInfo& submit);
+	void                       BeginNext();
+	void                       PriorityOperationsThread(std::stop_token stop);
+	void                       RunOperation(Common::UniqueFunction<void>&& operation);
+	[[nodiscard]] CommandSlot* AllocateCommandBuffer();
+	[[nodiscard]] uint64_t     NextSubmitSequence() noexcept;
+
+	MasterSemaphore                                               m_master;
+	RenderContext&                                                m_context;
+	GraphicContext&                                               m_graphics;
+	CommandPool                                                   m_command_pool;
+	std::array<std::unique_ptr<RenderCommandBuffer>, BufferCount> m_buffers;
+	std::queue<PendingOperation>                                  m_pending_operations;
+	std::queue<PendingOperation>                                  m_priority_operations;
+	std::mutex                                                    m_operation_mutex;
+	std::condition_variable                                       m_operation_available;
+	std::jthread                                                  m_priority_thread;
+	bool                                                          m_priority_active      = false;
+	uint64_t                                                      m_priority_active_tick = 0;
+	OperationState        m_operation_state = OperationState::Open;
+	int                   m_current         = -1;
+	bool                  m_recording       = false;
+	HW::Context*          m_registers       = nullptr;
+	HW::UserConfig*       m_user_config     = nullptr;
+	HW::Shader*           m_shaders         = nullptr;
+	std::atomic<uint64_t> m_submit_sequence = 0;
+
+	friend class CommandBuffer;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_COMMANDSCHEDULER_H_

src/graphics/host_gpu/renderer/context.cpp

@@ -8,64 +8,18 @@
 #include "graphics/host_gpu/renderer/colorRenderTarget.h"
 #include "graphics/host_gpu/renderer/debug.h"
 #include "graphics/host_gpu/renderer/depthRenderTarget.h"
-#include "graphics/host_gpu/renderer/descriptorCache.h"
+#include "graphics/host_gpu/renderer/image/imageView.h"
-#include "graphics/host_gpu/renderer/framebufferCache.h"
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
-#include "graphics/host_gpu/renderer/imageView.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/transfer.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 
 #include <algorithm>
-#include <atomic>
+#include <bit>
 #include <cstring>
-#include <deque>
 #include <memory>
 namespace Libs::Graphics {
-static std::atomic<uint64_t> g_command_buffer_submit_seq = 0;
-
-static void ResetNativeCommandBuffer(vk::CommandBuffer buffer) {
-	EXIT_IF(buffer == nullptr);
-	const auto result = buffer.reset(vk::CommandBufferResetFlagBits::eReleaseResources);
-	if (result != vk::Result::eSuccess) {
-		EXIT("failed to reset Vulkan command buffer: %s (%d)\n", VulkanToString(result).c_str(),
-		     static_cast<int>(result));
-	}
-}
-
-struct CommandSlot {
-	Common::Mutex*    pool_mutex = nullptr;
-	uint32_t          id         = 0;
-	vk::CommandBuffer buffer     = nullptr;
-	vk::Fence         fence      = nullptr;
-	bool              busy       = false;
-};
-
-class ThreadCommandPool {
-public:
-	ThreadCommandPool() = default;
-
-	KYTY_CLASS_NO_COPY(ThreadCommandPool);
-
-	CommandSlot* Allocate();
-	void         Destroy();
-
-private:
-	void         Create();
-	CommandSlot* CreateSlot();
-
-	Common::Mutex           m_mutex;
-	vk::CommandPool         m_pool = nullptr;
-	std::deque<CommandSlot> m_slots;
-};
-
-static RenderContext*                 g_render_ctx = nullptr;
-static thread_local ThreadCommandPool g_command_pool;
-
-RenderContext& GetRenderContext() noexcept {
-	return *g_render_ctx;
-}
 
 FenceResourceRetainer::~FenceResourceRetainer() {
 	if (!m_resources.empty()) {
@@ -88,87 +42,12 @@ void FenceResourceRetainer::ReleaseAfterFence() noexcept {
 	m_resources.clear();
 }
 
-void GraphicsRenderInit(GraphicContext& graphics) {
+CommandBuffer::CommandBuffer(CommandScheduler& scheduler)
-	g_render_ctx = new RenderContext(graphics);
+    : m_context(scheduler.Context()), m_scheduler(scheduler), m_graphics(scheduler.Graphics()),
-}
+      m_slot(scheduler.AllocateCommandBuffer()) {}
 
-void GraphicsRenderReleaseThreadCommandPool() {
+CommandBuffer::~CommandBuffer() {
-	g_command_pool.Destroy();
+	Release();
-}
-
-CommandBuffer::CommandBuffer()
-    : m_graphics(GetRenderContext().GetGraphics()), m_slot(g_command_pool.Allocate()),
-      m_host_stream(m_graphics) {}
-
-void ThreadCommandPool::Create() {
-	auto& graphics = GetRenderContext().GetGraphics();
-	EXIT_IF(m_pool != nullptr || graphics.queue_family == static_cast<uint32_t>(-1));
-
-	vk::CommandPoolCreateInfo pool_info {};
-	pool_info.sType            = vk::StructureType::eCommandPoolCreateInfo;
-	pool_info.pNext            = nullptr;
-	pool_info.queueFamilyIndex = graphics.queue_family;
-	pool_info.flags            = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
-
-	const auto result = graphics.device.createCommandPool(&pool_info, nullptr, &m_pool);
-	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess || m_pool == nullptr);
-}
-
-CommandSlot* ThreadCommandPool::CreateSlot() {
-	auto&                         graphics = GetRenderContext().GetGraphics();
-	vk::CommandBufferAllocateInfo alloc_info {};
-	alloc_info.sType              = vk::StructureType::eCommandBufferAllocateInfo;
-	alloc_info.commandPool        = m_pool;
-	alloc_info.level              = vk::CommandBufferLevel::ePrimary;
-	alloc_info.commandBufferCount = 1;
-
-	vk::CommandBuffer buffer = nullptr;
-	if (graphics.device.allocateCommandBuffers(&alloc_info, &buffer) != vk::Result::eSuccess) {
-		EXIT("Can't allocate command buffers");
-	}
-
-	vk::FenceCreateInfo fence_info {};
-	fence_info.sType = vk::StructureType::eFenceCreateInfo;
-	fence_info.flags = vk::FenceCreateFlagBits::eSignaled;
-
-	vk::Fence fence = nullptr;
-	if (graphics.device.createFence(&fence_info, nullptr, &fence) != vk::Result::eSuccess) {
-		graphics.device.freeCommandBuffers(m_pool, 1, &buffer);
-		EXIT("Can't create fence");
-	}
-	auto& slot      = m_slots.emplace_back();
-	slot.pool_mutex = &m_mutex;
-	slot.id         = static_cast<uint32_t>(m_slots.size() - 1);
-	slot.buffer     = buffer;
-	slot.fence      = fence;
-	return &slot;
-}
-
-CommandSlot* ThreadCommandPool::Allocate() {
-	Common::LockGuard lock(m_mutex);
-	if (m_pool == nullptr) {
-		Create();
-	}
-	auto  it   = std::ranges::find_if(m_slots, [](const auto& slot) { return !slot.busy; });
-	auto* slot = it != m_slots.end() ? &*it : CreateSlot();
-	slot->busy = true;
-	ResetNativeCommandBuffer(slot->buffer);
-	return slot;
-}
-
-void ThreadCommandPool::Destroy() {
-	Common::LockGuard lock(m_mutex);
-	if (m_pool == nullptr) {
-		return;
-	}
-	EXIT_IF(std::ranges::any_of(m_slots, [](const auto& slot) { return slot.busy; }));
-	auto& graphics = GetRenderContext().GetGraphics();
-	for (const auto& slot: m_slots) {
-		graphics.device.destroyFence(slot.fence, nullptr);
-	}
-	graphics.device.destroyCommandPool(m_pool, nullptr);
-	m_slots.clear();
-	m_pool = nullptr;
 }
 
 bool CommandBuffer::IsInvalid() const {
@@ -190,18 +69,19 @@ void CommandBuffer::Release() {
 
 	WaitForFence();
 
-	m_host_stream.Release();
-
 	m_slot->busy = false;
-	ResetNativeCommandBuffer(m_slot->buffer);
+	m_slot->Reset();
 	ReleaseResourcesAfterFence();
 	m_slot = nullptr;
 
 	EXIT_NOT_IMPLEMENTED(!IsInvalid());
 }
 
-void CommandBuffer::DeleteAfterFence(VulkanBuffer& buffer) {
+void CommandBuffer::RetireBufferAfterFence(std::unique_ptr<VulkanBuffer> buffer) {
-	m_delete_after_fence.push_back(&buffer);
+	if (IsInvalid() || m_execute || buffer == nullptr || buffer->buffer == nullptr) {
+		EXIT("cannot retire a buffer on an invalid or submitted command buffer\n");
+	}
+	m_retired_buffers.push_back(std::move(buffer));
 }
 
 void CommandBuffer::RetainResourceUntilFence(std::shared_ptr<void> resource) {
@@ -217,12 +97,13 @@ void CommandBuffer::RecycleDescriptorAfterFence(VulkanDescriptorSet& set) {
 
 void CommandBuffer::RecycleDescriptorsAfterFence() {
 	for (auto* set: m_descriptor_sets_after_fence) {
-		GetRenderContext().GetDescriptorCache().Recycle(*set);
+		m_context.GetDescriptorCache().Recycle(*set);
 	}
 	m_descriptor_sets_after_fence.clear();
 }
 
 void CommandBuffer::Begin() const {
+	EXIT_IF(m_rendering);
 	auto buffer = Handle();
 
 	vk::CommandBufferBeginInfo begin_info {};
@@ -237,6 +118,7 @@ void CommandBuffer::Begin() const {
 }
 
 void CommandBuffer::End() const {
+	EndRendering();
 	auto buffer = Handle();
 
 	auto result = buffer.end();
@@ -255,39 +137,34 @@ void CommandBuffer::SetDebugInfo(uint32_t op, uint64_t submit_id, uint32_t arg0,
 	m_debug_arg4      = arg4;
 }
 
-void CommandBuffer::Execute() {
+void CommandBuffer::Execute(const SubmitInfo& submit) {
-	Submit(nullptr, {}, nullptr);
-}
-
-void CommandBuffer::ExecuteWithSemaphore(vk::Semaphore          wait_semaphore,
-                                         vk::PipelineStageFlags wait_stage,
-                                         vk::Semaphore          signal_semaphore) {
-	EXIT_IF(wait_semaphore == nullptr || signal_semaphore == nullptr);
-	Submit(wait_semaphore, wait_stage, signal_semaphore);
-}
-
-void CommandBuffer::Submit(vk::Semaphore wait_semaphore, vk::PipelineStageFlags wait_stage,
-                           vk::Semaphore signal_semaphore) {
 	EXIT_IF(IsInvalid());
 	EXIT_IF(m_execute);
+	EXIT_IF(submit.num_wait_semaphores > SubmitInfo::MaxSemaphores ||
+	        submit.num_signal_semaphores > SubmitInfo::MaxSemaphores);
 
-	const bool has_wait   = wait_semaphore != nullptr;
+	auto buffer = Handle();
-	const bool has_signal = signal_semaphore != nullptr;
+	auto fence  = m_slot->fence;
-	auto       buffer     = Handle();
+
-	auto       fence      = m_slot->fence;
+	vk::TimelineSemaphoreSubmitInfo timeline_info {};
+	timeline_info.sType                     = vk::StructureType::eTimelineSemaphoreSubmitInfo;
+	timeline_info.waitSemaphoreValueCount   = submit.num_wait_semaphores;
+	timeline_info.pWaitSemaphoreValues      = submit.wait_ticks.data();
+	timeline_info.signalSemaphoreValueCount = submit.num_signal_semaphores;
+	timeline_info.pSignalSemaphoreValues    = submit.signal_ticks.data();
 
 	vk::SubmitInfo submit_info {};
 	submit_info.sType                = vk::StructureType::eSubmitInfo;
-	submit_info.pNext                = nullptr;
+	submit_info.pNext                = &timeline_info;
-	submit_info.waitSemaphoreCount   = has_wait ? 1u : 0u;
+	submit_info.waitSemaphoreCount   = submit.num_wait_semaphores;
-	submit_info.pWaitSemaphores      = has_wait ? &wait_semaphore : nullptr;
+	submit_info.pWaitSemaphores      = submit.wait_semaphores.data();
-	submit_info.pWaitDstStageMask    = has_wait ? &wait_stage : nullptr;
+	submit_info.pWaitDstStageMask    = submit.wait_stages.data();
 	submit_info.commandBufferCount   = 1;
 	submit_info.pCommandBuffers      = &buffer;
-	submit_info.signalSemaphoreCount = has_signal ? 1u : 0u;
+	submit_info.signalSemaphoreCount = submit.num_signal_semaphores;
-	submit_info.pSignalSemaphores    = has_signal ? &signal_semaphore : nullptr;
+	submit_info.pSignalSemaphores    = submit.signal_semaphores.data();
 
-	auto& graphics = GetRenderContext().GetGraphics();
+	auto& graphics = m_graphics;
 	EXIT_IF(graphics.queue == nullptr);
 
 	auto result = graphics.device.resetFences(1, &fence);
@@ -298,16 +175,16 @@ void CommandBuffer::Submit(vk::Semaphore wait_semaphore, vk::PipelineStageFlags
 	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
 
 	if (Config::GraphicsDebugDumpEnabled()) {
-		LOGF("vkQueueSubmit begin: slot=%u wait_semaphore=%p signal_semaphore=%p"
+		LOGF("vkQueueSubmit begin: slot=%u waits=%u signals=%u debug_op=%u debug_submit=%" PRIu64
-		     " debug_op=%u debug_submit=%" PRIu64 " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
+		     " args=%u,%u,%u,%u,0x%016" PRIx64 "\n",
-		     m_slot->id, static_cast<void*>(wait_semaphore), static_cast<void*>(signal_semaphore),
+		     m_slot->id, submit.num_wait_semaphores, submit.num_signal_semaphores, m_debug_op,
-		     m_debug_op, m_debug_submit_id, m_debug_arg0, m_debug_arg1, m_debug_arg2, m_debug_arg3,
+		     m_debug_submit_id, m_debug_arg0, m_debug_arg1, m_debug_arg2, m_debug_arg3,
 		     m_debug_arg4);
 	}
 
 	{
 		Common::LockGuard lock(graphics.queue_mutex);
-		m_submit_seq = g_command_buffer_submit_seq.fetch_add(1, std::memory_order_relaxed) + 1;
+		m_submit_seq = m_scheduler.NextSubmitSequence();
 		result       = graphics.queue.submit(1, &submit_info, fence);
 	}
 
@@ -333,7 +210,7 @@ void CommandBuffer::WaitForFenceOnly() {
 	if (!m_execute || m_fence_waited) {
 		return;
 	}
-	auto device = GetRenderContext().GetGraphics().device;
+	auto device = m_graphics.device;
 	auto result = device.waitForFences(1, &m_slot->fence, VK_TRUE, UINT64_MAX);
 	if (result != vk::Result::eSuccess) {
 		LOGF("vkWaitForFences failed: %s (%d), slot=%u submit_seq=%" PRIu64
@@ -357,13 +234,10 @@ void CommandBuffer::FinalizeFence(bool reset_recording) {
 		m_execute      = false;
 		m_fence_waited = false;
 		if (reset_recording) {
-			ResetNativeCommandBuffer(m_slot->buffer);
+			Common::LockGuard lock(*m_slot->pool_mutex);
-			m_recording_generation++;
+			m_slot->Reset();
 		}
 	}
-	if (reset_recording) {
-		m_host_stream.Reset();
-	}
 	if (was_executed) {
 		ReleaseResourcesAfterFence();
 	}
@@ -376,144 +250,71 @@ void CommandBuffer::ReleaseResourcesAfterFence() {
 }
 
 void CommandBuffer::DeleteBuffersAfterFence() {
-	for (auto* buffer: m_delete_after_fence) {
+	for (const auto& buffer: m_retired_buffers) {
-		GetRenderContext().GetGraphics().DeleteBuffer(*buffer);
+		m_graphics.DeleteBuffer(*buffer);
-		delete buffer;
 	}
-	m_delete_after_fence.clear();
+	m_retired_buffers.clear();
 }
 
-void CommandBuffer::BeginRenderPass(VulkanFramebuffer& framebuffer, RenderColorInfo* colors,
+void CommandBuffer::BeginRendering(const RenderState& state) const {
-                                    uint32_t requested_color_count, RenderDepthInfo& depth) const {
+	EXIT_IF(state.width == 0 || state.height == 0 || state.num_layers == 0 ||
-	auto buffer = Handle();
+	        state.num_color_attachments > RENDER_COLOR_ATTACHMENTS_MAX);
-
+	if (m_rendering && m_render_state == state) {
-	EXIT_IF(colors == nullptr);
+		return;
-	EXIT_IF(requested_color_count > RENDER_COLOR_ATTACHMENTS_MAX);
-
-	bool with_depth = (depth.format != vk::Format::eUndefined && depth.vulkan_buffer != nullptr);
-	uint32_t color_count = 0;
-	for (uint32_t i = 0; i < requested_color_count; i++) {
-		if (colors[i].vulkan_buffer == nullptr) {
-			break;
-		}
-		color_count++;
 	}
-	bool with_color = (color_count != 0);
+	EndRendering();
 
-	EXIT_NOT_IMPLEMENTED(!with_depth && !with_color);
+	std::array<vk::RenderingAttachmentInfo, RENDER_COLOR_ATTACHMENTS_MAX> colors {};
-
+	for (uint32_t i = 0; i < state.num_color_attachments; i++) {
-	vk::ClearValue clears[RENDER_COLOR_ATTACHMENTS_MAX + 1] = {};
+		const auto& attachment = state.color_attachments[i];
-	for (uint32_t i = 0; i < color_count; i++) {
+		colors[i].sType        = vk::StructureType::eRenderingAttachmentInfo;
-		clears[i].color = colors[i].color_clear_value;
+		colors[i].imageView    = attachment.image_view;
-	}
+		colors[i].imageLayout  = attachment.image_layout;
-	clears[color_count].depthStencil = {depth.depth_clear_value, depth.stencil_clear_value};
+		colors[i].loadOp =
-
+		    attachment.is_clear ? vk::AttachmentLoadOp::eClear : vk::AttachmentLoadOp::eLoad;
-	vk::Extent2D extent = (with_color ? colors[0].extent : depth.vulkan_buffer->extent);
+		colors[i].storeOp                 = vk::AttachmentStoreOp::eStore;
-
+		colors[i].clearValue.color.uint32 = attachment.clear_value;
-	vk::RenderPassBeginInfo render_pass_info {};
-	render_pass_info.sType             = vk::StructureType::eRenderPassBeginInfo;
-	render_pass_info.pNext             = nullptr;
-	render_pass_info.renderPass        = framebuffer.render_pass;
-	render_pass_info.framebuffer       = framebuffer.framebuffer;
-	render_pass_info.renderArea.offset = {0, 0};
-	render_pass_info.renderArea.extent = extent;
-	render_pass_info.clearValueCount   = color_count + (with_depth ? 1u : 0u);
-	render_pass_info.pClearValues      = clears;
-
-	for (uint32_t i = 0; i < color_count; i++) {
-		const auto color_initial_layout = framebuffer.color_layout[i];
-		if (colors[i].vulkan_buffer->layout != color_initial_layout) {
-			if (graphics_debug_dump_enabled()) {
-				LOGF("BeginRenderPass: color%u initial barrier image=%p mem=%" PRIu64 " %s -> %s\n",
-				     i, VulkanHandleToPointer(colors[i].vulkan_buffer->image),
-				     colors[i].vulkan_buffer->memory.unique_id,
-				     VulkanToString(colors[i].vulkan_buffer->layout).c_str(),
-				     VulkanToString(color_initial_layout).c_str());
-			}
-
-			vk::ImageMemoryBarrier image_memory_barrier {};
-			image_memory_barrier.sType               = vk::StructureType::eImageMemoryBarrier;
-			image_memory_barrier.pNext               = nullptr;
-			image_memory_barrier.srcAccessMask       = {};
-			image_memory_barrier.dstAccessMask       = vk::AccessFlagBits::eColorAttachmentRead |
-			                                           vk::AccessFlagBits::eColorAttachmentWrite;
-			image_memory_barrier.oldLayout           = colors[i].vulkan_buffer->layout;
-			image_memory_barrier.newLayout           = color_initial_layout;
-			image_memory_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-			image_memory_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-			image_memory_barrier.image               = colors[i].vulkan_buffer->image;
-			image_memory_barrier.subresourceRange.aspectMask     = vk::ImageAspectFlagBits::eColor;
-			image_memory_barrier.subresourceRange.baseMipLevel   = 0;
-			image_memory_barrier.subresourceRange.levelCount     = VK_REMAINING_MIP_LEVELS;
-			image_memory_barrier.subresourceRange.baseArrayLayer = 0;
-			image_memory_barrier.subresourceRange.layerCount     = colors[i].vulkan_buffer->layers;
-
-			buffer.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
-			                       vk::PipelineStageFlagBits::eColorAttachmentOutput,
-			                       vk::DependencyFlags {}, 0, nullptr, 0, nullptr, 1,
-			                       &image_memory_barrier);
-
-			colors[i].vulkan_buffer->layout = image_memory_barrier.newLayout;
-		} else if (graphics_debug_dump_enabled()) {
-			LOGF("BeginRenderPass: color%u initial image=%p mem=%" PRIu64 " layout=%s\n", i,
-			     VulkanHandleToPointer(colors[i].vulkan_buffer->image),
-			     colors[i].vulkan_buffer->memory.unique_id,
-			     VulkanToString(colors[i].vulkan_buffer->layout).c_str());
-		}
 	}
 
-	const auto depth_layout =
+	const auto&                 depth_stencil = state.depth_stencil_attachment;
-	    with_depth ? framebuffer.depth_layout : vk::ImageLayout::eDepthStencilAttachmentOptimal;
+	vk::RenderingAttachmentInfo depth {};
+	depth.sType       = vk::StructureType::eRenderingAttachmentInfo;
+	depth.imageView   = depth_stencil.image_view;
+	depth.imageLayout = depth_stencil.image_layout;
+	depth.loadOp =
+	    depth_stencil.depth_clear ? vk::AttachmentLoadOp::eClear : vk::AttachmentLoadOp::eLoad;
+	depth.storeOp                       = vk::AttachmentStoreOp::eStore;
+	depth.clearValue.depthStencil.depth = std::bit_cast<float>(depth_stencil.clear_value[0]);
 
-	if (with_depth && depth.vulkan_buffer->layout != depth_layout) {
+	vk::RenderingAttachmentInfo stencil {};
-		vk::ImageMemoryBarrier image_memory_barrier {};
+	stencil.sType       = vk::StructureType::eRenderingAttachmentInfo;
-		image_memory_barrier.sType = vk::StructureType::eImageMemoryBarrier;
+	stencil.imageView   = depth_stencil.image_view;
-		image_memory_barrier.pNext = nullptr;
+	stencil.imageLayout = depth_stencil.image_layout;
-		image_memory_barrier.srcAccessMask =
+	stencil.loadOp =
-		    vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
+	    depth_stencil.stencil_clear ? vk::AttachmentLoadOp::eClear : vk::AttachmentLoadOp::eLoad;
-		image_memory_barrier.dstAccessMask =
+	stencil.storeOp                         = vk::AttachmentStoreOp::eStore;
-		    (depth_layout == vk::ImageLayout::eDepthStencilReadOnlyOptimal
+	stencil.clearValue.depthStencil.stencil = depth_stencil.clear_value[1];
-		         ? vk::AccessFlagBits::eMemoryRead
-		         : vk::AccessFlagBits::eMemoryWrite);
-		image_memory_barrier.oldLayout           = depth.vulkan_buffer->layout;
-		image_memory_barrier.newLayout           = depth_layout;
-		image_memory_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-		image_memory_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-		image_memory_barrier.image               = depth.vulkan_buffer->image;
-		image_memory_barrier.subresourceRange.aspectMask =
-		    ImageViewOps::DepthAspectMask(depth.vulkan_buffer->format);
-		image_memory_barrier.subresourceRange.baseMipLevel   = 0;
-		image_memory_barrier.subresourceRange.levelCount     = 1;
-		image_memory_barrier.subresourceRange.baseArrayLayer = 0;
-		image_memory_barrier.subresourceRange.layerCount     = depth.vulkan_buffer->layers;
 
-		buffer.pipelineBarrier(
+	vk::RenderingInfo rendering {};
-		    vk::PipelineStageFlagBits::eAllGraphics | vk::PipelineStageFlagBits::eComputeShader,
+	rendering.sType                = vk::StructureType::eRenderingInfo;
-		    vk::PipelineStageFlagBits::eAllGraphics | vk::PipelineStageFlagBits::eComputeShader,
+	rendering.renderArea.extent    = {state.width, state.height};
-		    vk::DependencyFlags {}, 0, nullptr, 0, nullptr, 1, &image_memory_barrier);
+	rendering.layerCount           = state.num_layers;
-
+	rendering.colorAttachmentCount = state.num_color_attachments;
-		depth.vulkan_buffer->layout = image_memory_barrier.newLayout;
+	rendering.pColorAttachments    = colors.data();
-	}
+	rendering.pDepthAttachment     = depth_stencil.has_depth ? &depth : nullptr;
-
+	rendering.pStencilAttachment   = depth_stencil.has_stencil ? &stencil : nullptr;
-	buffer.beginRenderPass(&render_pass_info, vk::SubpassContents::eInline);
+	Handle().beginRendering(rendering);
-
+	m_render_state = state;
-	for (uint32_t i = 0; i < color_count; i++) {
+	m_rendering    = true;
-		colors[i].vulkan_buffer->layout = RENDER_COLOR_IMAGE_LAYOUT;
-		if (colors[i].vulkan_buffer->type == VulkanImageType::RenderTexture) {
-			static_cast<RenderTextureVulkanImage*>(colors[i].vulkan_buffer)->initial_clear_pending =
-			    false;
-		}
-	}
-	if (with_depth) {
-		depth.vulkan_buffer->initial_depth_clear_pending   = false;
-		depth.vulkan_buffer->initial_stencil_clear_pending = false;
-	}
 }
 
-void CommandBuffer::EndRenderPass() const {
+void CommandBuffer::EndRendering() const {
-	auto buffer = Handle();
+	if (!m_rendering) {
-
+		return;
-	buffer.endRenderPass();
+	}
+	Handle().endRendering();
+	m_rendering    = false;
+	m_render_state = {};
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/debug.cpp

@@ -9,6 +9,7 @@
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/host_gpu/renderer/render.h"
 
+#include <algorithm>
 #include <atomic>
 #include <cmath>
 #include <fmt/format.h>
@@ -100,8 +101,6 @@ void sh_print(const char* func, const HW::Shader& /*uc*/) {
 	LOGF("%s\n", func);
 }
 
-void sh_check(const HW::Shader& /*uc*/) {}
-
 std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt) {
 	std::vector<std::string> dst;
 	dst.reserve(53);
@@ -360,30 +359,12 @@ static void RtCheck(const HW::RenderTarget& rt) {
 				logged = true;
 			}
 		}
-		if (rt.attrib3.depth != 0x00000000) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("RenderTarget: temporary: ignoring PS5 color target depth_minus1=0x%08" PRIx32
-				     "\n",
-				     rt.attrib3.depth);
-				logged = true;
-			}
-		}
 		if (!RenderIsColorTileMode(rt.attrib3.tile_mode)) {
 			EXIT("unknown PS5 render-target tile mode: 0x%08" PRIx32 "\n", rt.attrib3.tile_mode);
 		}
 		if (!RenderIsColorDimension(rt.attrib3.dimension)) {
 			EXIT("unknown PS5 render-target dimension: 0x%08" PRIx32 "\n", rt.attrib3.dimension);
 		}
-		if (rt.attrib3.dimension != 0x00000001) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("RenderTarget: temporary: using 2D fallback for PS5 color "
-				     "dimension=0x%08" PRIx32 "\n",
-				     rt.attrib3.dimension);
-				logged = true;
-			}
-		}
 		if (!rt.attrib3.cmask_pipe_aligned) {
 			static bool logged = false;
 			if (!logged) {
@@ -431,21 +412,17 @@ static void ZPrint(const char* func, const HW::DepthRenderTarget& z) {
 	LOGF("%s\n", func);
 
 	LOGF("\t z_info.format                         = 0x%08" PRIx32 "\n"
-	     "\t z_info.tile_mode_index                = 0x%08" PRIx32 "\n"
 	     "\t z_info.num_samples                    = 0x%08" PRIx32 "\n"
-	     "\t z_info.tile_surface_enable            = %s\n"
+	     "\t z_info.texture_compatibility          = 0x%08" PRIx32 "\n"
+	     "\t z_info.htile_acceleration             = %s\n"
 	     "\t z_info.expclear_enabled               = %s\n"
-	     "\t z_info.zrange_precision               = 0x%08" PRIx32 "\n"
+	     "\t z_info.z_compare_base                 = 0x%08" PRIx32 "\n"
-	     "\t z_info.embedded_sample_locations      = %s\n"
 	     "\t z_info.partially_resident             = %s\n"
-	     "\t z_info.num_mip_levels                 = 0x%02" PRIx8 "\n"
+	     "\t z_info.max_mip_level                  = 0x%02" PRIx8 "\n"
-	     "\t z_info.plane_compression              = 0x%02" PRIx8 "\n"
 	     "\t stencil_info.format                   = 0x%08" PRIx32 "\n"
-	     "\t stencil_info.tile_stencil_disable     = %s\n"
+	     "\t stencil_info.texture_compatibility    = 0x%08" PRIx32 "\n"
+	     "\t stencil_info.htile_stencil_disabled   = %s\n"
 	     "\t stencil_info.expclear_enabled         = %s\n"
-	     "\t stencil_info.tile_mode_index          = 0x%08" PRIx32 "\n"
-	     "\t stencil_info.tile_split               = 0x%08" PRIx32 "\n"
-	     "\t stencil_info.texture_compatible_stencil = %s\n"
 	     "\t stencil_info.partially_resident       = %s\n"
 	     "\t depth_info.addr5_swizzle_mask         = 0x%08" PRIx32 "\n"
 	     "\t depth_info.array_mode                 = 0x%08" PRIx32 "\n"
@@ -478,15 +455,15 @@ static void ZPrint(const char* func, const HW::DepthRenderTarget& z) {
 	     "\t height                                = 0x%08" PRIx32 "\n"
 	     "\t size.x_max                            = 0x%04" PRIx16 "\n"
 	     "\t size.y_max                            = 0x%04" PRIx16 "\n",
-	     z.z_info.format, z.z_info.tile_mode_index, z.z_info.num_samples,
+	     z.z_info.format, z.z_info.num_samples,
-	     z.z_info.tile_surface_enable ? "true" : "false",
+	     Prospero::GpuEnumValue(z.z_info.texture_compatibility),
-	     z.z_info.expclear_enabled ? "true" : "false", z.z_info.zrange_precision,
+	     z.z_info.htile_acceleration ? "true" : "false",
-	     z.z_info.embedded_sample_locations ? "true" : "false",
+	     z.z_info.expclear_enabled ? "true" : "false",
-	     z.z_info.partially_resident ? "true" : "false", z.z_info.num_mip_levels,
+	     Prospero::GpuEnumValue(z.z_info.z_compare_base),
-	     z.z_info.plane_compression, z.stencil_info.format,
+	     z.z_info.partially_resident ? "true" : "false", z.z_info.max_mip_level,
-	     z.stencil_info.tile_stencil_disable ? "true" : "false",
+	     z.stencil_info.format, Prospero::GpuEnumValue(z.stencil_info.texture_compatibility),
-	     z.stencil_info.expclear_enabled ? "true" : "false", z.stencil_info.tile_mode_index,
+	     z.stencil_info.htile_stencil_disabled ? "true" : "false",
-	     z.stencil_info.tile_split, z.stencil_info.texture_compatible_stencil ? "true" : "false",
+	     z.stencil_info.expclear_enabled ? "true" : "false",
 	     z.stencil_info.partially_resident ? "true" : "false", z.depth_info.addr5_swizzle_mask,
 	     z.depth_info.array_mode, z.depth_info.pipe_config, z.depth_info.bank_width,
 	     z.depth_info.bank_height, z.depth_info.macro_tile_aspect, z.depth_info.num_banks,
@@ -502,37 +479,26 @@ static void ZPrint(const char* func, const HW::DepthRenderTarget& z) {
 }
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-static void ZCheck(const HW::DepthRenderTarget& z) {
+static void ZCheck(const HW::DepthRenderTarget& z, const HW::DepthControl& dc,
+                   const HW::RenderControl& rc) {
+	const bool depth_active =
+	    dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable || rc.depth_clear_enable;
+	const bool stencil_active = dc.stencil_enable || rc.stencil_clear_enable;
+	if (!depth_active && !stencil_active) {
+		return;
+	}
+
+	EXIT_NOT_IMPLEMENTED(!z.z_info.HasValidTextureCompatibility());
+	EXIT_NOT_IMPLEMENTED(!z.stencil_info.HasValidTextureCompatibility());
 	if (z.z_info.format == 0) {
 		EXIT_NOT_IMPLEMENTED(z.z_info.format != 0);
-		EXIT_NOT_IMPLEMENTED(z.z_info.tile_mode_index != 0);
 		EXIT_NOT_IMPLEMENTED(z.z_info.num_samples != 0);
-		EXIT_NOT_IMPLEMENTED(z.z_info.tile_surface_enable != false);
+		EXIT_NOT_IMPLEMENTED(z.z_info.htile_acceleration != false);
 		EXIT_NOT_IMPLEMENTED(z.z_info.expclear_enabled != false);
-		if (z.z_info.zrange_precision != 0) {
-			LOGF("Warning: zrange_precision != 0\n");
-			// z.z_info.zrange_precision = 0;
-		}
-		if (z.z_info.embedded_sample_locations) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("DepthTarget: temporary: ignoring embedded sample locations\n");
-				logged = true;
-			}
-		}
 		EXIT_NOT_IMPLEMENTED(z.z_info.partially_resident != false);
-		EXIT_NOT_IMPLEMENTED(z.z_info.num_mip_levels != 0);
+		EXIT_NOT_IMPLEMENTED(z.z_info.max_mip_level != 0);
-		if (z.z_info.plane_compression != 0) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("DepthTarget: temporary: ignoring PS5 plane_compression=0x%02" PRIx8 "\n",
-				     z.z_info.plane_compression);
-				logged = true;
-			}
-		}
 	} else {
 		EXIT_NOT_IMPLEMENTED(z.z_info.format != 0x00000001 && z.z_info.format != 0x00000003);
-		// EXIT_NOT_IMPLEMENTED(z.z_info.tile_mode_index != 0x00000002);
 		if (z.z_info.num_samples != 0x00000000) {
 			static bool logged = false;
 			if (!logged) {
@@ -541,56 +507,17 @@ static void ZCheck(const HW::DepthRenderTarget& z) {
 				logged = true;
 			}
 		}
-		// EXIT_NOT_IMPLEMENTED(z.z_info.tile_surface_enable != true);
 		EXIT_NOT_IMPLEMENTED(z.z_info.expclear_enabled != false);
-		if (z.z_info.zrange_precision != 0x00000001) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("DepthTarget: temporary: ignoring zrange_precision=0x%08" PRIx32 "\n",
-				     z.z_info.zrange_precision);
-				logged = true;
-			}
-		}
-		if (z.z_info.embedded_sample_locations) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("DepthTarget: temporary: ignoring embedded sample locations\n");
-				logged = true;
-			}
-		}
 		EXIT_NOT_IMPLEMENTED(z.z_info.partially_resident != false);
-		EXIT_NOT_IMPLEMENTED(z.z_info.num_mip_levels != 0);
+		EXIT_NOT_IMPLEMENTED(z.z_info.max_mip_level != 0);
-		if (z.z_info.plane_compression != 0) {
-			static bool logged = false;
-			if (!logged) {
-				LOGF("DepthTarget: temporary: ignoring PS5 plane_compression=0x%02" PRIx8 "\n",
-				     z.z_info.plane_compression);
-				logged = true;
-			}
-		}
 	}
 
 	if (z.stencil_info.format == 0) {
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.format != 0);
-		//  EXIT_NOT_IMPLEMENTED(z.stencil_info.tile_stencil_disable != false);
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.expclear_enabled != false);
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.tile_mode_index != 0);
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.tile_split != 0);
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.texture_compatible_stencil != true);
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.partially_resident != false);
 	} else {
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.format != 0x00000001);
+		EXIT_NOT_IMPLEMENTED(z.stencil_info.format != 0x00000001);
-		if (z.stencil_info.tile_stencil_disable != true) {
-
-			static std::atomic<uint32_t> log_count {0};
-			if (log_count.fetch_add(1) < 16) {
-				LOGF("DepthTarget: temporary: ignoring PS5 HTILE stencil acceleration\n");
-			}
-		}
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.expclear_enabled != false);
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.tile_mode_index != 0x00000002);
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.tile_split != 0x00000002);
-		// EXIT_NOT_IMPLEMENTED(z.stencil_info.texture_compatible_stencil != true);
 		EXIT_NOT_IMPLEMENTED(z.stencil_info.partially_resident != false);
 	}
 
@@ -611,14 +538,6 @@ static void ZCheck(const HW::DepthRenderTarget& z) {
 		EXIT_NOT_IMPLEMENTED(z.htile_surface.prefetch_height != 0x00000000);
 		EXIT_NOT_IMPLEMENTED(z.htile_surface.dst_outside_zero_to_one != 0x00000000);
 
-		if (z.depth_view.slice_start != 0x00000000 || z.depth_view.slice_max != 0x00000000) {
-			static std::atomic<uint32_t> log_count {0};
-			if (log_count.fetch_add(1, std::memory_order_relaxed) < 16) {
-				LOGF("DepthTarget: temporary: ignoring PS5 array slice view start=0x%08" PRIx32
-				     ", max=0x%08" PRIx32 "\n",
-				     z.depth_view.slice_start, z.depth_view.slice_max);
-			}
-		}
 		if (z.depth_view.current_mip_level != 0x00000000) {
 			static std::atomic<uint32_t> log_count {0};
 			if (log_count.fetch_add(1, std::memory_order_relaxed) < 16) {
@@ -1135,10 +1054,10 @@ static ScissorRect ScissorRectClamp(ScissorRect r, uint32_t width, uint32_t heig
 	int max_right  = static_cast<int>(width);
 	int max_bottom = static_cast<int>(height);
 
-	r.left   = (r.left < 0 ? 0 : (r.left > max_right ? max_right : r.left));
+	r.left   = std::clamp(r.left, 0, max_right);
-	r.right  = (r.right < 0 ? 0 : (r.right > max_right ? max_right : r.right));
+	r.right  = std::clamp(r.right, 0, max_right);
-	r.top    = (r.top < 0 ? 0 : (r.top > max_bottom ? max_bottom : r.top));
+	r.top    = std::clamp(r.top, 0, max_bottom);
-	r.bottom = (r.bottom < 0 ? 0 : (r.bottom > max_bottom ? max_bottom : r.bottom));
+	r.bottom = std::clamp(r.bottom, 0, max_bottom);
 
 	if (!ScissorRectValid(r)) {
 		r.right  = r.left;
@@ -1277,7 +1196,7 @@ void hw_check(const RenderCommandBuffer& buffer) {
 	log_phase("vp");
 	VpCheck(vp, smc);
 	log_phase("z");
-	ZCheck(z);
+	ZCheck(z, d, rc);
 	log_phase("clip");
 	ClipCheck(c);
 	log_phase("rc");

src/graphics/host_gpu/renderer/debug.h

@@ -33,7 +33,6 @@ bool                     graphics_debug_dump_enabled();
 void                     uc_print(const char* func, const HW::UserConfig& uc);
 void                     uc_check(const HW::UserConfig& uc);
 void                     sh_print(const char* func, const HW::Shader& uc);
-void                     sh_check(const HW::Shader& uc);
 std::vector<std::string> rt_print(const char* func, const HW::RenderTarget& rt);
 bool                     RenderIsColorTileModeLinear(uint32_t tile_mode);
 void                     hw_print(const RenderCommandBuffer& buffer);

src/graphics/host_gpu/renderer/depthRenderTarget.cpp

@@ -10,15 +10,13 @@
 #include "graphics/guest_gpu/hardwareContext.h"
 #include "graphics/guest_gpu/tile.h"
 #include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/objects/textureCommon.h"
 #include "graphics/host_gpu/renderer/debug.h"
-#include "graphics/host_gpu/renderer/descriptorCache.h"
+#include "graphics/host_gpu/renderer/image/imageView.h"
-#include "graphics/host_gpu/renderer/framebufferCache.h"
+#include "graphics/host_gpu/renderer/image/textureCommon.h"
+#include "graphics/host_gpu/renderer/pipeline/descriptorCache.h"
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/transfer.h"
 #include "graphics/host_gpu/vulkanCommon.h"
-#include "graphics/presentation/displayBuffer.h"
 
 #include <algorithm>
 #include <atomic>
@@ -88,7 +86,8 @@ static bool UsesStencilOpValue(uint8_t fail, uint8_t pass, uint8_t depth_fail) {
 }
 
 // NOLINTNEXTLINE(readability-function-cognitive-complexity)
-void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, RenderDepthInfo& r) {
+void RenderExecutor::ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer,
+                                              RenderDepthInfo& r) {
 	KYTY_PROFILER_FUNCTION();
 	(void)submit_id;
 	const auto& hw = buffer.GetRegisters();
@@ -97,37 +96,42 @@ void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	const auto& dc = hw.GetDepthControl();
 	const auto& sc = hw.GetStencilControl();
 	const auto& sm = hw.GetStencilMask();
-	const bool  depth_active =
+	const bool  has_stencil =
+	    z.stencil_info.format != Prospero::GpuEnumValue(Prospero::StencilFormat::kInvalid);
+	const bool depth_active =
 	    dc.z_enable || dc.z_write_enable || dc.depth_bounds_enable || rc.depth_clear_enable;
-	const bool stencil_active = dc.stencil_enable || rc.stencil_clear_enable;
+	const bool stencil_active = has_stencil && (dc.stencil_enable || rc.stencil_clear_enable);
 	if (!depth_active && !stencil_active) {
 		return;
 	}
+	if (!z.z_info.HasValidTextureCompatibility() ||
+	    !z.stencil_info.HasValidTextureCompatibility()) {
+		DepthFatal("invalid PS5 depth texture-compatibility encoding");
+	}
 	const bool attachment_unbound =
 	    z.z_info.format == Prospero::GpuEnumValue(Prospero::DepthFormat::kInvalid) &&
 	    z.stencil_info.format == Prospero::GpuEnumValue(Prospero::StencilFormat::kInvalid) &&
-	    z.z_info.tile_mode_index == 0 && z.z_info.num_samples == 0 &&
+	    z.z_info.num_samples == 0 &&
-	    z.z_info.zrange_precision <= 1 && !z.z_info.expclear_enabled &&
+	    z.z_info.texture_compatibility == Prospero::TextureCompatiblePlaneCompression::kDisable &&
-	    !z.z_info.embedded_sample_locations && !z.z_info.partially_resident &&
+	    !z.z_info.expclear_enabled && !z.z_info.partially_resident && z.z_info.max_mip_level == 0 &&
-	    z.z_info.num_mip_levels == 0 && z.z_info.plane_compression == 0 &&
+	    z.stencil_info.texture_compatibility == Prospero::TextureCompatibleStencil::kDisable &&
-	    z.stencil_info.tile_mode_index == 0 && z.stencil_info.tile_split == 0 &&
+	    !z.stencil_info.expclear_enabled && !z.stencil_info.partially_resident &&
-	    !z.stencil_info.expclear_enabled && !z.stencil_info.texture_compatible_stencil &&
+	    z.depth_view.slice_start == 0 && z.depth_view.slice_max == 0 &&
-	    !z.stencil_info.partially_resident && z.depth_view.slice_start == 0 &&
+	    z.depth_view.current_mip_level == 0 && !z.depth_view.depth_write_disable &&
-	    z.depth_view.slice_max == 0 && z.depth_view.current_mip_level == 0 &&
+	    !z.depth_view.stencil_write_disable && z.depth_info.addr5_swizzle_mask == 0 &&
-	    !z.depth_view.depth_write_disable && !z.depth_view.stencil_write_disable &&
+	    z.depth_info.array_mode == 0 && z.depth_info.pipe_config == 0 &&
-	    z.depth_info.addr5_swizzle_mask == 0 && z.depth_info.array_mode == 0 &&
+	    z.depth_info.bank_width == 0 && z.depth_info.bank_height == 0 &&
-	    z.depth_info.pipe_config == 0 && z.depth_info.bank_width == 0 &&
+	    z.depth_info.macro_tile_aspect == 0 && z.depth_info.num_banks == 0 &&
-	    z.depth_info.bank_height == 0 && z.depth_info.macro_tile_aspect == 0 &&
+	    z.htile_surface.linear == 0 && z.htile_surface.full_cache == 0 &&
-	    z.depth_info.num_banks == 0 && z.htile_surface.linear == 0 &&
+	    z.htile_surface.htile_uses_preload_win == 0 && z.htile_surface.preload == 0 &&
-	    z.htile_surface.full_cache == 0 && z.htile_surface.htile_uses_preload_win == 0 &&
+	    z.htile_surface.prefetch_width == 0 && z.htile_surface.prefetch_height == 0 &&
-	    z.htile_surface.preload == 0 && z.htile_surface.prefetch_width == 0 &&
+	    z.htile_surface.dst_outside_zero_to_one == 0 && z.z_read_base_addr == 0 &&
-	    z.htile_surface.prefetch_height == 0 && z.htile_surface.dst_outside_zero_to_one == 0 &&
+	    z.z_write_base_addr == 0 && z.stencil_read_base_addr == 0 &&
-	    z.z_read_base_addr == 0 && z.z_write_base_addr == 0 && z.stencil_read_base_addr == 0 &&
 	    z.stencil_write_base_addr == 0 && z.htile_data_base_addr == 0 &&
 	    // DB_DEPTH_SIZE_XY is independent state and may remain programmed after the attachment
 	    // formats and addresses are unbound. A zero encoding is the valid 1x1 value, so its
 	    // presence alone must not manufacture a depth attachment.
-	    !z.z_info.tile_surface_enable && !z.width_height_valid && !z.pitch_height_valid &&
+	    !z.z_info.htile_acceleration && !z.width_height_valid && !z.pitch_height_valid &&
 	    z.size.x_max == 0 && z.size.y_max == 0 && z.pitch_div8_minus1 == 0 &&
 	    z.height_div8_minus1 == 0 && z.slice_div64_minus1 == 0 && z.width == 0 && z.height == 0;
 	if (attachment_unbound) {
@@ -137,33 +141,25 @@ void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 		}
 		return;
 	}
-	const bool has_stencil =
+	const bool has_htile = z.z_info.htile_acceleration;
-	    z.stencil_info.format != Prospero::GpuEnumValue(Prospero::StencilFormat::kInvalid);
-	const bool has_htile = z.z_info.tile_surface_enable;
 	const auto samples   = render_sample_count(z.z_info.num_samples);
 	if (samples == 0) {
 		DepthFatal("unsupported depth fragment count: %u", z.z_info.num_samples);
 	}
 	const bool htile_stencil_compat = depth_htile_stencil_acceleration_compatible(
-	    has_stencil, has_htile, z.stencil_info.tile_stencil_disable);
+	    has_stencil, has_htile, z.stencil_info.htile_stencil_disabled);
 	const auto view = ResolveTargetViewInfo(z.depth_view.slice_start, z.depth_view.slice_max);
 	switch (view.type) {
-		case TargetViewType::Image2D: break;
+		case TargetViewType::Image2D:
-		case TargetViewType::Image2DArray:
+		case TargetViewType::Image2DArray: break;
-			DepthFatal("layered depth views are unsupported: base=%u count=%u", view.base_layer,
-			           view.layer_count);
 		case TargetViewType::Unsupported:
 			DepthFatal("invalid depth view: base=%u last=%u", z.depth_view.slice_start,
 			           z.depth_view.slice_max);
 	}
-	// Prospero defines the compression-disable bits as tile writeback policy. Vulkan attachments
+	if (rc.resummarize_enable || rc.copy_centroid || rc.copy_sample != 0 ||
-	// expose the same logical depth/stencil values regardless of the driver's backing compression.
+	    z.z_info.expclear_enabled || z.stencil_info.expclear_enabled ||
-	if ((stencil_active && !has_stencil) || rc.resummarize_enable || rc.copy_centroid ||
+	    z.z_info.partially_resident || z.stencil_info.partially_resident ||
-	    rc.copy_sample != 0 || z.z_info.expclear_enabled || z.stencil_info.expclear_enabled ||
+	    z.z_info.max_mip_level != 0 || z.depth_view.current_mip_level != 0 ||
-	    z.z_info.embedded_sample_locations || z.z_info.partially_resident ||
-	    z.stencil_info.partially_resident || z.z_info.plane_compression != 0 ||
-	    z.z_info.num_mip_levels != 0 || z.z_info.tile_mode_index != 0 ||
-	    z.z_info.zrange_precision > 1 || z.depth_view.current_mip_level != 0 ||
 	    z.depth_info.addr5_swizzle_mask != 0 || z.depth_info.array_mode != 0 ||
 	    z.depth_info.pipe_config != 0 || z.depth_info.bank_width != 0 ||
 	    z.depth_info.bank_height != 0 || z.depth_info.macro_tile_aspect != 0 ||
@@ -177,27 +173,16 @@ void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 		DepthFatal("unsupported depth register state");
 	}
 	if (has_stencil) {
-		// Prospero defines Hi-Stencil as HTile-backed acceleration of the logical stencil plane.
-		// Keep the plane native in Vulkan while tracking HTile separately.
 		if (z.stencil_info.format != Prospero::GpuEnumValue(Prospero::StencilFormat::k8UInt) ||
-		    z.stencil_info.tile_mode_index != 0 || z.stencil_info.tile_split != 0 ||
+		    !htile_stencil_compat || z.stencil_read_base_addr == 0 ||
-		    !htile_stencil_compat || z.stencil_info.texture_compatible_stencil ||
-		    z.stencil_read_base_addr == 0 ||
 		    z.stencil_write_base_addr != z.stencil_read_base_addr ||
 		    (z.stencil_read_base_addr & 0xffffu) != 0 || z.depth_view.stencil_write_disable) {
 			DepthFatal("unsupported stencil attachment state");
 		}
-		if (!z.stencil_info.tile_stencil_disable) {
-			static std::atomic_bool logged = false;
-			if (!logged.load(std::memory_order_relaxed) &&
-			    !logged.exchange(true, std::memory_order_relaxed)) {
-				LOGF("DepthTarget: compatibility: using native stencil with PS5 HTILE "
-				     "acceleration\n");
-			}
-		}
 	} else if (z.stencil_read_base_addr != 0 || z.stencil_write_base_addr != 0 ||
-	           z.stencil_info.tile_mode_index != 0 || z.stencil_info.tile_split != 0 ||
+	           !htile_stencil_compat ||
-	           !htile_stencil_compat || z.stencil_info.texture_compatible_stencil) {
+	           z.stencil_info.texture_compatibility !=
+	               Prospero::TextureCompatibleStencil::kDisable) {
 		DepthFatal("stencil state without an active stencil attachment");
 	}
 	if (has_htile) {
@@ -272,28 +257,19 @@ void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	    (has_htile && htile_backing_size > TRACKER_ADDRESS_SIZE - z.htile_data_base_addr)) {
 		DepthFatal("layered depth backing range is invalid");
 	}
-	r.htile                = has_htile;
+	r.htile                   = has_htile;
-	r.width                = width;
+	r.width                   = width;
-	r.height               = height;
+	r.height                  = height;
-	r.samples              = samples;
+	r.samples                 = samples;
-	r.depth_buffer_size    = depth_backing_size;
+	r.depth_buffer_size       = depth_backing_size;
-	r.depth_buffer_vaddr   = z.z_read_base_addr;
+	r.depth_buffer_vaddr      = z.z_read_base_addr;
-	r.stencil_buffer_size  = has_stencil ? stencil_backing_size : 0;
+	r.stencil_buffer_size     = has_stencil ? stencil_backing_size : 0;
-	r.stencil_buffer_vaddr = has_stencil ? z.stencil_read_base_addr : 0;
+	r.stencil_buffer_vaddr    = has_stencil ? z.stencil_read_base_addr : 0;
-	r.htile_buffer_size    = has_htile ? htile_backing_size : 0;
+	r.htile_buffer_size       = has_htile ? htile_backing_size : 0;
-	r.htile_buffer_vaddr   = has_htile ? z.htile_data_base_addr : 0;
+	r.htile_buffer_vaddr      = has_htile ? z.htile_data_base_addr : 0;
-	auto& cache            = GetRenderContext().GetTextureCache();
-	if (has_htile) {
-		cache.RegisterMeta(r.htile_buffer_vaddr, r.htile_buffer_size, view.image_layers);
-	}
-	if (has_htile && rc.depth_clear_enable && !cache.ClearMeta(z.htile_data_base_addr)) {
-		DepthFatal("failed to acquire HTile metadata for a depth clear");
-	}
-	const bool meta_clear =
-	    has_htile && cache.IsMetaCleared(z.htile_data_base_addr, z.depth_view.slice_start);
 	r.depth_clear_enable      = rc.depth_clear_enable;
-	r.depth_meta_clear_enable = meta_clear;
+	r.depth_meta_clear_enable = false;
-	r.depth_load_clear_enable = r.depth_clear_enable || r.depth_meta_clear_enable;
+	r.depth_load_clear_enable = r.depth_clear_enable;
 	r.depth_clear_value       = hw.GetDepthClearValue();
 	r.depth_test_enable       = dc.z_enable;
 	r.depth_write_enable      = dc.z_write_enable && !z.depth_view.depth_write_disable;
@@ -303,10 +279,10 @@ void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 	r.depth_min_bounds         = hw.GetDepthBoundsMin();
 	r.depth_max_bounds         = hw.GetDepthBoundsMax();
 
-	r.stencil_clear_enable = rc.stencil_clear_enable;
+	r.stencil_clear_enable = has_stencil && rc.stencil_clear_enable;
 	r.stencil_clear_value  = hw.GetStencilClearValue();
-	r.stencil_test_enable  = dc.stencil_enable;
+	r.stencil_test_enable  = has_stencil && dc.stencil_enable;
-	if (dc.stencil_enable) {
+	if (r.stencil_test_enable) {
 		if (dc.stencilfunc > static_cast<uint8_t>(vk::CompareOp::eAlways) ||
 		    (dc.backface_enable &&
 		     dc.stencilfunc_bf > static_cast<uint8_t>(vk::CompareOp::eAlways)) ||
@@ -343,55 +319,93 @@ void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, R
 		r.vaddr[1] = r.stencil_buffer_vaddr;
 		r.size[1]  = r.stencil_buffer_size;
 	}
-	DepthTargetInfo info {};
+	TextureCache::ImageDesc desc {};
-	info.address            = r.depth_buffer_vaddr;
+	desc.type                 = TextureCache::BindingType::DepthTarget;
-	info.size               = r.depth_buffer_size;
+	desc.info.data            = {r.depth_buffer_vaddr, r.depth_buffer_size};
-	info.stencil_address    = r.stencil_buffer_vaddr;
+	desc.info.stencil         = {r.stencil_buffer_vaddr, r.stencil_buffer_size};
-	info.stencil_size       = r.stencil_buffer_size;
+	desc.info.pixel_format    = r.format;
-	info.htile_address      = r.htile_buffer_vaddr;
+	desc.info.guest_format    = guest_format;
-	info.htile_size         = r.htile_buffer_size;
+	desc.info.type            = Prospero::ImageType::kColor2D;
-	info.format             = r.format;
+	desc.info.extent          = {width, height, 1};
-	info.guest_format       = guest_format;
+	desc.info.resources       = {1, view.image_layers};
-	info.width              = width;
+	desc.info.pitch           = pitch;
-	info.height             = height;
+	desc.info.bytes_per_block = bytes;
-	info.pitch              = pitch;
+	desc.info.samples         = samples;
-	info.bytes_per_element  = bytes;
+	desc.info.tile_mode       = Prospero::GpuEnumValue(Prospero::TileMode::kDepth);
-	info.tile_mode          = Prospero::GpuEnumValue(Prospero::TileMode::kDepth);
+	desc.info.mip_layout[0]   = {0, r.depth_buffer_size, pitch, height};
-	info.layers             = view.image_layers;
+	desc.info.metadata.range  = {r.htile_buffer_vaddr, r.htile_buffer_size};
-	info.samples            = samples;
+	desc.info.metadata.kind   = has_htile ? ImageMetadataKind::Htile : ImageMetadataKind::None;
-	info.depth_load_clear   = r.depth_load_clear_enable;
+	desc.info.metadata.stencil_compressed =
-	info.depth_access       = depth_active;
+	    has_stencil && has_htile && !z.stencil_info.htile_stencil_disabled;
-	info.stencil_load_clear = rc.stencil_clear_enable;
+	desc.view_info.format = r.format;
-	info.stencil_access =
+	desc.view_info.type =
-	    r.stencil_clear_enable ||
+	    view.layer_count == 1 ? vk::ImageViewType::e2D : vk::ImageViewType::e2DArray;
-	    (r.stencil_test_enable &&
+	desc.view_info.aspect      = ImageViewOps::DepthAspectMask(r.format);
-	     (stencil_face_accesses_attachment(r.stencil_static_front, r.stencil_dynamic_front) ||
+	desc.view_info.base_level  = 0;
-	      stencil_face_accesses_attachment(r.stencil_static_back, r.stencil_dynamic_back)));
+	desc.view_info.level_count = 1;
-	info.stencil_htile_compressed =
+	desc.view_info.base_layer  = view.base_layer;
-	    has_stencil && has_htile && !z.stencil_info.tile_stencil_disable;
+	desc.view_info.layer_count = view.layer_count;
-	r.vulkan_buffer = &cache.FindDepthTarget(buffer, info);
+	desc.view_info.usage       = vk::ImageUsageFlagBits::eDepthStencilAttachment;
-	r.vulkan_view =
+	r.desc                     = std::move(desc);
-	    cache.GetDepthTargetAttachmentView(*r.vulkan_buffer, view.base_layer, view.layer_count);
+	auto& cache                = m_context.GetTextureCache();
-	if (r.vulkan_buffer->initial_depth_clear_pending) {
+	r.image_id                 = cache.FindImage(r.desc);
-		r.depth_load_clear_enable = true;
+	r.image_view               = nullptr;
-		r.depth_clear_value       = 0.0f;
+	BindRenderTarget(r.image_id);
-	}
-	if (r.vulkan_buffer->initial_stencil_clear_pending) {
-		r.stencil_clear_enable = true;
-		r.stencil_clear_value  = 0;
-	}
-	if (meta_clear && !cache.TouchMeta(z.htile_data_base_addr, z.depth_view.slice_start, false)) {
-		DepthFatal("failed to consume HTile clear state");
-	}
 }
 
-void MarkRenderTargetGpuWritten(const RenderDepthInfo& target) {
+vk::ImageAspectFlags RenderDepthInfo::AttachmentWriteAspects() const {
-	const bool with_depth =
+	if (format == vk::Format::eUndefined) {
-	    target.format != vk::Format::eUndefined && target.vulkan_buffer != nullptr;
+		return {};
-
-	if (with_depth && !depth_attachment_read_only(target)) {
-		GetRenderContext().GetTextureCache().MarkGpuWritten(*target.vulkan_buffer);
 	}
+
+	const auto           available = ImageViewOps::DepthAspectMask(format);
+	vk::ImageAspectFlags writes {};
+	if ((available & vk::ImageAspectFlagBits::eDepth) &&
+	    (depth_load_clear_enable || (depth_test_enable && depth_write_enable))) {
+		writes |= vk::ImageAspectFlagBits::eDepth;
+	}
+	if (!(available & vk::ImageAspectFlagBits::eStencil)) {
+		return writes;
+	}
+
+	const auto face_writes = [&](const PipelineStencilStaticState&  state,
+	                             const PipelineStencilDynamicState& dynamic) {
+		if (dynamic.writeMask == 0) {
+			return false;
+		}
+		bool can_pass = state.compareOp != vk::CompareOp::eNever;
+		bool can_fail = state.compareOp != vk::CompareOp::eAlways;
+		if (dynamic.compareMask == 0) {
+			switch (state.compareOp) {
+				case vk::CompareOp::eEqual:
+				case vk::CompareOp::eLessOrEqual:
+				case vk::CompareOp::eGreaterOrEqual:
+				case vk::CompareOp::eAlways:
+					can_pass = true;
+					can_fail = false;
+					break;
+				case vk::CompareOp::eNever:
+				case vk::CompareOp::eLess:
+				case vk::CompareOp::eGreater:
+				case vk::CompareOp::eNotEqual:
+					can_pass = false;
+					can_fail = true;
+					break;
+				default: break;
+			}
+		}
+		const bool depth_pass = !depth_test_enable || depth_compare_op != vk::CompareOp::eNever;
+		const bool depth_fail = depth_test_enable && depth_compare_op != vk::CompareOp::eAlways;
+		return (can_fail && state.failOp != vk::StencilOp::eKeep) ||
+		       (can_pass && depth_pass && state.passOp != vk::StencilOp::eKeep) ||
+		       (can_pass && depth_fail && state.depthFailOp != vk::StencilOp::eKeep);
+	};
+	if (stencil_clear_enable ||
+	    (stencil_test_enable && (face_writes(stencil_static_front, stencil_dynamic_front) ||
+	                             face_writes(stencil_static_back, stencil_dynamic_back)))) {
+		writes |= vk::ImageAspectFlagBits::eStencil;
+	}
+	return writes;
 }
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/depthRenderTarget.h

@@ -2,6 +2,8 @@
 #define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DEPTHRENDERTARGET_H_
 
 #include "common/assert.h"
+#include "graphics/host_gpu/renderer/cache/textureCache.h"
+#include "graphics/host_gpu/renderer/image/imageView.h"
 #include "graphics/host_gpu/renderer/renderTarget.h"
 #include "graphics/host_gpu/vulkanCommon.h"
 
@@ -10,14 +12,14 @@
 namespace Libs::Graphics {
 
 class RenderCommandBuffer;
-struct DepthStencilVulkanImage;
 
 inline constexpr bool depth_htile_stencil_acceleration_compatible(bool has_stencil, bool has_htile,
-                                                                  bool acceleration_disabled) {
+                                                                  bool htile_stencil_disabled) {
-	return acceleration_disabled || (has_stencil && has_htile);
+	return htile_stencil_disabled || (has_stencil && has_htile);
 }
 
 struct RenderDepthInfo {
+	TextureCache::ImageDesc     desc;
 	vk::Format                  format                   = vk::Format::eUndefined;
 	uint32_t                    width                    = 0;
 	uint32_t                    height                   = 0;
@@ -49,29 +51,46 @@ struct RenderDepthInfo {
 	PipelineStencilStaticState  stencil_static_back;
 	PipelineStencilDynamicState stencil_dynamic_front;
 	PipelineStencilDynamicState stencil_dynamic_back;
-	DepthStencilVulkanImage*    vulkan_buffer = nullptr;
+	ImageId                     image_id;
-	vk::ImageView               vulkan_view   = nullptr;
+	vk::ImageView               image_view = nullptr;
-	uint64_t                    vaddr[3]      = {};
+	uint64_t                    vaddr[3]   = {};
-	uint64_t                    size[3]       = {};
+	uint64_t                    size[3]    = {};
-	int                         vaddr_num     = 0;
+	int                         vaddr_num  = 0;
+
+	[[nodiscard]] vk::ImageAspectFlags AttachmentWriteAspects() const;
 };
 
 inline bool depth_attachment_read_only(const RenderDepthInfo& depth) {
-	const bool stencil_write =
+	return !depth.AttachmentWriteAspects();
-	    depth.stencil_test_enable &&
-	    (depth.stencil_dynamic_front.writeMask != 0 || depth.stencil_dynamic_back.writeMask != 0);
-	return !depth.depth_load_clear_enable && !depth.stencil_clear_enable &&
-	       !depth.depth_write_enable && !stencil_write;
 }
 
 inline vk::ImageLayout depth_attachment_layout(const RenderDepthInfo& depth) {
-	return depth_attachment_read_only(depth) ? vk::ImageLayout::eDepthStencilReadOnlyOptimal
+	const auto available     = ImageViewOps::DepthAspectMask(depth.format);
-	                                         : vk::ImageLayout::eDepthStencilAttachmentOptimal;
+	const auto writes        = depth.AttachmentWriteAspects();
+	const bool has_depth     = static_cast<bool>(available & vk::ImageAspectFlagBits::eDepth);
+	const bool has_stencil   = static_cast<bool>(available & vk::ImageAspectFlagBits::eStencil);
+	const bool depth_write   = static_cast<bool>(writes & vk::ImageAspectFlagBits::eDepth);
+	const bool stencil_write = static_cast<bool>(writes & vk::ImageAspectFlagBits::eStencil);
+	if (!has_stencil) {
+		return depth_write ? vk::ImageLayout::eDepthAttachmentOptimal
+		                   : vk::ImageLayout::eDepthReadOnlyOptimal;
+	}
+	if (!has_depth) {
+		return stencil_write ? vk::ImageLayout::eStencilAttachmentOptimal
+		                     : vk::ImageLayout::eStencilReadOnlyOptimal;
+	}
+	if (depth_write && stencil_write) {
+		return vk::ImageLayout::eDepthStencilAttachmentOptimal;
+	}
+	if (depth_write) {
+		return vk::ImageLayout::eDepthAttachmentStencilReadOnlyOptimal;
+	}
+	if (stencil_write) {
+		return vk::ImageLayout::eDepthReadOnlyStencilAttachmentOptimal;
+	}
+	return vk::ImageLayout::eDepthStencilReadOnlyOptimal;
 }
 
-void ResolveRenderDepthTarget(uint64_t submit_id, RenderCommandBuffer& buffer, RenderDepthInfo& r);
-void MarkRenderTargetGpuWritten(const RenderDepthInfo& target);
-
 } // namespace Libs::Graphics
 
 #endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DEPTHRENDERTARGET_H_

src/graphics/host_gpu/renderer/descriptors.cpp

@@ -1,854 +0,0 @@
-#include "graphics/host_gpu/renderer/descriptors.h"
-
-#include "common/assert.h"
-#include "common/common.h"
-#include "common/file.h"
-#include "common/logging/log.h"
-#include "common/profiler.h"
-#include "common/stringUtils.h"
-#include "common/threads.h"
-#include "graphics/guest_gpu/gpu_defs.h"
-#include "graphics/guest_gpu/gpu_format.h"
-#include "graphics/guest_gpu/graphicsRun.h"
-#include "graphics/guest_gpu/hardwareContext.h"
-#include "graphics/guest_gpu/tile.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/hostMemory.h"
-#include "graphics/host_gpu/objects/textureCommon.h"
-#include "graphics/host_gpu/renderer/debug.h"
-#include "graphics/host_gpu/renderer/descriptorCache.h"
-#include "graphics/host_gpu/renderer/framebufferCache.h"
-#include "graphics/host_gpu/renderer/imageView.h"
-#include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/renderer/renderTargetBarriers.h"
-#include "graphics/host_gpu/renderer/shaderResourceBarrier.h"
-#include "graphics/host_gpu/transfer.h"
-#include "graphics/host_gpu/vma.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-#include "graphics/presentation/displayBuffer.h"
-#include "graphics/shader/recompiler/BindingLayout.h"
-#include "graphics/shader/recompiler/ResourceMaterialization.h"
-#include "graphics/shader/recompiler/ShaderIR.h"
-#include "graphics/shader/shader.h"
-
-#include <algorithm>
-#include <atomic>
-#include <fmt/format.h>
-#include <limits>
-#include <span>
-
-#ifdef min
-#undef min
-#endif
-#ifdef max
-#undef max
-#endif
-
-namespace Libs::Graphics {
-
-using TextureVariant = DescriptorCache::TextureVariant;
-
-static void BindNullStorageBuffer(CommandBuffer& cmd_buffer, BufferView& dst) {
-	dst.buffer = &GetRenderContext().GetBufferCache().ObtainNullBuffer(cmd_buffer);
-	dst.offset = 0;
-	dst.range  = 16;
-}
-
-// NOLINTNEXTLINE(readability-function-cognitive-complexity)
-static const char* VulkanImageTypeName(VulkanImageType type) {
-	switch (type) {
-		case VulkanImageType::VideoOut: return "VideoOut";
-		case VulkanImageType::DepthStencil: return "DepthStencil";
-		case VulkanImageType::Texture: return "Texture";
-		case VulkanImageType::StorageTexture: return "StorageTexture";
-		case VulkanImageType::RenderTexture: return "RenderTexture";
-		case VulkanImageType::Unknown:
-		default: return "Unknown";
-	}
-}
-
-static int SampledArrayViewIndex(const VulkanImage& image, int view_index) {
-	switch (view_index) {
-		case VulkanImage::VIEW_DEFAULT: return VulkanImage::VIEW_DEFAULT_ARRAY;
-		default: return view_index;
-	}
-}
-
-static int SelectSampledTextureArrayView(const VulkanImage& image, int base_view) {
-	const int array_view = SampledArrayViewIndex(image, base_view);
-	if (image.image_view[array_view] == nullptr) {
-		EXIT("missing sampled array image view: image_type=%s base_view=%d array_view=%d "
-		     "layers=%u\n",
-		     VulkanImageTypeName(image.type), base_view, array_view, image.layers);
-	}
-	return array_view;
-}
-
-static bool TextureVariantIsUint(TextureVariant variant) {
-	return variant == TextureVariant::Uint2D || variant == TextureVariant::UintArray ||
-	       variant == TextureVariant::Uint3D;
-}
-
-static bool TextureVariantIsArray(TextureVariant variant) {
-	return variant == TextureVariant::FloatArray || variant == TextureVariant::UintArray;
-}
-
-static bool TextureVariantIs3D(TextureVariant variant) {
-	return variant == TextureVariant::Float3D || variant == TextureVariant::Uint3D;
-}
-
-static int TextureVariantDefaultView(TextureVariant variant) {
-	return TextureVariantIsArray(variant) ? VulkanImage::VIEW_DEFAULT_ARRAY
-	                                      : VulkanImage::VIEW_DEFAULT;
-}
-
-static VulkanImage& GetDummySampledTexture(TextureVariant variant) {
-	return GetRenderContext().GetTextureCache().GetDummySampledTexture(
-	    TextureVariantIsUint(variant), TextureVariantIs3D(variant));
-}
-
-static VulkanImage& GetDummyStorageTexture(TextureVariant variant) {
-	return GetRenderContext().GetTextureCache().GetDummyStorageTexture(
-	    TextureVariantIsUint(variant), TextureVariantIs3D(variant));
-}
-
-static void CopyNativeDescriptor(const ShaderRecompiler::IR::DescriptorValue& source,
-                                 std::span<uint32_t>                          destination) {
-	EXIT_IF(source.dword_count != destination.size());
-	std::copy_n(source.dwords.begin(), destination.size(), destination.begin());
-}
-
-static BufferView NativeStorageBuffer(uint64_t submit_id, CommandBuffer& command_buffer,
-                                      const ShaderBufferResource&                 descriptor,
-                                      const ShaderRecompiler::IR::BufferResource& resource) {
-	BufferView result;
-
-	const auto address = descriptor.Base48();
-	const auto stride  = descriptor.Stride();
-	const auto records = descriptor.NumRecords();
-	if (stride != 0 && records > UINT64_MAX / stride) {
-		EXIT("storage buffer descriptor footprint overflow\n");
-	}
-	const auto size = stride != 0 ? static_cast<uint64_t>(stride) * records : records;
-	if (address == 0 || size == 0) {
-		BindNullStorageBuffer(command_buffer, result);
-		return result;
-	}
-	const auto& graphics  = GetRenderContext().GetGraphics();
-	const auto  alignment = graphics.StorageMinAlignment();
-	if (alignment == 0 ||
-	    size > graphics.GetPhysicalDeviceProperties().limits.maxStorageBufferRange ||
-	    BufferCache::CACHING_PAGE_SIZE % alignment != 0) {
-		EXIT("storage buffer range or device alignment is unsupported\n");
-	}
-	(void)submit_id;
-	auto binding = GetRenderContext().GetBufferCache().ObtainBuffer(
-	    command_buffer, address, size, resource.written, resource.read, resource.formatted);
-	if (binding.offset % alignment != 0) {
-		EXIT("storage buffer binding is not device-aligned\n");
-	}
-	result.buffer = &binding.buffer;
-	result.offset = binding.offset;
-	result.range  = static_cast<vk::DeviceSize>(size);
-	return result;
-}
-
-static BufferView
-NativeAddressBuffer(uint64_t submit_id, CommandBuffer& command_buffer,
-                    const ShaderRecompiler::IR::AddressResource&           resource,
-                    const ShaderRecompiler::IR::ResourceSnapshot::Address& address) {
-	BufferView result;
-	if (address.binding_base == 0) {
-		BindNullStorageBuffer(command_buffer, result);
-		return result;
-	}
-	if (resource.written) {
-		EXIT("writable address resources are unsupported\n");
-	}
-	const auto limit  = resource.kind == ShaderRecompiler::IR::ResourceKind::Flat
-	                        ? ShaderRecompiler::IR::FlatAddressWindowSize
-	                        : static_cast<uint64_t>(GetRenderContext()
-	                                                    .GetGraphics()
-	                                                    .GetPhysicalDeviceProperties()
-	                                                    .limits.maxStorageBufferRange);
-	uint64_t   size   = 0;
-	const auto access = HostMemoryAccess::Mapped;
-	if (!HostMemoryQueryRange(address.binding_base, limit, access, size)) {
-		EXIT("address resource is not host-accessible: base=0x%016" PRIx64 "\n",
-		     address.binding_base);
-	}
-	const auto& graphics  = GetRenderContext().GetGraphics();
-	const auto  alignment = graphics.StorageMinAlignment();
-	if (alignment == 0 ||
-	    size > graphics.GetPhysicalDeviceProperties().limits.maxStorageBufferRange ||
-	    BufferCache::GetBufferOffset(address.binding_base) % alignment != 0) {
-		EXIT("address resource range or alignment is unsupported\n");
-	}
-	(void)submit_id;
-	auto binding  = GetRenderContext().GetBufferCache().ObtainBuffer(command_buffer,
-	                                                                 address.binding_base, size);
-	result.buffer = &binding.buffer;
-	result.offset = binding.offset;
-	result.range  = static_cast<vk::DeviceSize>(size);
-	return result;
-}
-
-static TextureVariant NativeTextureVariant(const ShaderRecompiler::IR::ImageResource& resource) {
-	const bool uint_image = resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint ||
-	                        resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint;
-	switch (resource.dimension) {
-		case ShaderRecompiler::Decoder::ImageDimension::Dim3D:
-			return uint_image ? TextureVariant::Uint3D : TextureVariant::Float3D;
-		case ShaderRecompiler::Decoder::ImageDimension::Dim2DArray:
-			return uint_image ? TextureVariant::UintArray : TextureVariant::FloatArray;
-		default: return uint_image ? TextureVariant::Uint2D : TextureVariant::Float2D;
-	}
-}
-
-static bool IsSupportedSampledColorResource(const ShaderRecompiler::IR::ImageResource& resource) {
-	bool supported_dimension = false;
-	switch (resource.dimension) {
-		case ShaderRecompiler::Decoder::ImageDimension::Dim2D:
-		case ShaderRecompiler::Decoder::ImageDimension::Dim2DArray:
-			supported_dimension = true;
-			break;
-		default: break;
-	}
-	const bool sampled_kind = resource.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-	                          resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint;
-	return sampled_kind && supported_dimension &&
-	       resource.mip_mode == ShaderRecompiler::IR::ImageMipMode::None && resource.read &&
-	       !resource.written && !resource.atomic && !resource.depth_compare;
-}
-
-TargetTextureViewInfo ResolveTargetTextureView(const ShaderRecompiler::IR::ImageResource& resource,
-                                               Prospero::ImageType type, uint32_t base_layer,
-                                               uint32_t image_layers) {
-	switch (type) {
-		case Prospero::ImageType::kColor2D:
-			return resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
-			               base_layer == 0 && image_layers == 1
-			           ? TargetTextureViewInfo {vk::ImageViewType::e2D, 0, 1}
-			           : TargetTextureViewInfo {};
-		case Prospero::ImageType::kCube:
-			if (resource.dimension != ShaderRecompiler::Decoder::ImageDimension::Dim2DArray ||
-			    base_layer >= image_layers || (image_layers - base_layer) % 6u != 0) {
-				return {};
-			}
-			return {vk::ImageViewType::e2DArray, base_layer, image_layers - base_layer};
-		case Prospero::ImageType::kColor2DArray:
-			if (resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
-			    base_layer == 0 && image_layers == 1) {
-				return {vk::ImageViewType::e2D, 0, 1};
-			}
-			return resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2DArray &&
-			               base_layer < image_layers
-			           ? TargetTextureViewInfo {vk::ImageViewType::e2DArray, base_layer,
-			                                    image_layers - base_layer}
-			           : TargetTextureViewInfo {};
-		default: return {};
-	}
-}
-
-bool IsSupportedSampledVideoOutView(const ShaderRecompiler::IR::ImageResource& resource,
-                                    const ShaderTextureResource&               descriptor,
-                                    const VulkanImage&                         image) {
-	return image.type == VulkanImageType::VideoOut && image.layers == 1 &&
-	       IsSupportedSampledColorResource(resource) &&
-	       resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
-	       descriptor.Type() == Prospero::GpuEnumValue(Prospero::ImageType::kColor2D) &&
-	       descriptor.Depth() == 0 && descriptor.BaseArray5() == 0;
-}
-
-bool IsSupportedDepthTargetDescriptor(const ShaderTextureResource& descriptor,
-                                      const VulkanImage&           image) {
-	const auto width  = static_cast<uint32_t>(descriptor.Width5()) + 1u;
-	const auto height = static_cast<uint32_t>(descriptor.Height5()) + 1u;
-	const auto pitch  = TileGetTexturePitch(descriptor.Format(), width, 1, descriptor.TileMode());
-	const auto type   = static_cast<Prospero::ImageType>(descriptor.Type());
-	const bool supported_single_layer =
-	    image.layers == 1 && descriptor.Depth() == 0 && descriptor.BaseArray5() == 0 &&
-	    (type == Prospero::ImageType::kColor2D || type == Prospero::ImageType::kColor2DArray);
-	const bool supported_cube = type == Prospero::ImageType::kCube && width == height &&
-	                            image.layers >= 6 && image.layers % 6u == 0 &&
-	                            static_cast<uint32_t>(descriptor.Depth()) + 1u == image.layers &&
-	                            descriptor.BaseArray5() == 0;
-	return image.type == VulkanImageType::DepthStencil && width == image.extent.width &&
-	       height == image.extent.height && (supported_single_layer || supported_cube) &&
-	       descriptor.BaseLevel() == 0 && descriptor.LastLevel() == 0 && descriptor.MaxMip() == 0 &&
-	       descriptor.MinLod() == 0 && descriptor.BaseArray5() == 0 &&
-	       descriptor.TileMode() == Prospero::GpuEnumValue(Prospero::TileMode::kDepth) &&
-	       descriptor.BCSwizzle() == 0 && !descriptor.MsaaDepth() && pitch >= width &&
-	       pitch == image.guest_pitch;
-}
-
-bool IsSupportedDepthTextureEncoding(const ShaderTextureResource& descriptor) {
-	constexpr uint32_t field1_reserved_mask = 0x200fff00u;
-	constexpr uint32_t field2_reserved_mask = 0xf0003000u;
-	constexpr uint32_t field3_common        = 0x01800000u;
-	constexpr uint32_t field5_expected      = 0x00700000u;
-	const uint32_t     field3_expected =
-	    (descriptor.Type() << 28u) | field3_common | descriptor.DstSelXYZW();
-	const uint32_t field4_expected = descriptor.Depth() | (descriptor.BaseArray5() << 16u);
-	return (descriptor.fields[1] & field1_reserved_mask) == 0 &&
-	       (descriptor.fields[2] & field2_reserved_mask) == 0 &&
-	       descriptor.fields[3] == field3_expected && descriptor.fields[4] == field4_expected &&
-	       descriptor.fields[5] == field5_expected && descriptor.fields[6] == 0 &&
-	       descriptor.fields[7] == 0;
-}
-
-static void ValidateDepthTargetBinding(const ShaderRecompiler::IR::ImageResource& resource,
-                                       const ShaderTextureResource&               descriptor,
-                                       const VulkanImage* image, vk::Format view_format,
-                                       uint64_t size) {
-	const bool resource_ok = IsSupportedSampledDepthResource(resource);
-	const bool descriptor_ok =
-	    image != nullptr && IsSupportedDepthTargetDescriptor(descriptor, *image);
-	const bool encoding_ok = IsSupportedDepthTextureEncoding(descriptor);
-	const bool format_ok   = image != nullptr && IsSupportedSampledDepthFormat(
-	                                                 image->format, descriptor.Format(), view_format);
-	if (resource_ok && descriptor_ok && encoding_ok && format_ok && size != 0) {
-		return;
-	}
-	const auto descriptor_pitch =
-	    TileGetTexturePitch(descriptor.Format(), static_cast<uint32_t>(descriptor.Width5()) + 1u, 1,
-	                        descriptor.TileMode());
-	EXIT("unsupported sampled depth target: resource=%d descriptor=%d encoding=%d format=%d "
-	     "kind=%u dimension=%u mip_mode=%u read=%d written=%d atomic=%d compare=%d "
-	     "guest_format=%u swizzle=0x%03x image_format=%d view_format=%d image_layers=%u "
-	     "descriptor_type=%u base_array=%u depth=%u descriptor_pitch=%u target_pitch=%u "
-	     "addr=0x%016" PRIx64 " size=0x%016" PRIx64
-	     " dwords=%08x,%08x,%08x,%08x,%08x,%08x,%08x,%08x\n",
-	     resource_ok, descriptor_ok, encoding_ok, format_ok, static_cast<uint32_t>(resource.kind),
-	     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
-	     resource.read, resource.written, resource.atomic, resource.depth_compare,
-	     descriptor.Format(), descriptor.DstSelXYZW(),
-	     image == nullptr ? static_cast<int>(vk::Format::eUndefined)
-	                      : static_cast<int>(image->format),
-	     static_cast<int>(view_format), image == nullptr ? 0u : image->layers, descriptor.Type(),
-	     descriptor.BaseArray5(), descriptor.Depth(), descriptor_pitch,
-	     image == nullptr ? 0u : image->guest_pitch, descriptor.Base40(), size,
-	     descriptor.fields[0], descriptor.fields[1], descriptor.fields[2], descriptor.fields[3],
-	     descriptor.fields[4], descriptor.fields[5], descriptor.fields[6], descriptor.fields[7]);
-}
-
-static bool IsSupportedStorageTextureDescriptor(const ShaderRecompiler::IR::ImageResource& resource,
-                                                const ShaderTextureResource& descriptor) {
-	const auto tile   = descriptor.TileMode();
-	const auto width  = static_cast<uint32_t>(descriptor.Width5()) + 1u;
-	const auto height = static_cast<uint32_t>(descriptor.Height5()) + 1u;
-	const auto depth  = static_cast<uint32_t>(descriptor.Depth()) + 1u;
-	const bool is_2d = resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
-	                   descriptor.Type() == Prospero::GpuEnumValue(Prospero::ImageType::kColor2D) &&
-	                   descriptor.Depth() == 0;
-	const bool is_2d_array =
-	    resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2DArray &&
-	    descriptor.Type() == Prospero::GpuEnumValue(Prospero::ImageType::kColor2DArray) &&
-	    descriptor.BaseArray5() <= descriptor.Depth();
-	const bool is_3d = resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim3D &&
-	                   descriptor.Type() == Prospero::GpuEnumValue(Prospero::ImageType::kColor3D);
-	const bool supported_depth_tile =
-	    tile == Prospero::GpuEnumValue(Prospero::TileMode::kDepth) && !resource.read &&
-	    resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint &&
-	    IsSupportedStorageDepthTile(descriptor.Format(), descriptor.Type(), width, height, depth);
-	const bool supported_tile = tile == Prospero::GpuEnumValue(Prospero::TileMode::kLinear) ||
-	                            tile == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget) ||
-	                            supported_depth_tile;
-	const bool supported_swizzle =
-	    IsSupportedStorageSwizzle(descriptor.Format(), descriptor.DstSelXYZW()) &&
-	    (descriptor.DstSelXYZW() == DstSel(4, 5, 6, 7) || !resource.read);
-	const bool supported_mip_view = descriptor.BaseLevel() == 0 || is_2d;
-	return (is_2d || is_2d_array || is_3d) && supported_tile && supported_mip_view &&
-	       descriptor.BaseLevel() == descriptor.LastLevel() &&
-	       descriptor.LastLevel() <= descriptor.MaxMip() && descriptor.MinLod() == 0 &&
-	       descriptor.BaseArray5() == 0 && supported_swizzle && descriptor.BCSwizzle() == 0 &&
-	       !descriptor.MsaaDepth();
-}
-
-static bool IsSupportedStorageTextureEncoding(const ShaderTextureResource& descriptor) {
-	constexpr uint32_t field1_reserved_mask = 0x200fff00u;
-	constexpr uint32_t field2_reserved_mask = 0xf0003000u;
-	constexpr uint32_t field5_expected      = 0x00700000u;
-	constexpr uint32_t field5_max_mip_mask  = 0x000000f0u;
-	const uint32_t     expected_field3 = descriptor.DstSelXYZW() |
-	                                     (static_cast<uint32_t>(descriptor.BaseLevel()) << 12u) |
-	                                     (static_cast<uint32_t>(descriptor.LastLevel()) << 16u) |
-	                                     (static_cast<uint32_t>(descriptor.TileMode()) << 20u) |
-	                                     (static_cast<uint32_t>(descriptor.Type()) << 28u);
-	return (descriptor.fields[1] & field1_reserved_mask) == 0 &&
-	       (descriptor.fields[2] & field2_reserved_mask) == 0 &&
-	       descriptor.fields[3] == expected_field3 && descriptor.fields[4] == descriptor.Depth() &&
-	       (descriptor.fields[5] & ~field5_max_mip_mask) == field5_expected &&
-	       descriptor.fields[6] == 0 && descriptor.fields[7] == 0;
-}
-
-void ValidateStorageTexture(const ShaderRecompiler::IR::ImageResource& resource,
-                            const ShaderTextureResource& descriptor, uint64_t size) {
-	const auto format        = descriptor.Format();
-	const bool resource_ok   = IsSupportedStorageImageResource(resource);
-	const bool descriptor_ok = IsSupportedStorageTextureDescriptor(resource, descriptor);
-	const bool encoding_ok   = IsSupportedStorageTextureEncoding(descriptor);
-	const bool uint_resource =
-	    resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint;
-	const bool format_ok = Prospero::IsSupportedTextureFormat(format) &&
-	                       uint_resource == Prospero::IsUintTextureFormat(format);
-	if (resource_ok && descriptor_ok && encoding_ok && format_ok && size != 0) {
-		return;
-	}
-	EXIT("unsupported storage texture: resource=%d descriptor=%d encoding=%d format=%d "
-	     "kind=%u dimension=%u mip_mode=%u atomic=%d compare=%d "
-	     "base_level=%u last_level=%u max_mip=%u min_lod=%u base_array=%u bc=%u msaa=%d "
-	     "depth_tile_shape=%d swizzle_ok=%d "
-	     "addr=0x%016" PRIx64 " size=0x%016" PRIx64
-	     " extent=%ux%ux%u type=%u format=%u tile=%u swizzle=0x%03x read=%d written=%d "
-	     "dwords=%08x,%08x,%08x,%08x,%08x,%08x,%08x,%08x\n",
-	     resource_ok, descriptor_ok, encoding_ok, format_ok, static_cast<uint32_t>(resource.kind),
-	     static_cast<uint32_t>(resource.dimension), static_cast<uint32_t>(resource.mip_mode),
-	     resource.atomic, resource.depth_compare, descriptor.BaseLevel(), descriptor.LastLevel(),
-	     descriptor.MaxMip(), descriptor.MinLod(), descriptor.BaseArray5(), descriptor.BCSwizzle(),
-	     descriptor.MsaaDepth(),
-	     IsSupportedStorageDepthTile(descriptor.Format(), descriptor.Type(),
-	                                 static_cast<uint32_t>(descriptor.Width5()) + 1u,
-	                                 static_cast<uint32_t>(descriptor.Height5()) + 1u,
-	                                 static_cast<uint32_t>(descriptor.Depth()) + 1u),
-	     IsSupportedStorageSwizzle(descriptor.Format(), descriptor.DstSelXYZW()),
-	     descriptor.Base40(), size, static_cast<uint32_t>(descriptor.Width5()) + 1u,
-	     static_cast<uint32_t>(descriptor.Height5()) + 1u,
-	     static_cast<uint32_t>(descriptor.Depth()) + 1u, descriptor.Type(), format,
-	     descriptor.TileMode(), descriptor.DstSelXYZW(), resource.read, resource.written,
-	     descriptor.fields[0], descriptor.fields[1], descriptor.fields[2], descriptor.fields[3],
-	     descriptor.fields[4], descriptor.fields[5], descriptor.fields[6], descriptor.fields[7]);
-}
-
-void ValidateMetadataReuseTexture(const ShaderRecompiler::IR::ImageResource& resource,
-                                  const ShaderTextureResource& descriptor, uint64_t size) {
-	constexpr uint32_t field1_reserved = 0x200fff00u;
-	constexpr uint32_t field2_reserved = 0xf0003000u;
-	constexpr uint32_t field5_common   = 0x00700000u;
-	const auto         format          = descriptor.Format();
-	const bool         resource_ok     = IsSupportedSampledColorResource(resource);
-	const bool         swizzle_ok      = IsValidSampledColorSwizzle(descriptor.DstSelXYZW());
-	const bool         descriptor_ok =
-	    resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
-	    descriptor.Type() == Prospero::GpuEnumValue(Prospero::ImageType::kColor2D) &&
-	    descriptor.Depth() == 0 && descriptor.BaseArray5() == 0 &&
-	    descriptor.BaseLevel() <= descriptor.LastLevel() &&
-	    descriptor.LastLevel() <= descriptor.MaxMip() && descriptor.MaxMip() < 15 &&
-	    descriptor.TileMode() == Prospero::GpuEnumValue(Prospero::TileMode::kStandard4KB) &&
-	    swizzle_ok;
-	const uint32_t field3_expected = descriptor.DstSelXYZW() |
-	                                 (static_cast<uint32_t>(descriptor.BaseLevel()) << 12u) |
-	                                 (static_cast<uint32_t>(descriptor.LastLevel()) << 16u) |
-	                                 (static_cast<uint32_t>(descriptor.TileMode()) << 20u) |
-	                                 (static_cast<uint32_t>(descriptor.Type()) << 28u);
-	const uint32_t field4_expected = descriptor.Depth() | (descriptor.BaseArray5() << 16u);
-	const uint32_t field5_expected =
-	    field5_common | (static_cast<uint32_t>(descriptor.MaxMip()) << 4u);
-	const bool encoding_ok =
-	    (descriptor.fields[1] & field1_reserved) == 0 &&
-	    (descriptor.fields[2] & field2_reserved) == 0 && descriptor.fields[3] == field3_expected &&
-	    descriptor.fields[4] == field4_expected && descriptor.fields[5] == field5_expected &&
-	    descriptor.fields[6] == 0 && descriptor.fields[7] == 0;
-	const bool format_ok =
-	    Prospero::IsSupportedTextureFormat(format) && !Prospero::IsUintTextureFormat(format);
-	if (!resource_ok || !descriptor_ok || !encoding_ok || !format_ok || size == 0) {
-		EXIT("unsupported metadata-reuse sampled texture: resource=%d descriptor=%d encoding=%d "
-		     "format=%d "
-		     "kind=%u dimension=%u mip_mode=%u read=%d written=%d atomic=%d compare=%d "
-		     "base_level=%u last_level=%u max_mip=%u base_array=%u swizzle_ok=%d "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64
-		     " extent=%ux%ux%u type=%u format=%u tile=%u swizzle=0x%03x "
-		     "dwords=%08x,%08x,%08x,%08x,%08x,%08x,%08x,%08x\n",
-		     resource_ok, descriptor_ok, encoding_ok, format_ok,
-		     static_cast<uint32_t>(resource.kind), static_cast<uint32_t>(resource.dimension),
-		     static_cast<uint32_t>(resource.mip_mode), resource.read, resource.written,
-		     resource.atomic, resource.depth_compare, descriptor.BaseLevel(),
-		     descriptor.LastLevel(), descriptor.MaxMip(), descriptor.BaseArray5(), swizzle_ok,
-		     descriptor.Base40(), size, static_cast<uint32_t>(descriptor.Width5()) + 1u,
-		     static_cast<uint32_t>(descriptor.Height5()) + 1u,
-		     static_cast<uint32_t>(descriptor.Depth()) + 1u, descriptor.Type(), format,
-		     descriptor.TileMode(), descriptor.DstSelXYZW(), descriptor.fields[0],
-		     descriptor.fields[1], descriptor.fields[2], descriptor.fields[3], descriptor.fields[4],
-		     descriptor.fields[5], descriptor.fields[6], descriptor.fields[7]);
-	}
-}
-
-static DescriptorCache::TextureBinding
-NativeTexture(uint64_t submit_id, CommandBuffer& command_buffer,
-              const ShaderRecompiler::IR::ImageResource&   resource,
-              const ShaderRecompiler::IR::DescriptorValue& value) {
-	ShaderTextureResource descriptor;
-	CopyNativeDescriptor(value, descriptor.fields);
-	const bool storage = resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImage ||
-	                     resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint;
-	const auto variant = NativeTextureVariant(resource);
-	if (storage) {
-		ValidateStorageImageResource(resource);
-	}
-	if (descriptor.IsNull()) {
-		return storage ? DescriptorCache::TextureBinding {&GetDummyStorageTexture(variant),
-		                                                  TextureVariantDefaultView(variant)}
-		               : DescriptorCache::TextureBinding {&GetDummySampledTexture(variant),
-		                                                  TextureVariantDefaultView(variant)};
-	}
-	const auto address    = descriptor.Base40();
-	const auto width      = static_cast<uint32_t>(descriptor.Width5()) + 1u;
-	const auto height     = static_cast<uint32_t>(descriptor.Height5()) + 1u;
-	const auto base_level = descriptor.BaseLevel();
-	const auto last_level = descriptor.LastLevel();
-	const auto levels     = static_cast<uint32_t>(descriptor.MaxMip()) + 1u;
-	if (base_level > last_level || last_level >= levels) {
-		EXIT("unsupported texture mip view: base=%u last=%u levels=%u\n", base_level, last_level,
-		     levels);
-	}
-	const auto view_levels = last_level - base_level + 1u;
-	const auto depth       = static_cast<uint32_t>(descriptor.Depth()) + 1u;
-	const auto tile        = descriptor.TileMode();
-	const auto format      = descriptor.Format();
-	const bool sampled_numeric_class =
-	    storage || ((resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint) ==
-	                Prospero::IsUintTextureFormat(format));
-	if (!storage &&
-	    (resource.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-	     resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint) &&
-	    !sampled_numeric_class) {
-		EXIT("sampled image numeric class mismatch: kind=%u format=%u addr=0x%016" PRIx64 "\n",
-		     static_cast<uint32_t>(resource.kind), format, address);
-	}
-	const auto view_format = TextureGetFormat(format);
-	const auto type        = static_cast<Prospero::ImageType>(descriptor.Type());
-	const auto target_view =
-	    ResolveTargetTextureView(resource, type, descriptor.BaseArray5(), depth);
-	const auto    pitch   = TileGetTexturePitch(format, width, levels, tile);
-	const auto    swizzle = descriptor.DstSelXYZW();
-	TileSizeAlign size;
-	TileGetTextureTotalSize(format, width, height, depth, pitch, levels, tile,
-	                        type == Prospero::ImageType::kColor3D, size);
-	EXIT_NOT_IMPLEMENTED(size.size == 0 ||
-	                     (address & (static_cast<uint64_t>(size.align) - 1u)) != 0);
-	if (storage) {
-		ValidateStorageTexture(resource, descriptor, size.size);
-		GetRenderContext().GetBufferCache().ValidateGpuAccess(address, size.size, resource.read,
-		                                                      resource.written);
-	}
-
-	VulkanImage*  image      = nullptr;
-	int           view       = VulkanImage::VIEW_DEFAULT;
-	vk::ImageView image_view = nullptr;
-	const bool check_depth = static_cast<Prospero::TileMode>(tile) == Prospero::TileMode::kDepth ||
-	                         descriptor.MsaaDepth();
-	if (image == nullptr) {
-		if (check_depth) {
-			image = GetRenderContext().GetTextureCache().FindDepthTargetByRange(
-			    command_buffer, address, size.size, true);
-		} else {
-			image = GetRenderContext().GetTextureCache().FindRenderTargetByRange(
-			    command_buffer, address, size.size);
-		}
-		if (image != nullptr) {
-			if (check_depth) {
-				const bool uint_reinterpret =
-				    IsSupportedSampledDepthUintResource(resource) &&
-				    IsSupportedDepthTargetDescriptor(descriptor, *image) &&
-				    IsSupportedDepthTextureEncoding(descriptor) &&
-				    IsDepthUintTextureReinterpretation(image->format, descriptor.Format(),
-				                                       view_format);
-				const bool uint_storage_reinterpret =
-				    storage && IsSupportedStorageImageResource(resource) &&
-				    IsSupportedStorageTextureDescriptor(resource, descriptor) &&
-				    IsSupportedStorageTextureEncoding(descriptor) &&
-				    IsDepthUintTextureReinterpretation(image->format, descriptor.Format(),
-				                                       view_format);
-				if (uint_reinterpret || uint_storage_reinterpret) {
-					image = nullptr;
-				} else {
-					const auto depth_view = ResolveTargetTextureView(
-					    resource, type, descriptor.BaseArray5(), image->layers);
-					ValidateDepthTargetBinding(resource, descriptor, image, view_format, size.size);
-					if (depth_view.type ==
-					    static_cast<vk::ImageViewType>(VK_IMAGE_VIEW_TYPE_MAX_ENUM)) {
-						EXIT("unsupported sampled depth target view: dimension=%u "
-						     "descriptor_type=%u "
-						     "base_array=%u image_layers=%u\n",
-						     static_cast<uint32_t>(resource.dimension), descriptor.Type(),
-						     descriptor.BaseArray5(), image->layers);
-					}
-					image_view = GetRenderContext().GetTextureCache().GetDepthTargetSampledView(
-					    *static_cast<DepthStencilVulkanImage*>(image), view_format, swizzle, 0, 1,
-					    depth_view.type, depth_view.base_layer, depth_view.layer_count);
-				}
-			} else {
-				if (!(storage ? IsSupportedStorageImageResource(resource)
-				              : IsSupportedSampledColorResource(resource)) ||
-				    image->type != VulkanImageType::RenderTexture || width != image->extent.width ||
-				    height != image->extent.height ||
-				    (storage ? levels != image->mip_levels || base_level != 0
-				             : levels != image->mip_levels || base_level >= levels) ||
-				    target_view.type ==
-				        static_cast<vk::ImageViewType>(VK_IMAGE_VIEW_TYPE_MAX_ENUM) ||
-				    target_view.base_layer >= image->layers ||
-				    target_view.layer_count > image->layers - target_view.base_layer) {
-					EXIT("unsupported cached render-target image view: storage=%d resource=%u "
-					     "dimension=%u"
-					     " image_type=%u layers=%u extent=%ux%u/%ux%u depth=%u"
-					     " levels=%u/%u base_level=%u base_array=%u descriptor_type=%u\n",
-					     storage, static_cast<uint32_t>(resource.kind),
-					     static_cast<uint32_t>(resource.dimension),
-					     static_cast<uint32_t>(image->type), image->layers, width, height,
-					     image->extent.width, image->extent.height, depth, levels,
-					     image->mip_levels, base_level, descriptor.BaseArray5(),
-					     static_cast<uint32_t>(type));
-				}
-				if (storage) {
-					view       = SelectStorageColorView(image->format, view_format, swizzle);
-					image_view = GetRenderContext().GetTextureCache().GetRenderTargetStorageView(
-					    *static_cast<RenderTextureVulkanImage*>(image), view_format, base_level,
-					    view_levels, target_view.type, target_view.base_layer,
-					    target_view.layer_count);
-				} else {
-					image_view = GetRenderContext().GetTextureCache().GetSampledColorView(
-					    *image, view_format, swizzle, base_level, view_levels, target_view.type,
-					    target_view.base_layer, target_view.layer_count);
-				}
-			}
-			if (image != nullptr && image_view == nullptr && image->image_view[view] == nullptr) {
-				EXIT("required cached texture image view is missing\n");
-			}
-			if (storage && image != nullptr) {
-				GetRenderContext().GetTextureCache().MarkGpuWritten(*image);
-			}
-		}
-	}
-	if (image == nullptr) {
-		const auto video = Presentation::DisplayBufferFind(address);
-		if (video.image != nullptr) {
-			if (storage) {
-				const bool exact =
-				    resource.kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint &&
-				    resource.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D &&
-				    !resource.read && resource.written && !resource.atomic &&
-				    format == Prospero::GpuEnumValue(Prospero::BufferFormat::k8_8_8_8UInt) &&
-				    view_format == vk::Format::eR8G8B8A8Uint && swizzle == DstSel(6, 5, 4, 7) &&
-				    width == video.image->extent.width && height == video.image->extent.height &&
-				    depth == 1 && levels == 1 && base_level == 0 && view_levels == 1 &&
-				    type == Prospero::ImageType::kColor2D && video.size == size.size &&
-				    video.pitch == pitch &&
-				    (video.image->format == vk::Format::eR8G8B8A8Srgb ||
-				     video.image->format == vk::Format::eB8G8R8A8Srgb) &&
-				    video.image->image_view[VulkanImage::VIEW_STORAGE] != nullptr;
-				if (!exact) {
-					EXIT("unsupported storage access to video-out surface: format=%u view=%d"
-					     " extent=%ux%u size=0x%016" PRIx64 " pitch=%u\n",
-					     format, static_cast<int>(view_format), width, height, size.size, pitch);
-				}
-				image = video.image;
-				view  = VulkanImage::VIEW_STORAGE;
-				GetRenderContext().GetTextureCache().MarkGpuWritten(*image);
-			} else {
-				const bool exact =
-				    IsSupportedSampledVideoOutView(resource, descriptor, *video.image) &&
-				    width == video.image->extent.width && height == video.image->extent.height &&
-				    levels == 1 && base_level == 0 && view_levels == 1 && video.size == size.size &&
-				    video.pitch == pitch;
-				if (!exact) {
-					EXIT("unsupported sampled access to video-out surface: resource=%u dimension=%u"
-					     " image_format=%d view_format=%d swizzle=0x%03x extent=%ux%u/%ux%u"
-					     " depth=%u levels=%u base=%u count=%u type=%u size=0x%016" PRIx64
-					     "/0x%016" PRIx64 " pitch=%u/%u\n",
-					     static_cast<uint32_t>(resource.kind),
-					     static_cast<uint32_t>(resource.dimension),
-					     static_cast<int>(video.image->format), static_cast<int>(view_format),
-					     swizzle, width, height, video.image->extent.width,
-					     video.image->extent.height, depth, levels, base_level, view_levels,
-					     static_cast<uint32_t>(type), size.size, video.size, pitch, video.pitch);
-				}
-				image      = video.image;
-				image_view = GetRenderContext().GetTextureCache().GetSampledColorView(
-				    *video.image, view_format, swizzle, 0, 1, vk::ImageViewType::e2D, 0, 1);
-			}
-		}
-	}
-	if (image == nullptr) {
-		auto&      texture_cache = GetRenderContext().GetTextureCache();
-		const bool metadata_read = texture_cache.QueryRegion(address, size.size).metadata_pages;
-		if (storage && metadata_read) {
-			EXIT("storage texture overlaps surface metadata\n");
-		}
-		if (!storage && metadata_read) {
-			ValidateMetadataReuseTexture(resource, descriptor, size.size);
-		}
-		(void)submit_id;
-		(void)command_buffer;
-		ImageInfo info {};
-		info.address     = address;
-		info.size        = size.size;
-		info.format      = format;
-		info.width       = width;
-		info.height      = height;
-		info.pitch       = pitch;
-		info.base_level  = base_level;
-		info.levels      = levels;
-		info.view_levels = view_levels;
-		info.tile        = tile;
-		info.swizzle     = swizzle;
-		info.depth       = depth;
-		info.type        = descriptor.Type();
-		info.base_array  = descriptor.BaseArray5();
-		if (storage) {
-			image      = &texture_cache.FindStorageTexture(command_buffer, info);
-			view       = VulkanImage::VIEW_DEFAULT;
-			image_view = texture_cache.GetStorageTextureStorageView(
-			    *static_cast<StorageTextureVulkanImage*>(image), base_level);
-		} else {
-			image = &texture_cache.FindTexture(command_buffer, info, metadata_read);
-			if (image->type == VulkanImageType::StorageTexture) {
-				image_view = texture_cache.GetStorageTextureSampledView(
-				    *static_cast<StorageTextureVulkanImage*>(image), info);
-			}
-		}
-	}
-	EXIT_NOT_IMPLEMENTED(image == nullptr);
-	if (NeedsStaticSampledArrayView(resource.dimension ==
-	                                    ShaderRecompiler::Decoder::ImageDimension::Dim2DArray,
-	                                image_view != nullptr)) {
-		view = SelectSampledTextureArrayView(*image, view);
-	}
-	return {image, view, image_view};
-}
-
-static vk::Sampler NativeSampler(const ShaderRecompiler::IR::Program& program, uint32_t index,
-                                 const ShaderRecompiler::IR::DescriptorValue& value) {
-	ShaderSamplerResource descriptor;
-	CopyNativeDescriptor(value, descriptor.fields);
-	const bool depth_compare = std::any_of(program.info.sampled_pairs.begin(),
-	                                       program.info.sampled_pairs.end(), [&](const auto& pair) {
-		                                       return pair.sampler == index &&
-		                                              pair.image < program.info.images.size() &&
-		                                              program.info.images[pair.image].depth_compare;
-	                                       });
-	if (!depth_compare) {
-		descriptor.fields[0] &= ~(0x7u << 12u);
-	}
-	return GetRenderContext().GetSamplerCache().GetSampler(descriptor);
-}
-
-static BufferView NativeUpload(CommandBuffer& command_buffer, std::span<const uint32_t> data) {
-	EXIT_IF(data.empty());
-	BufferView result;
-	EXIT_IF(!GetRenderContext().GetBufferCache().UploadHostData(
-	    command_buffer, data.data(), data.size_bytes(), 256, result.buffer, result.offset,
-	    result.range));
-	return result;
-}
-
-void BindDescriptors(uint64_t submit_id, CommandBuffer& buffer,
-                     vk::PipelineBindPoint pipeline_bind_point, vk::PipelineLayout layout,
-                     const ShaderStageRuntime& runtime, vk::ShaderStageFlags vk_stage,
-                     DescriptorCache::Stage stage) {
-	KYTY_PROFILER_FUNCTION();
-	EXIT_IF(!runtime);
-	const auto& program  = *runtime.program;
-	const auto& snapshot = *runtime.resources;
-	std::string error;
-	if (!ShaderRecompiler::IR::ValidateResourceSpecialization(program, snapshot, &error)) {
-		EXIT("invalid native shader runtime snapshot: %s\n", error.c_str());
-	}
-	auto       vk_buffer     = buffer.Handle();
-	const auto shader_stages = ShaderPipelineStages(vk_stage);
-
-	DescriptorCache::NativeDescriptors descriptors;
-	descriptors.buffers.reserve(program.info.buffers.size());
-	for (uint32_t i = 0; i < program.info.buffers.size(); i++) {
-		ShaderBufferResource descriptor;
-		CopyNativeDescriptor(snapshot.buffers[i], descriptor.fields);
-		descriptors.buffers.push_back(
-		    NativeStorageBuffer(submit_id, buffer, descriptor, program.info.buffers[i]));
-	}
-	descriptors.images.reserve(program.info.images.size());
-	for (uint32_t i = 0; i < program.info.images.size(); i++) {
-		const auto kind = program.info.images[i].kind;
-		if ((kind == ShaderRecompiler::IR::ResourceKind::StorageImage ||
-		     kind == ShaderRecompiler::IR::ResourceKind::StorageImageUint) &&
-		    vk_stage != vk::ShaderStageFlagBits::eCompute) {
-			EXIT("storage images are unsupported outside compute shaders\n");
-		}
-		descriptors.images.push_back(
-		    NativeTexture(submit_id, buffer, program.info.images[i], snapshot.images[i]));
-	}
-	descriptors.samplers.reserve(program.info.samplers.size());
-	for (uint32_t i = 0; i < program.info.samplers.size(); i++) {
-		descriptors.samplers.push_back(NativeSampler(program, i, snapshot.samplers[i]));
-	}
-	descriptors.addresses.reserve(program.info.addresses.size());
-	for (uint32_t i = 0; i < program.info.addresses.size(); i++) {
-		descriptors.addresses.push_back(NativeAddressBuffer(
-		    submit_id, buffer, program.info.addresses[i], snapshot.addresses[i]));
-	}
-	if (ShaderRecompiler::IR::FindBinding(
-	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::FlattenedSrt) !=
-	    nullptr) {
-		descriptors.flattened_srt = NativeUpload(buffer, snapshot.flattened_srt);
-	}
-
-	std::vector<uint32_t> user_data;
-	user_data.reserve(program.bindings.user_data_registers.size());
-	for (const auto reg: program.bindings.user_data_registers) {
-		user_data.push_back(snapshot.user_data[reg - program.user_data_base]);
-	}
-	if (ShaderRecompiler::IR::FindBinding(
-	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::UserData) != nullptr) {
-		descriptors.user_data = NativeUpload(buffer, user_data);
-	}
-	if (ShaderRecompiler::IR::FindBinding(
-	        program.bindings, ShaderRecompiler::IR::DescriptorBindingKind::Gds) != nullptr) {
-		descriptors.gds.buffer = &GetRenderContext().GetGdsBuffer().GetBuffer();
-		const auto barrier     = MakeGdsDependency(*descriptors.gds.buffer);
-		vk_buffer.pipelineBarrier(
-		    vk::PipelineStageFlagBits::eHost | vk::PipelineStageFlagBits::eTransfer |
-		        vk::PipelineStageFlagBits::eAllGraphics | vk::PipelineStageFlagBits::eComputeShader,
-		    shader_stages, vk::DependencyFlags {}, 0, nullptr, 1, &barrier, 0, nullptr);
-	}
-
-	for (uint32_t i = 0; i < program.info.images.size(); i++) {
-		auto*       image    = descriptors.images[i].image;
-		const auto& resource = program.info.images[i];
-		if (resource.kind == ShaderRecompiler::IR::ResourceKind::Image ||
-		    resource.kind == ShaderRecompiler::IR::ResourceKind::ImageUint) {
-			switch (image->type) {
-				case VulkanImageType::DepthStencil:
-					GraphicsRenderDepthStencilBarrier(vk_buffer, *image);
-					break;
-				case VulkanImageType::RenderTexture:
-				case VulkanImageType::StorageTexture:
-					GraphicsRenderTextureBarrier(vk_buffer, *image);
-					break;
-				case VulkanImageType::VideoOut:
-					GraphicsRenderColorImageBarrier(vk_buffer, *image, RENDER_COLOR_IMAGE_LAYOUT);
-					break;
-				default: break;
-			}
-		} else {
-			const auto barrier =
-			    MakeStorageImageDependency(*image, resource.read, resource.written);
-			vk_buffer.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands, shader_stages,
-			                          vk::DependencyFlags {}, 0, nullptr, 0, nullptr, 1, &barrier);
-			image->layout = vk::ImageLayout::eGeneral;
-		}
-	}
-
-	if (!program.bindings.descriptors.empty()) {
-		auto& set =
-		    GetRenderContext().GetDescriptorCache().GetDescriptor(stage, program, descriptors);
-		vk_buffer.bindDescriptorSets(pipeline_bind_point, layout, program.bindings.descriptor_set,
-		                             1, &set.set, 0, nullptr);
-		buffer.RecycleDescriptorAfterFence(set);
-	}
-	if (program.bindings.push_constant_size != 0) {
-		EXIT_IF(program.bindings.push_constant_size != user_data.size() * sizeof(uint32_t));
-		vk_buffer.pushConstants(layout, vk_stage, program.bindings.push_constant_offset,
-		                        program.bindings.push_constant_size, user_data.data());
-	}
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/dummyTextureCache.cpp

@@ -1,50 +0,0 @@
-#include "graphics/host_gpu/renderer/dummyTextureCache.h"
-
-#include "common/assert.h"
-#include "graphics/host_gpu/renderer/image.h"
-#include "graphics/host_gpu/transfer.h"
-
-#include <algorithm>
-
-namespace Libs::Graphics {
-
-namespace {
-
-[[nodiscard]] constexpr size_t DummyTextureIndex(bool uint_format, bool image_3d) noexcept {
-	return (image_3d ? 2u : 0u) + (uint_format ? 1u : 0u);
-}
-
-} // namespace
-
-DummyTextureCache::~DummyTextureCache() {
-	Common::LockGuard lock(m_mutex);
-	const auto        populated = [](const auto& slots) {
-		return std::ranges::any_of(slots, [](const auto& slot) { return slot.image != nullptr; });
-	};
-	if (!populated(m_sampled) && !populated(m_storage)) {
-		return;
-	}
-	Transfer::WaitForQueueIdle();
-	const auto destroy = [](auto& slots) {
-		for (auto& slot: slots) {
-			if (slot.image != nullptr) {
-				ImageOps::Destroy(*slot.image);
-				slot.image = nullptr;
-			}
-		}
-	};
-	destroy(m_sampled);
-	destroy(m_storage);
-}
-
-VulkanImage& DummyTextureCache::Get(Usage usage, bool uint_format, bool image_3d) {
-	Common::LockGuard lock(m_mutex);
-	auto&             slots = usage == Usage::Storage ? m_storage : m_sampled;
-	auto&             slot  = slots[DummyTextureIndex(uint_format, image_3d)];
-	if (slot.image == nullptr) {
-		slot.image = ImageOps::CreateDummyTexture(uint_format, image_3d, usage == Usage::Storage);
-	}
-	return *slot.image;
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/dummyTextureCache.h

@@ -1,35 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DUMMYTEXTURECACHE_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DUMMYTEXTURECACHE_H_
-
-#include "common/abi.h"
-#include "common/threads.h"
-#include "graphics/host_gpu/graphicContext.h"
-
-#include <array>
-#include <cstdint>
-
-namespace Libs::Graphics {
-
-class DummyTextureCache final {
-public:
-	enum class Usage : uint8_t { Sampled, Storage };
-
-	DummyTextureCache() = default;
-	~DummyTextureCache();
-	KYTY_CLASS_NO_COPY(DummyTextureCache);
-
-	[[nodiscard]] VulkanImage& Get(Usage usage, bool uint_format, bool image_3d);
-
-private:
-	struct Slot {
-		GpuTextureVulkanImage* image = nullptr;
-	};
-
-	Common::Mutex       m_mutex;
-	std::array<Slot, 4> m_sampled {};
-	std::array<Slot, 4> m_storage {};
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_DUMMYTEXTURECACHE_H_

src/graphics/host_gpu/renderer/framebufferCache.cpp

@@ -1,357 +0,0 @@
-#include "graphics/host_gpu/renderer/framebufferCache.h"
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/profiler.h"
-#include "graphics/host_gpu/renderer/colorRenderTarget.h"
-#include "graphics/host_gpu/renderer/depthRenderTarget.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <algorithm>
-#include <atomic>
-
-namespace Libs::Graphics {
-
-VulkanFramebuffer* FramebufferCache::CreateFramebuffer(RenderColorInfo* colors,
-                                                       uint32_t         requested_color_count,
-                                                       RenderDepthInfo& depth) {
-	KYTY_PROFILER_FUNCTION();
-
-	Common::LockGuard lock(m_mutex);
-
-	EXIT_IF(colors == nullptr);
-	EXIT_IF(requested_color_count > RENDER_COLOR_ATTACHMENTS_MAX);
-
-	bool with_depth = (depth.format != vk::Format::eUndefined && depth.vulkan_buffer != nullptr);
-	bool with_color[RENDER_COLOR_ATTACHMENTS_MAX] = {};
-	uint32_t     color_count                      = 0;
-	VulkanImage* first_color                      = nullptr;
-	vk::Extent2D first_color_extent               = {};
-	uint32_t     attachment_samples               = 0;
-	for (uint32_t i = 0; i < requested_color_count; i++) {
-		with_color[i] = (colors[i].vulkan_buffer != nullptr);
-		if (!with_color[i]) {
-			break;
-		}
-		if (first_color == nullptr) {
-			first_color        = colors[i].vulkan_buffer;
-			first_color_extent = colors[i].extent;
-			attachment_samples = colors[i].samples;
-		} else if (colors[i].extent.width != first_color_extent.width ||
-		           colors[i].extent.height != first_color_extent.height) {
-			LOGF("Framebuffer: temporary: dropping mismatched MRT%u attachment color0=%ux%u "
-			     "color%u=%ux%u\n",
-			     i, first_color_extent.width, first_color_extent.height, i, colors[i].extent.width,
-			     colors[i].extent.height);
-			with_color[i] = false;
-			break;
-		}
-		if (colors[i].samples != attachment_samples ||
-		    colors[i].vulkan_buffer->samples != colors[i].samples) {
-			EXIT("Framebuffer: mismatched color attachment samples at slot %u, expected=%u "
-			     "requested=%u image=%u\n",
-			     i, attachment_samples, colors[i].samples, colors[i].vulkan_buffer->samples);
-		}
-		color_count++;
-	}
-	if (with_depth) {
-		if (depth.samples != depth.vulkan_buffer->samples) {
-			EXIT("Framebuffer: depth attachment sample identity mismatch, requested=%u image=%u\n",
-			     depth.samples, depth.vulkan_buffer->samples);
-		}
-		if (attachment_samples == 0) {
-			attachment_samples = depth.samples;
-		} else if (attachment_samples != depth.samples) {
-			EXIT(
-			    "Framebuffer: mixed color/depth sample counts are unsupported, color=%u depth=%u\n",
-			    attachment_samples, depth.samples);
-		}
-	}
-	if (!with_depth && color_count == 0) {
-		LOGF("Framebuffer: warning: no color or depth attachment\n");
-		return nullptr;
-	}
-	if (vulkan_sample_count(attachment_samples) == vk::SampleCountFlagBits {}) {
-		EXIT("Framebuffer: invalid attachment sample count %u\n", attachment_samples);
-	}
-	vk::ImageLayout color_layout[RENDER_COLOR_ATTACHMENTS_MAX] = {};
-	for (auto& layout: color_layout) {
-		layout = RENDER_COLOR_IMAGE_LAYOUT;
-	}
-	auto depth_layout = (with_depth ? depth_attachment_layout(depth)
-	                                : vk::ImageLayout::eDepthStencilAttachmentOptimal);
-	auto depth_read_only =
-	    (with_depth && depth_layout == vk::ImageLayout::eDepthStencilReadOnlyOptimal);
-
-	if (with_depth && first_color != nullptr &&
-	    (first_color_extent.width != depth.vulkan_buffer->extent.width ||
-	     first_color_extent.height != depth.vulkan_buffer->extent.height)) {
-		static std::atomic<uint32_t> log_count {0};
-		if (log_count.fetch_add(1, std::memory_order_relaxed) < 16) {
-			LOGF("Framebuffer: temporary: dropping mismatched PS5 depth attachment color=%ux%u "
-			     "depth=%ux%u format=%s\n",
-			     first_color_extent.width, first_color_extent.height,
-			     depth.vulkan_buffer->extent.width, depth.vulkan_buffer->extent.height,
-			     VulkanToString(depth.format).c_str());
-		}
-		depth.format                   = vk::Format::eUndefined;
-		depth.vulkan_buffer            = nullptr;
-		depth.vulkan_view              = nullptr;
-		depth.depth_test_enable        = false;
-		depth.depth_write_enable       = false;
-		depth.depth_bounds_test_enable = false;
-		depth.stencil_test_enable      = false;
-		depth.depth_clear_enable       = false;
-		depth.depth_load_clear_enable  = false;
-		depth.stencil_clear_enable     = false;
-		with_depth                     = false;
-		depth_layout                   = vk::ImageLayout::eDepthStencilAttachmentOptimal;
-		depth_read_only                = false;
-	}
-
-	for (auto& f: m_framebuffers) {
-		bool color_match = (f.framebuffer != nullptr);
-		for (uint32_t i = 0; color_match && i < RENDER_COLOR_ATTACHMENTS_MAX; i++) {
-			const uint64_t image_id =
-			    (i < color_count && with_color[i] ? colors[i].vulkan_buffer->memory.unique_id : 0);
-			color_match =
-			    color_match && f.image_id[i] == image_id &&
-			    f.color_view[i] ==
-			        (i < color_count && with_color[i] ? colors[i].vulkan_view : nullptr) &&
-			    f.color_clear_enable[i] ==
-			        (i < color_count && with_color[i] && colors[i].color_clear_enable) &&
-			    f.color_layout[i] == color_layout[i];
-		}
-		if (color_match && f.depth_id == (with_depth ? depth.vulkan_buffer->memory.unique_id : 0) &&
-		    f.depth_view == (with_depth ? depth.vulkan_view : nullptr) &&
-		    f.depth_clear_enable == depth.depth_load_clear_enable &&
-		    f.stencil_clear_enable == depth.stencil_clear_enable &&
-		    f.depth_read_only == depth_read_only) {
-			return f.framebuffer;
-		}
-	}
-
-	EXIT_NOT_IMPLEMENTED(with_depth && first_color != nullptr &&
-	                     (first_color_extent.width != depth.vulkan_buffer->extent.width ||
-	                      first_color_extent.height != depth.vulkan_buffer->extent.height));
-
-	if (first_color == nullptr) {
-		first_color_extent = depth.vulkan_buffer->extent;
-	}
-
-	auto* framebuffer        = new VulkanFramebuffer;
-	framebuffer->render_pass = nullptr;
-	framebuffer->framebuffer = nullptr;
-	framebuffer->samples     = attachment_samples;
-	for (uint32_t i = 0; i < RENDER_COLOR_ATTACHMENTS_MAX; i++) {
-		framebuffer->color_layout[i] = color_layout[i];
-	}
-	framebuffer->depth_layout = depth_layout;
-
-	vk::AttachmentDescription attachments[RENDER_COLOR_ATTACHMENTS_MAX + 1] = {};
-	for (uint32_t i = 0; i < color_count; i++) {
-		attachments[i].flags         = {};
-		attachments[i].format        = colors[i].format;
-		attachments[i].samples       = vulkan_sample_count(attachment_samples);
-		attachments[i].loadOp        = (colors[i].color_clear_enable ? vk::AttachmentLoadOp::eClear
-		                                                             : vk::AttachmentLoadOp::eLoad);
-		attachments[i].storeOp       = vk::AttachmentStoreOp::eStore;
-		attachments[i].stencilLoadOp = vk::AttachmentLoadOp::eDontCare;
-		attachments[i].stencilStoreOp = vk::AttachmentStoreOp::eDontCare;
-		attachments[i].initialLayout  = color_layout[i];
-		attachments[i].finalLayout    = RENDER_COLOR_IMAGE_LAYOUT;
-	}
-
-	const uint32_t depth_attachment       = color_count;
-	attachments[depth_attachment].flags   = {};
-	attachments[depth_attachment].format  = depth.format;
-	attachments[depth_attachment].samples = vulkan_sample_count(attachment_samples);
-	attachments[depth_attachment].loadOp =
-	    (depth.depth_load_clear_enable ? vk::AttachmentLoadOp::eClear
-	                                   : vk::AttachmentLoadOp::eLoad);
-	attachments[depth_attachment].storeOp = vk::AttachmentStoreOp::eStore;
-	attachments[depth_attachment].stencilLoadOp =
-	    (depth.stencil_clear_enable ? vk::AttachmentLoadOp::eClear : vk::AttachmentLoadOp::eLoad);
-	attachments[depth_attachment].stencilStoreOp = vk::AttachmentStoreOp::eStore;
-	attachments[depth_attachment].initialLayout  = depth_layout;
-	attachments[depth_attachment].finalLayout    = depth_layout;
-
-	vk::AttachmentReference color_attachment_ref[RENDER_COLOR_ATTACHMENTS_MAX] = {};
-	for (uint32_t i = 0; i < RENDER_COLOR_ATTACHMENTS_MAX; i++) {
-		color_attachment_ref[i].attachment = (i < color_count ? i : VK_ATTACHMENT_UNUSED);
-		color_attachment_ref[i].layout     = RENDER_COLOR_IMAGE_LAYOUT;
-	}
-
-	vk::AttachmentReference depth_attachment_ref {};
-	depth_attachment_ref.attachment = depth_attachment;
-	depth_attachment_ref.layout     = depth_layout;
-
-	vk::SubpassDescription subpass {};
-	subpass.flags                   = {};
-	subpass.pipelineBindPoint       = vk::PipelineBindPoint::eGraphics;
-	subpass.inputAttachmentCount    = 0;
-	subpass.pInputAttachments       = nullptr;
-	subpass.colorAttachmentCount    = color_count;
-	subpass.pColorAttachments       = (color_count > 0 ? color_attachment_ref : nullptr);
-	subpass.pResolveAttachments     = nullptr;
-	subpass.pDepthStencilAttachment = (with_depth ? &depth_attachment_ref : nullptr);
-	subpass.preserveAttachmentCount = 0;
-	subpass.pPreserveAttachments    = nullptr;
-
-	const auto attachment_stage_mask =
-	    static_cast<vk::PipelineStageFlags>(vk::PipelineStageFlagBits::eColorAttachmentOutput |
-	                                        vk::PipelineStageFlagBits::eEarlyFragmentTests |
-	                                        vk::PipelineStageFlagBits::eLateFragmentTests);
-	const auto attachment_access_mask = static_cast<vk::AccessFlags>(
-	    vk::AccessFlagBits::eColorAttachmentRead | vk::AccessFlagBits::eColorAttachmentWrite |
-	    vk::AccessFlagBits::eDepthStencilAttachmentRead |
-	    vk::AccessFlagBits::eDepthStencilAttachmentWrite);
-
-	vk::SubpassDependency dependencies[2] = {};
-	dependencies[0].srcSubpass            = VK_SUBPASS_EXTERNAL;
-	dependencies[0].dstSubpass            = 0;
-	dependencies[0].srcStageMask          = vk::PipelineStageFlagBits::eAllCommands;
-	dependencies[0].dstStageMask          = attachment_stage_mask;
-	dependencies[0].srcAccessMask =
-	    vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
-	dependencies[0].dstAccessMask   = attachment_access_mask;
-	dependencies[0].dependencyFlags = vk::DependencyFlagBits::eByRegion;
-
-	dependencies[1].srcSubpass    = 0;
-	dependencies[1].dstSubpass    = VK_SUBPASS_EXTERNAL;
-	dependencies[1].srcStageMask  = attachment_stage_mask;
-	dependencies[1].dstStageMask  = vk::PipelineStageFlagBits::eAllCommands;
-	dependencies[1].srcAccessMask = attachment_access_mask;
-	dependencies[1].dstAccessMask =
-	    vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite;
-	dependencies[1].dependencyFlags = vk::DependencyFlagBits::eByRegion;
-
-	vk::RenderPassCreateInfo render_pass_info {};
-	render_pass_info.sType           = vk::StructureType::eRenderPassCreateInfo;
-	render_pass_info.pNext           = nullptr;
-	render_pass_info.flags           = {};
-	render_pass_info.attachmentCount = color_count + (with_depth ? 1u : 0u);
-	render_pass_info.pAttachments    = attachments;
-	render_pass_info.subpassCount    = 1;
-	render_pass_info.pSubpasses      = &subpass;
-	render_pass_info.dependencyCount = 2;
-	render_pass_info.pDependencies   = dependencies;
-
-	auto result =
-	    m_graphics.device.createRenderPass(&render_pass_info, nullptr, &framebuffer->render_pass);
-	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
-
-	vk::Format color_formats[RENDER_COLOR_ATTACHMENTS_MAX] = {};
-	for (uint32_t i = 0; i < color_count; i++) {
-		color_formats[i] = colors[i].format;
-	}
-	framebuffer->render_pass_id = render_pass_compat_id(
-	    color_count, color_formats, with_depth, depth.format, depth_layout, attachment_samples);
-
-	EXIT_NOT_IMPLEMENTED(framebuffer->render_pass == nullptr);
-
-	vk::ImageView views[RENDER_COLOR_ATTACHMENTS_MAX + 1] = {};
-	for (uint32_t i = 0; i < color_count; i++) {
-		if (colors[i].vulkan_view == nullptr) {
-			EXIT("Framebuffer: color attachment view is missing at slot %u\n", i);
-		}
-		views[i] = colors[i].vulkan_view;
-	}
-	if (with_depth) {
-		if (depth.vulkan_view == nullptr) {
-			EXIT("Framebuffer: depth attachment view is missing\n");
-		}
-		views[color_count] = depth.vulkan_view;
-	}
-
-	vk::FramebufferCreateInfo framebuffer_info {};
-	framebuffer_info.sType           = vk::StructureType::eFramebufferCreateInfo;
-	framebuffer_info.pNext           = nullptr;
-	framebuffer_info.flags           = {};
-	framebuffer_info.renderPass      = framebuffer->render_pass;
-	framebuffer_info.attachmentCount = color_count + (with_depth ? 1u : 0u);
-	framebuffer_info.pAttachments    = views;
-	framebuffer_info.width           = first_color_extent.width;
-	framebuffer_info.height          = first_color_extent.height;
-	framebuffer_info.layers          = 1;
-
-	result =
-	    m_graphics.device.createFramebuffer(&framebuffer_info, nullptr, &framebuffer->framebuffer);
-	EXIT_NOT_IMPLEMENTED(result != vk::Result::eSuccess);
-
-	EXIT_NOT_IMPLEMENTED(framebuffer->framebuffer == nullptr);
-
-	Framebuffer fnew;
-	fnew.framebuffer = framebuffer;
-	for (uint32_t i = 0; i < RENDER_COLOR_ATTACHMENTS_MAX; i++) {
-		fnew.image_id[i] =
-		    (i < color_count && with_color[i] ? colors[i].vulkan_buffer->memory.unique_id : 0);
-		fnew.color_view[i] = (i < color_count && with_color[i] ? colors[i].vulkan_view : nullptr);
-		fnew.color_clear_enable[i] =
-		    (i < color_count && with_color[i] && colors[i].color_clear_enable);
-		fnew.color_layout[i] = color_layout[i];
-	}
-	fnew.depth_id             = (with_depth ? depth.vulkan_buffer->memory.unique_id : 0);
-	fnew.depth_view           = (with_depth ? depth.vulkan_view : nullptr);
-	fnew.depth_clear_enable   = depth.depth_load_clear_enable;
-	fnew.stencil_clear_enable = depth.stencil_clear_enable;
-	fnew.depth_read_only      = depth_read_only;
-
-	bool updated = false;
-
-	for (auto& f: m_framebuffers) {
-		if (f.framebuffer == nullptr) {
-			f       = fnew;
-			updated = true;
-			break;
-		}
-	}
-
-	if (!updated) {
-		m_framebuffers.push_back(fnew);
-	}
-
-	return framebuffer;
-}
-
-void FramebufferCache::FreeFramebufferByColor(VulkanImage& image) {
-	Common::LockGuard lock(m_mutex);
-
-	for (auto& f: m_framebuffers) {
-		bool uses_image = false;
-		for (auto image_id: f.image_id) {
-			if (image_id == image.memory.unique_id) {
-				uses_image = true;
-				break;
-			}
-		}
-		if (f.framebuffer != nullptr && uses_image) {
-			m_graphics.device.destroyFramebuffer(f.framebuffer->framebuffer, nullptr);
-
-			m_graphics.device.destroyRenderPass(f.framebuffer->render_pass, nullptr);
-
-			delete f.framebuffer;
-
-			f.framebuffer = nullptr;
-		}
-	}
-}
-
-void FramebufferCache::FreeFramebufferByDepth(DepthStencilVulkanImage& image) {
-	Common::LockGuard lock(m_mutex);
-
-	for (auto& f: m_framebuffers) {
-		if (f.framebuffer != nullptr && f.depth_id == image.memory.unique_id) {
-			m_graphics.device.destroyFramebuffer(f.framebuffer->framebuffer, nullptr);
-
-			m_graphics.device.destroyRenderPass(f.framebuffer->render_pass, nullptr);
-
-			delete f.framebuffer;
-
-			f.framebuffer = nullptr;
-		}
-	}
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/framebufferCache.h

@@ -1,85 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_FRAMEBUFFERCACHE_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_FRAMEBUFFERCACHE_H_
-
-#include "common/abi.h"
-#include "common/assert.h"
-#include "common/common.h"
-#include "common/threads.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/renderer/renderTarget.h"
-#include "graphics/host_gpu/vulkanCommon.h"
-
-#include <vector>
-
-namespace Libs::Graphics {
-
-struct RenderColorInfo;
-struct RenderDepthInfo;
-
-static constexpr vk::ImageLayout RENDER_COLOR_IMAGE_LAYOUT = vk::ImageLayout::eGeneral;
-
-struct VulkanFramebuffer {
-	vk::RenderPass  render_pass                                = nullptr;
-	uint64_t        render_pass_id                             = 0;
-	vk::Framebuffer framebuffer                                = nullptr;
-	uint32_t        samples                                    = 1;
-	vk::ImageLayout color_layout[RENDER_COLOR_ATTACHMENTS_MAX] = {};
-	vk::ImageLayout depth_layout = vk::ImageLayout::eDepthStencilAttachmentOptimal;
-};
-
-inline uint64_t render_pass_compat_id(uint32_t color_count, const vk::Format* color_formats,
-                                      bool with_depth, vk::Format depth_format,
-                                      vk::ImageLayout depth_layout, uint32_t samples) {
-	uint64_t id  = 0xcbf29ce484222325ull;
-	auto     mix = [&id](uint64_t v) {
-		id ^= v;
-		id *= 0x100000001b3ull;
-	};
-
-	mix(color_count);
-	for (uint32_t i = 0; i < color_count; i++) {
-		mix(static_cast<uint32_t>(color_formats[i]));
-	}
-	mix(with_depth ? 1u : 0u);
-	mix(static_cast<uint32_t>(depth_format));
-	mix(static_cast<uint32_t>(depth_layout));
-	mix(samples);
-
-	return id;
-}
-
-class FramebufferCache {
-public:
-	explicit FramebufferCache(GraphicContext& graphics): m_graphics(graphics) {
-		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
-	}
-	~FramebufferCache() { KYTY_NOT_IMPLEMENTED; }
-	KYTY_CLASS_NO_COPY(FramebufferCache);
-
-	VulkanFramebuffer* CreateFramebuffer(RenderColorInfo* colors, uint32_t color_count,
-	                                     RenderDepthInfo& depth);
-	void               FreeFramebufferByColor(VulkanImage& image);
-	void               FreeFramebufferByDepth(DepthStencilVulkanImage& image);
-
-private:
-	struct Framebuffer {
-		VulkanFramebuffer* framebuffer                                      = nullptr;
-		uint64_t           image_id[RENDER_COLOR_ATTACHMENTS_MAX]           = {};
-		vk::ImageView      color_view[RENDER_COLOR_ATTACHMENTS_MAX]         = {};
-		uint64_t           depth_id                                         = 0;
-		vk::ImageView      depth_view                                       = nullptr;
-		bool               color_clear_enable[RENDER_COLOR_ATTACHMENTS_MAX] = {};
-		vk::ImageLayout    color_layout[RENDER_COLOR_ATTACHMENTS_MAX]       = {};
-		bool               depth_clear_enable                               = false;
-		bool               stencil_clear_enable                             = false;
-		bool               depth_read_only                                  = false;
-	};
-
-	GraphicContext&          m_graphics;
-	Common::Mutex            m_mutex;
-	std::vector<Framebuffer> m_framebuffers;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_FRAMEBUFFERCACHE_H_

src/graphics/host_gpu/renderer/gdsBuffer.cpp

@@ -1,67 +0,0 @@
-#include "graphics/host_gpu/renderer/gdsBuffer.h"
-
-#include "common/assert.h"
-#include "graphics/host_gpu/transfer.h"
-#include "graphics/host_gpu/vma.h"
-
-namespace Libs::Graphics {
-
-void GdsBuffer::Init() {
-	if (m_buffer == nullptr) {
-		m_buffer = std::make_unique<VulkanBuffer>();
-
-		m_buffer->usage           = vk::BufferUsageFlagBits::eStorageBuffer;
-		m_buffer->memory.property = vk::MemoryPropertyFlagBits::eHostVisible |
-		                            vk::MemoryPropertyFlagBits::eHostCoherent |
-		                            vk::MemoryPropertyFlagBits::eHostCached;
-		m_graphics.CreateBuffer(DW_SIZE * 4, *m_buffer);
-	}
-}
-
-void GdsBuffer::Clear(uint64_t dw_offset, uint32_t dw_num, uint32_t clear_value) {
-	Common::LockGuard lock(m_mutex);
-
-	Init();
-
-	EXIT_NOT_IMPLEMENTED(dw_offset >= DW_SIZE);
-	EXIT_NOT_IMPLEMENTED(dw_offset + dw_num > DW_SIZE);
-
-	void* data = nullptr;
-	m_graphics.MapMemory(m_buffer->memory, data);
-
-	for (uint32_t i = 0; i < dw_num; i++) {
-		static_cast<uint32_t*>(data)[dw_offset + i] = clear_value;
-	}
-
-	m_graphics.UnmapMemory(m_buffer->memory);
-}
-
-void GdsBuffer::Read(uint32_t* dst, uint32_t dw_offset, uint32_t dw_size) {
-	EXIT_IF(dst == nullptr);
-
-	Common::LockGuard lock(m_mutex);
-
-	Init();
-
-	EXIT_NOT_IMPLEMENTED(dw_offset >= DW_SIZE);
-	EXIT_NOT_IMPLEMENTED(dw_offset + dw_size > DW_SIZE);
-
-	void* data = nullptr;
-	m_graphics.MapMemory(m_buffer->memory, data);
-
-	for (uint32_t i = 0; i < dw_size; i++) {
-		dst[i] = static_cast<uint32_t*>(data)[dw_offset + i];
-	}
-
-	m_graphics.UnmapMemory(m_buffer->memory);
-}
-
-VulkanBuffer& GdsBuffer::GetBuffer() {
-	Common::LockGuard lock(m_mutex);
-
-	Init();
-
-	return *m_buffer;
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/gdsBuffer.h

@@ -1,39 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GDSBUFFER_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GDSBUFFER_H_
-
-#include "common/abi.h"
-#include "common/assert.h"
-#include "common/common.h"
-#include "common/threads.h"
-#include "graphics/host_gpu/graphicContext.h"
-
-#include <memory>
-
-namespace Libs::Graphics {
-
-class GdsBuffer {
-public:
-	explicit GdsBuffer(GraphicContext& graphics): m_graphics(graphics) {
-		EXIT_NOT_IMPLEMENTED(!Common::Thread::IsMainThread());
-	}
-	~GdsBuffer() { KYTY_NOT_IMPLEMENTED; }
-	KYTY_CLASS_NO_COPY(GdsBuffer);
-
-	void Clear(uint64_t dw_offset, uint32_t dw_num, uint32_t clear_value);
-	void Read(uint32_t* dst, uint32_t dw_offset, uint32_t dw_size);
-
-	VulkanBuffer& GetBuffer();
-
-private:
-	static constexpr uint64_t DW_SIZE = 0x3000;
-
-	void Init();
-
-	GraphicContext&               m_graphics;
-	Common::Mutex                 m_mutex;
-	std::unique_ptr<VulkanBuffer> m_buffer;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GDSBUFFER_H_

src/graphics/host_gpu/renderer/gpuResourceManager.cpp

@@ -1,133 +0,0 @@
-#include "graphics/host_gpu/renderer/gpuResourceManager.h"
-
-#include "common/assert.h"
-#include "graphics/guest_gpu/command_processor/commandProcessor.h"
-#include "graphics/guest_gpu/graphicsRun.h"
-#include "graphics/host_gpu/objects/label.h"
-#include "graphics/host_gpu/renderer/render.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-
-namespace Libs::Graphics {
-
-GpuResourceManager::GpuResourceManager(GraphicContext& graphics)
-    : m_page_manager(FaultThunk, this), m_buffer_cache(graphics, m_page_manager, m_resource_mutex),
-      m_texture_cache(graphics, m_page_manager, m_buffer_cache, m_resource_mutex) {
-	m_buffer_cache.SetTextureCache(m_texture_cache);
-}
-
-GpuResourceManager::~GpuResourceManager() = default;
-
-bool GpuResourceManager::FaultThunk(void* context, PageFaultAccess access, uint64_t vaddr,
-                                    uint64_t size, PageFaultPhase phase) noexcept {
-	return static_cast<GpuResourceManager*>(context)->InvalidateMemory(access, vaddr, size, phase);
-}
-
-bool GpuResourceManager::InvalidateMemory(PageFaultAccess access, uint64_t vaddr, uint64_t size,
-                                          PageFaultPhase phase) noexcept {
-	const bool buffer_handled = m_buffer_cache.InvalidateMemory(access, vaddr, size, phase);
-	const bool image_handled  = m_texture_cache.InvalidateMemory(access, vaddr, size, phase);
-	return buffer_handled || image_handled;
-}
-
-bool GpuResourceManager::HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept {
-	if (!m_page_manager.IsMapped(fault_vaddr, 1)) {
-		return false;
-	}
-	if (LabelInCallback()) {
-		EXIT("unsupported guest-memory fault from an asynchronous GPU label callback, "
-		     "addr=0x%016" PRIx64 " access=%u\n",
-		     fault_vaddr, static_cast<uint32_t>(access));
-	}
-	if (auto* cp = GraphicsRunCurrentCommandProcessor(); cp != nullptr) {
-		cp->BeginReadbackTransaction();
-		bool handled = false;
-		{
-			ResourceMutex::FaultScope fault(m_resource_mutex);
-			handled = m_page_manager.HandleFault(access, fault_vaddr);
-		}
-		cp->EndReadbackTransaction();
-		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));
-	}
-	// Stop command-processor jobs before taking the shared cache transaction. External readback
-	// workers inherit this paused state and therefore never form resource -> submission lock
-	// inversion.
-	GraphicsRunSubmissionLock submissions;
-	ResourceMutex::FaultScope fault(m_resource_mutex);
-	return m_page_manager.HandleFault(access, fault_vaddr);
-}
-
-void GpuResourceManager::PrepareHostWrite(uint64_t vaddr, uint64_t size) {
-	if (!m_page_manager.HasAnyMapping(vaddr, size)) {
-		return;
-	}
-	if (LabelInCallback()) {
-		EXIT("unsupported host write from an asynchronous GPU label callback, addr=0x%016" PRIx64
-		     " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	const auto handle_range = [this, vaddr, size]() {
-		if (!m_page_manager.HandleWriteRange(vaddr, size)) {
-			EXIT("failed to prepare host write, addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-			     vaddr, size);
-		}
-	};
-	if (auto* cp = GraphicsRunCurrentCommandProcessor(); cp != nullptr) {
-		cp->BeginReadbackTransaction();
-		{
-			ResourceMutex::FaultScope fault(m_resource_mutex);
-			handle_range();
-		}
-		cp->EndReadbackTransaction();
-		return;
-	}
-	if (m_resource_mutex.IsOwnedByCurrentThread()) {
-		EXIT("unsupported host write from a pre-owned resource transaction, addr=0x%016" PRIx64
-		     " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	GraphicsRunSubmissionLock submissions;
-	ResourceMutex::FaultScope fault(m_resource_mutex);
-	handle_range();
-}
-
-bool GpuResourceManager::IsMapped(uint64_t vaddr, uint64_t size) const noexcept {
-	return m_page_manager.IsMapped(vaddr, size);
-}
-
-void GpuResourceManager::MapMemory(uint64_t vaddr, uint64_t size, GpuAccess access) {
-	m_page_manager.OnGpuMap(vaddr, size, access);
-}
-
-void GpuResourceManager::UnmapMemory(uint64_t vaddr, uint64_t size, GpuAccess access) {
-	if (!IsMapped(vaddr, size)) {
-		EXIT("cannot unmap an unmapped GPU resource range\n");
-	}
-	m_texture_cache.UnmapMemory(vaddr, size);
-	m_buffer_cache.UnmapMemory(vaddr, size);
-	m_page_manager.OnGpuUnmap(vaddr, size, access);
-}
-
-void GpuResourceManager::FillBuffer(CommandBuffer& command, uint64_t vaddr, uint64_t size,
-                                    uint32_t value) {
-	if (command.IsInvalid()) {
-		EXIT("cannot fill a buffer without a valid render command context\n");
-	}
-	Common::LockGuard lock(GetRenderContext().GetMutex());
-	m_buffer_cache.FillBuffer(&command, vaddr, size, value);
-}
-
-void GpuResourceManager::CopyBuffer(CommandBuffer& command, uint64_t dst_vaddr, uint64_t src_vaddr,
-                                    uint64_t size) {
-	if (command.IsInvalid()) {
-		EXIT("cannot copy a buffer without a valid render command context\n");
-	}
-	Common::LockGuard lock(GetRenderContext().GetMutex());
-	m_buffer_cache.CopyBuffer(&command, dst_vaddr, src_vaddr, size);
-}
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/gpuResourceManager.h

@@ -1,48 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GPURESOURCEMANAGER_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GPURESOURCEMANAGER_H_
-
-#include "common/abi.h"
-#include "common/common.h"
-#include "graphics/host_gpu/pageManager.h"
-#include "graphics/host_gpu/renderer/bufferCache.h"
-#include "graphics/host_gpu/renderer/resourceMutex.h"
-#include "graphics/host_gpu/renderer/textureCache.h"
-
-#include <cstdint>
-
-namespace Libs::Graphics {
-
-class CommandBuffer;
-
-class GpuResourceManager {
-public:
-	explicit GpuResourceManager(GraphicContext& graphics);
-	~GpuResourceManager();
-	KYTY_CLASS_NO_COPY(GpuResourceManager);
-
-	[[nodiscard]] BufferCache&  GetBufferCache() { return m_buffer_cache; }
-	[[nodiscard]] TextureCache& GetTextureCache() { return m_texture_cache; }
-
-	[[nodiscard]] bool HandleFault(PageFaultAccess access, uint64_t fault_vaddr) noexcept;
-	void               PrepareHostWrite(uint64_t vaddr, uint64_t size);
-	[[nodiscard]] bool IsMapped(uint64_t vaddr, uint64_t size) const noexcept;
-	void               MapMemory(uint64_t vaddr, uint64_t size, GpuAccess access);
-	void               UnmapMemory(uint64_t vaddr, uint64_t size, GpuAccess access);
-	void FillBuffer(CommandBuffer& command, uint64_t vaddr, uint64_t size, uint32_t value);
-	void CopyBuffer(CommandBuffer& command, uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t size);
-
-private:
-	static bool FaultThunk(void* context, PageFaultAccess access, uint64_t vaddr, uint64_t size,
-	                       PageFaultPhase phase) noexcept;
-	[[nodiscard]] bool InvalidateMemory(PageFaultAccess access, uint64_t vaddr, uint64_t size,
-	                                    PageFaultPhase phase) noexcept;
-
-	PageManager   m_page_manager;
-	ResourceMutex m_resource_mutex;
-	BufferCache   m_buffer_cache;
-	TextureCache  m_texture_cache;
-};
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_GPURESOURCEMANAGER_H_

src/graphics/host_gpu/renderer/image.cpp

@@ -1,482 +0,0 @@
-#include "graphics/host_gpu/renderer/image.h"
-
-#include "common/assert.h"
-#include "common/profiler.h"
-#include "graphics/guest_gpu/gpu_defs.h"
-#include "graphics/guest_gpu/tile.h"
-#include "graphics/host_gpu/gpuTiler.h"
-#include "graphics/host_gpu/graphicContext.h"
-#include "graphics/host_gpu/objects/textureCommon.h"
-#include "graphics/host_gpu/regionDefinitions.h"
-#include "graphics/host_gpu/renderer/framebufferCache.h"
-#include "graphics/host_gpu/renderer/imageView.h"
-#include "graphics/host_gpu/renderer/renderContext.h"
-#include "graphics/host_gpu/renderer/renderTarget.h"
-#include "graphics/host_gpu/transfer.h"
-#include "graphics/host_gpu/vma.h"
-#include "graphics/shader/shader.h"
-
-#include <algorithm>
-
-namespace Libs::Graphics {
-
-namespace {
-
-TextureImageCreateParams MakeImageParams(const ImageInfo& info, bool storage) {
-	TextureImageCreateParams params {};
-	params.fmt        = info.format;
-	params.width      = info.width;
-	params.height     = info.height;
-	params.base_level = SelectImageBackingBaseLevel(storage, info.base_level);
-	params.levels     = info.levels;
-	params.depth      = info.depth;
-	params.type       = info.type;
-	// Storage image views use identity component mapping. The guest storage write mapping is
-	// validated before this point and intentionally does not become a Vulkan view swizzle.
-	params.swizzle               = storage ? DstSel(4, 5, 6, 7) : info.swizzle;
-	params.format_usage          = TextureFormatUsage::Sampled | TextureFormatUsage::Storage;
-	params.required_format_usage = storage
-	                                   ? TextureFormatUsage::Sampled | TextureFormatUsage::Storage
-	                                   : TextureFormatUsage::Sampled;
-	params.view_usage      = storage ? TextureFormatUsage::Sampled | TextureFormatUsage::Storage
-	                                 : TextureFormatUsage::Sampled;
-	params.image_layout    = TextureUploadDestination::MipLevels;
-	params.allow_cube_view = !storage;
-	params.compatible_format_views =
-	    storage && (IsRgba8SrgbViewFormat(TextureGetFormat(info.format)) ||
-	                info.format == Prospero::GpuEnumValue(Prospero::BufferFormat::k32UInt) ||
-	                info.format == Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float));
-	params.owner = storage ? "StorageTextureCache" : "TextureCache";
-	return params;
-}
-
-bool RenderTargetSupportsStorage(vk::Format format, vk::ImageCreateFlags flags) {
-	const auto compatible = SrgbStorageViewFormat(format);
-	const auto required_flags =
-	    vk::ImageCreateFlagBits::eMutableFormat | vk::ImageCreateFlagBits::eExtendedUsage;
-	const bool compatible_views = (flags & required_flags) == required_flags;
-	return ImageViewOps::FormatSupportsStorage(format) ||
-	       (compatible_views && compatible != vk::Format::eUndefined &&
-	        ImageViewOps::FormatSupportsStorage(compatible));
-}
-
-vk::ImageCreateFlags RenderTargetCreateFlags(vk::Format format) {
-	const bool compatible_format_view =
-	    IsRgba8SrgbViewFormat(format) ||
-	    BgraToRgbaSampledViewFormat(format) != vk::Format::eUndefined ||
-	    format == vk::Format::eR8G8B8A8Uint || format == vk::Format::eR16G16B16A16Sfloat ||
-	    format == vk::Format::eR16G16B16A16Uint;
-	return compatible_format_view
-	           ? vk::ImageCreateFlagBits::eMutableFormat | vk::ImageCreateFlagBits::eExtendedUsage
-	           : vk::ImageCreateFlags {0};
-}
-
-vk::ImageUsageFlags RenderTargetUsage(vk::Format format, vk::ImageCreateFlags flags,
-                                      uint32_t samples) {
-	auto& graphics = GetRenderContext().GetGraphics();
-	auto  usage    = static_cast<vk::ImageUsageFlags>(vk::ImageUsageFlagBits::eColorAttachment) |
-	                 static_cast<vk::ImageUsageFlags>(vk::ImageUsageFlagBits::eTransferSrc) |
-	                 static_cast<vk::ImageUsageFlags>(vk::ImageUsageFlagBits::eTransferDst);
-	if (samples == 1) {
-		usage |= vk::ImageUsageFlagBits::eSampled;
-		if (RenderTargetSupportsStorage(format, flags)) {
-			usage |= vk::ImageUsageFlagBits::eStorage;
-		}
-	}
-	vk::ImageFormatProperties properties {};
-	if (graphics.GetImageFormatProperties(format, vk::ImageType::e2D, vk::ImageTiling::eOptimal,
-	                                      usage, flags, &properties) != vk::Result::eSuccess ||
-	    !static_cast<bool>(properties.sampleCounts & vulkan_sample_count(samples))) {
-		EXIT("TextureCache: render-target format does not support required usage, format=%d "
-		     "usage=0x%x samples=%u supported=0x%x\n",
-		     static_cast<int>(format), static_cast<vk::ImageUsageFlags::MaskType>(usage), samples,
-		     static_cast<vk::SampleCountFlags::MaskType>(properties.sampleCounts));
-	}
-	return usage;
-}
-
-[[nodiscard]] uint32_t RenderTargetTransferFormatImpl(uint32_t bytes_per_element) {
-	switch (bytes_per_element) {
-		case 1: return Prospero::GpuEnumValue(Prospero::BufferFormat::k8UNorm);
-		case 2: return Prospero::GpuEnumValue(Prospero::BufferFormat::k16UNorm);
-		case 4: return Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float);
-		case 8: return Prospero::GpuEnumValue(Prospero::BufferFormat::k16_16_16_16Float);
-		case 16: return Prospero::GpuEnumValue(Prospero::BufferFormat::k32_32_32_32Float);
-		default:
-			EXIT("TextureCache: unsupported render-target element size: %u\n", bytes_per_element);
-	}
-}
-
-static constexpr uint32_t DummyTextureSwizzle() {
-	return Prospero::GpuEnumValue(Prospero::CompSwizzle::kRed) |
-	       (Prospero::GpuEnumValue(Prospero::CompSwizzle::kGreen) << 3u) |
-	       (Prospero::GpuEnumValue(Prospero::CompSwizzle::kBlue) << 6u) |
-	       (Prospero::GpuEnumValue(Prospero::CompSwizzle::kAlpha) << 9u);
-}
-
-TextureImageCreateParams MakeDummyTextureParams(bool uint_format, bool image_3d,
-                                                TextureFormatUsage usage, const char* owner) {
-	TextureImageCreateParams params {};
-	params.fmt = static_cast<uint32_t>(
-	    Prospero::GpuEnumValue(uint_format ? Prospero::BufferFormat::k8_8_8_8UInt
-	                                       : Prospero::BufferFormat::k8_8_8_8UNorm));
-	params.width                 = 1;
-	params.height                = 1;
-	params.base_level            = 0;
-	params.levels                = 1;
-	params.depth                 = 1;
-	params.type                  = Prospero::GpuEnumValue(image_3d ? Prospero::ImageType::kColor3D
-	                                                               : Prospero::ImageType::kColor2D);
-	params.swizzle               = DummyTextureSwizzle();
-	params.format_usage          = usage;
-	params.required_format_usage = usage;
-	params.view_usage            = usage;
-	params.image_layout          = TextureUploadDestination::MipLevels;
-	params.allow_cube_view       = true;
-	params.storage_swizzle_fallback = TextureHasFormatUsage(usage, TextureFormatUsage::Storage);
-	params.owner                    = owner;
-	return params;
-}
-
-} // namespace
-
-namespace ImageOps {
-
-uint32_t RenderTargetTransferFormat(uint32_t bytes_per_element) {
-	return RenderTargetTransferFormatImpl(bytes_per_element);
-}
-
-GpuTextureVulkanImage* CreateTexture(const ImageInfo& info, bool storage,
-                                     vk::ComponentMapping& components) {
-	auto* image = storage ? static_cast<GpuTextureVulkanImage*>(new StorageTextureVulkanImage)
-	                      : new TextureVulkanImage;
-	components  = TextureCreateImage(*image, MakeImageParams(info, storage));
-	return image;
-}
-
-void CreateTextureViews(GpuTextureVulkanImage& image, const ImageInfo& info, bool storage,
-                        vk::ComponentMapping components) {
-	if (storage) {
-		TextureCreateImageViews(image, components, info.type, 0, 0, 1, info.depth, false,
-		                        TextureFormatUsage::Sampled | TextureFormatUsage::Storage);
-	} else {
-		TextureCreateImageViews(image, components, info.type, info.base_array, info.base_level,
-		                        info.view_levels, info.depth, true, TextureFormatUsage::Sampled);
-	}
-}
-
-void UploadRenderTargetLayers(RenderTextureVulkanImage& image, const RenderTargetInfo& info,
-                              uint32_t base_layer, uint32_t layer_count, bool refresh) {
-	if (info.layers == 0 || info.size % info.layers != 0 || layer_count == 0 ||
-	    base_layer >= info.layers || layer_count > info.layers - base_layer ||
-	    base_layer >= image.layers || layer_count > image.layers - base_layer) {
-		EXIT("TextureCache: invalid render-target layer upload, base=%u count=%u "
-		     "info_layers=%u image_layers=%u size=0x%016" PRIx64 "\n",
-		     base_layer, layer_count, info.layers, image.layers, info.size);
-	}
-	if (info.samples != 1 || image.samples != 1) {
-		EXIT("TextureCache: multisampled render-target upload is unsupported, samples=%u/%u\n",
-		     info.samples, image.samples);
-	}
-	if (refresh) {
-		Transfer::WaitForQueueIdle();
-	}
-	const auto slice_size  = info.size / info.layers;
-	const auto upload_size = slice_size * layer_count;
-	const bool standard64  = IsSupportedStandard64RenderTarget(info);
-	if (standard64 || info.levels > 1 || info.layers > 1) {
-		const auto format = RenderTargetTransferFormat(info.bytes_per_element);
-		auto layout = TextureCalcUploadLayout(format, info.width, info.height, info.levels,
-		                                      layer_count, info.pitch, info.tile_mode, upload_size,
-		                                      false, false, "TextureCache render target");
-		const bool render_target_tiled =
-		    info.tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget);
-		if (!standard64 &&
-		    ((render_target_tiled && layout.tile_family != TileBlockFamily::RenderTarget64KB) ||
-		     layout.pitch != info.pitch)) {
-			EXIT("TextureCache: unsupported render-target mip upload layout, pitch=%u/%u tile=%u\n",
-			     info.pitch, layout.pitch, info.tile_mode);
-		}
-		auto regions = TextureBuildUploadRegions(layout, info.format, info.width, info.height,
-		                                         layer_count, info.levels, true, false,
-		                                         TextureUploadDestination::MipLevels);
-		for (auto& region: regions) {
-			region.dst_layer += base_layer;
-		}
-		const auto source_address = info.address + slice_size * base_layer;
-		TextureUploadGuestImage(image, reinterpret_cast<const void*>(source_address), upload_size,
-		                        regions, layout, format, info.width, info.height, layer_count,
-		                        info.levels, "TextureCache render target",
-		                        vk::ImageLayout::eGeneral);
-		return;
-	}
-	if (info.tile_mode == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget) &&
-	    Transfer::GuestBufferIsTiled(info.address, slice_size)) {
-		const auto format = RenderTargetTransferFormat(info.bytes_per_element);
-		auto layout  = TextureCalcUploadLayout(format, info.width, info.height, 1, 1, info.pitch,
-		                                       info.tile_mode, slice_size, false, false,
-		                                       "TextureCache render target");
-		auto regions = TextureBuildUploadRegions(layout, info.format, info.width, info.height, 1, 1,
-		                                         true, false, TextureUploadDestination::MipLevels);
-		TextureUploadGuestImage(image, reinterpret_cast<const void*>(info.address), slice_size,
-		                        regions, layout, format, info.width, info.height, 1, 1,
-		                        "TextureCache render target", vk::ImageLayout::eGeneral);
-	} else {
-		Transfer::UploadImage(image, reinterpret_cast<const void*>(info.address), slice_size,
-		                      info.pitch, vk::ImageLayout::eGeneral);
-	}
-}
-
-void UploadRenderTarget(RenderTextureVulkanImage& image, const RenderTargetInfo& info,
-                        bool refresh) {
-	UploadRenderTargetLayers(image, info, 0, info.layers, refresh);
-}
-
-RenderTextureVulkanImage* CreateRenderTarget(const RenderTargetInfo& info) {
-	auto& graphics       = GetRenderContext().GetGraphics();
-	auto* image          = new RenderTextureVulkanImage;
-	image->extent.width  = info.width;
-	image->extent.height = info.height;
-	image->format        = info.format;
-	image->mip_levels    = info.levels;
-	image->layers        = info.layers;
-	image->samples       = info.samples;
-	image->layout        = vk::ImageLayout::eUndefined;
-	vk::ImageCreateInfo create {};
-	create.sType           = vk::StructureType::eImageCreateInfo;
-	create.flags           = RenderTargetCreateFlags(info.format);
-	create.imageType       = vk::ImageType::e2D;
-	create.extent          = {info.width, info.height, 1};
-	create.mipLevels       = info.levels;
-	create.arrayLayers     = info.layers;
-	create.format          = info.format;
-	create.tiling          = vk::ImageTiling::eOptimal;
-	create.initialLayout   = vk::ImageLayout::eUndefined;
-	create.usage           = RenderTargetUsage(info.format, create.flags, info.samples);
-	create.sharingMode     = vk::SharingMode::eExclusive;
-	create.samples         = vulkan_sample_count(info.samples);
-	image->memory.property = vk::MemoryPropertyFlagBits::eDeviceLocal;
-	if (!graphics.CreateImage(create, *image)) {
-		EXIT("TextureCache: failed to create render target, addr=0x%016" PRIx64
-		     " extent=%ux%u format=%d\n",
-		     info.address, info.width, info.height, static_cast<int>(info.format));
-	}
-	ImageViewOps::CreateRenderTargetViews(*image);
-	return image;
-}
-
-DepthStencilVulkanImage* CreateDepthTarget(const DepthTargetInfo& info) {
-	auto&               graphics = GetRenderContext().GetGraphics();
-	vk::ImageCreateInfo create {};
-	create.sType         = vk::StructureType::eImageCreateInfo;
-	create.imageType     = vk::ImageType::e2D;
-	create.extent        = {info.width, info.height, 1};
-	create.mipLevels     = 1;
-	create.arrayLayers   = info.layers;
-	create.format        = info.format;
-	create.tiling        = vk::ImageTiling::eOptimal;
-	create.initialLayout = vk::ImageLayout::eUndefined;
-	create.usage         = DepthTargetImageUsage();
-	create.sharingMode   = vk::SharingMode::eExclusive;
-	create.samples       = vulkan_sample_count(info.samples);
-	vk::ImageFormatProperties properties {};
-	if (graphics.GetImageFormatProperties(
-	        info.format, vk::ImageType::e2D, vk::ImageTiling::eOptimal, create.usage,
-	        vk::ImageCreateFlags {}, &properties) != vk::Result::eSuccess ||
-	    !static_cast<bool>(properties.sampleCounts & create.samples)) {
-		EXIT("TextureCache: depth format does not support required usage, format=%d usage=0x%x "
-		     "samples=%u supported=0x%x\n",
-		     static_cast<int>(info.format),
-		     static_cast<vk::ImageUsageFlags::MaskType>(create.usage), info.samples,
-		     static_cast<vk::SampleCountFlags::MaskType>(properties.sampleCounts));
-	}
-	auto* image            = new DepthStencilVulkanImage;
-	image->extent.width    = info.width;
-	image->extent.height   = info.height;
-	image->guest_pitch     = info.pitch;
-	image->layers          = info.layers;
-	image->samples         = info.samples;
-	image->format          = info.format;
-	image->layout          = vk::ImageLayout::eUndefined;
-	image->compressed      = false;
-	image->memory.property = vk::MemoryPropertyFlagBits::eDeviceLocal;
-	if (!graphics.CreateImage(create, *image)) {
-		EXIT("TextureCache: failed to create depth target, addr=0x%016" PRIx64
-		     " extent=%ux%u format=%d\n",
-		     info.address, info.width, info.height, static_cast<int>(info.format));
-	}
-	ImageViewOps::CreateDepthViews(*image);
-	return image;
-}
-
-void ValidateVideoOut(const VideoOutInfo& info) {
-	const auto compression =
-	    ClassifyVideoOutCompression(info.compression != VideoOutCompression::Uncompressed,
-	                                info.metadata_address, info.dcc_control, 0);
-	const bool metadata_invalid = compression != VideoOutCompression::Uncompressed &&
-	                              compression != VideoOutCompression::Unsupported &&
-	                              (info.metadata_address >= TRACKER_ADDRESS_SIZE ||
-	                               (info.metadata_address >= info.address &&
-	                                info.metadata_address < info.address + info.size));
-	if (info.address == 0 || info.size == 0 || info.address >= TRACKER_ADDRESS_SIZE ||
-	    info.size > TRACKER_ADDRESS_SIZE - info.address || (info.address & 0xffffu) != 0 ||
-	    info.width == 0 || info.height == 0 || info.width > 16384 || info.height > 16384 ||
-	    info.pitch < info.width ||
-	    info.tile_mode != Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget) ||
-	    compression == VideoOutCompression::Unsupported || compression != info.compression ||
-	    metadata_invalid || !IsSupportedVideoOutFormat(info)) {
-		EXIT("TextureCache: unsupported video-out surface, addr=0x%016" PRIx64 " size=0x%016" PRIx64
-		     " metadata=0x%016" PRIx64 " dcc=0x%08" PRIx32
-		     " extent=%ux%u pitch=%u tile=%u guest_format=%u bpe=%u vk_format=%d\n",
-		     info.address, info.size, info.metadata_address, info.dcc_control, info.width,
-		     info.height, info.pitch, info.tile_mode, info.guest_format, info.bytes_per_element,
-		     static_cast<int>(info.format));
-	}
-	TileSizeAlign exact {};
-	TileGetTextureTotalSize(info.guest_format, info.width, info.height, 1, info.pitch, 1,
-	                        info.tile_mode, false, exact);
-	if (exact.align != 65536 || exact.size != info.size ||
-	    TileGetTexturePitch(info.guest_format, info.width, 1, info.tile_mode) != info.pitch) {
-		EXIT("TextureCache: video-out tile layout mismatch, addr=0x%016" PRIx64
-		     " size=0x%016" PRIx64 " expected_size=0x%016" PRIx64 " align=0x%016" PRIx64
-		     " pitch=%u\n",
-		     info.address, info.size, exact.size, exact.align, info.pitch);
-	}
-	(void)RenderTargetUsage(info.format, vk::ImageCreateFlags {}, 1);
-}
-
-VideoOutVulkanImage* CreateVideoOut(const VideoOutInfo& info) {
-	auto& graphics       = GetRenderContext().GetGraphics();
-	auto* image          = new VideoOutVulkanImage;
-	image->extent.width  = info.width;
-	image->extent.height = info.height;
-	image->format        = info.format;
-	image->layout        = vk::ImageLayout::eUndefined;
-	vk::ImageCreateInfo create {};
-	create.sType           = vk::StructureType::eImageCreateInfo;
-	create.imageType       = vk::ImageType::e2D;
-	create.extent          = {info.width, info.height, 1};
-	create.mipLevels       = 1;
-	create.arrayLayers     = 1;
-	create.format          = info.format;
-	create.tiling          = vk::ImageTiling::eOptimal;
-	create.initialLayout   = vk::ImageLayout::eUndefined;
-	create.flags           = RenderTargetCreateFlags(info.format);
-	create.usage           = RenderTargetUsage(info.format, create.flags, 1);
-	create.sharingMode     = vk::SharingMode::eExclusive;
-	create.samples         = vk::SampleCountFlagBits::e1;
-	image->memory.property = vk::MemoryPropertyFlagBits::eDeviceLocal;
-	if (!graphics.CreateImage(create, *image)) {
-		EXIT("TextureCache: failed to create video-out image, addr=0x%016" PRIx64
-		     " extent=%ux%u format=%d\n",
-		     info.address, info.width, info.height, static_cast<int>(info.format));
-	}
-	ImageViewOps::CreateVideoOutViews(*image);
-	return image;
-}
-
-void UploadVideoOut(VideoOutVulkanImage& image, const VideoOutInfo& info, bool refresh) {
-	if (info.compression != VideoOutCompression::Uncompressed) {
-		EXIT("TextureCache: compressed video-out guest upload is unsupported, "
-		     "addr=0x%016" PRIx64 " metadata=0x%016" PRIx64 " dcc=0x%08" PRIx32 "\n",
-		     info.address, info.metadata_address, info.dcc_control);
-	}
-	if (refresh) {
-		Transfer::WaitForQueueIdle();
-	}
-	image.layout = vk::ImageLayout::eUndefined;
-	if (!info.bgra16) {
-		auto layout =
-		    TextureCalcUploadLayout(info.guest_format, info.width, info.height, 1, 1, info.pitch,
-		                            info.tile_mode, info.size, false, false, "VideoOut");
-		auto regions = TextureBuildUploadRegions(layout, info.format, info.width, info.height, 1, 1,
-		                                         false, false, TextureUploadDestination::MipLevels);
-		TextureUploadGuestImage(image, reinterpret_cast<const void*>(info.address), info.size,
-		                        regions, layout, info.guest_format, info.width, info.height, 1, 1,
-		                        "VideoOut", vk::ImageLayout::eGeneral);
-		return;
-	}
-	Transfer::ScratchBuffer scratch(info.size);
-	TileBlockLayout         block {};
-	EXIT_NOT_IMPLEMENTED(
-	    !TileGetBlockLayout(TileBlockFamily::RenderTarget64KB, info.bytes_per_element, block));
-	const GpuTileInfo tile_info {block.family,
-	                             block.bytes_per_element,
-	                             0,
-	                             info.size,
-	                             0,
-	                             info.size,
-	                             0,
-	                             info.width,
-	                             info.height,
-	                             1,
-	                             info.pitch};
-	GpuDetile(reinterpret_cast<const void*>(info.address), scratch.Data(), info.size, info.size,
-	          std::span<const GpuTileInfo>(&tile_info, 1));
-	SwapVideoOutBgra16(scratch.Data(), info.size);
-	Transfer::UploadImage(image, scratch.Data(), info.size, info.pitch, vk::ImageLayout::eGeneral);
-}
-
-void SwapVideoOutBgra16(void* data, uint64_t size) {
-	auto* pixels = static_cast<uint16_t*>(data);
-	for (uint64_t i = 0; i < size / sizeof(uint16_t); i += 4) {
-		std::swap(pixels[i], pixels[i + 2]);
-	}
-}
-
-GpuTextureVulkanImage* CreateDummyTexture(bool uint_format, bool image_3d, bool storage) {
-	auto* image  = storage ? static_cast<GpuTextureVulkanImage*>(new StorageTextureVulkanImage)
-	                       : new TextureVulkanImage;
-	auto  usage  = storage ? TextureFormatUsage::Storage : TextureFormatUsage::Sampled;
-	auto  layout = storage ? vk::ImageLayout::eGeneral : vk::ImageLayout::eShaderReadOnlyOptimal;
-	auto  owner  = storage ? "DummyStorageTexture" : "DummySampledTexture";
-
-	auto params     = MakeDummyTextureParams(uint_format, image_3d, usage, owner);
-	auto components = TextureCreateImage(*image, params);
-
-	static constexpr uint32_t zero = 0;
-	Transfer::UploadImage(*image, &zero, sizeof(zero), 1, layout);
-	TextureCreateImageViews(*image, components, params.type, 0, params.base_level, params.levels,
-	                        params.depth, params.allow_cube_view, params.view_usage);
-	return image;
-}
-
-void Destroy(VulkanImage& image) {
-	auto& graphics = GetRenderContext().GetGraphics();
-	KYTY_PROFILER_BLOCK("TextureCache::DeleteImage");
-	switch (image.type) {
-		case VulkanImageType::RenderTexture:
-		case VulkanImageType::VideoOut:
-			GetRenderContext().GetFramebufferCache().FreeFramebufferByColor(image);
-			break;
-		case VulkanImageType::DepthStencil:
-			GetRenderContext().GetFramebufferCache().FreeFramebufferByDepth(
-			    static_cast<DepthStencilVulkanImage&>(image));
-			break;
-		case VulkanImageType::Texture:
-		case VulkanImageType::StorageTexture: break;
-		case VulkanImageType::Unknown: EXIT("cannot destroy an untyped Vulkan image\n");
-	}
-
-	ImageViewOps::DestroyViews(image);
-	graphics.DeleteImage(image);
-
-	switch (image.type) {
-		case VulkanImageType::Texture: delete &static_cast<TextureVulkanImage&>(image); break;
-		case VulkanImageType::StorageTexture:
-			delete &static_cast<StorageTextureVulkanImage&>(image);
-			break;
-		case VulkanImageType::RenderTexture:
-			delete &static_cast<RenderTextureVulkanImage&>(image);
-			break;
-		case VulkanImageType::DepthStencil:
-			delete &static_cast<DepthStencilVulkanImage&>(image);
-			break;
-		case VulkanImageType::VideoOut: delete &static_cast<VideoOutVulkanImage&>(image); break;
-		case VulkanImageType::Unknown: EXIT("cannot delete an untyped Vulkan image\n");
-	}
-}
-
-} // namespace ImageOps
-
-} // namespace Libs::Graphics

src/graphics/host_gpu/renderer/image.h

@@ -1,168 +0,0 @@
-#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_
-#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_
-
-#include "common/assert.h"
-#include "graphics/host_gpu/renderer/imageInfo.h"
-
-#include <algorithm>
-#include <cstddef>
-#include <span>
-
-namespace Libs::Graphics {
-
-struct DepthStencilVulkanImage;
-struct GpuTextureVulkanImage;
-struct GraphicContext;
-struct RenderTextureVulkanImage;
-struct VideoOutVulkanImage;
-struct VulkanImage;
-
-struct Image final: ImageInfo {
-	Image& operator=(const ImageInfo& value) {
-		if (IsCpuDirty()) {
-			EXIT("dirty sampled image cannot be reassigned\n");
-		}
-		static_cast<ImageInfo&>(*this) = value;
-		m_track_begin                  = address;
-		m_track_end                    = address + size;
-		m_maybe_cpu_hash_valid         = false;
-		return *this;
-	}
-
-	void InvalidateCpuWrite(uint64_t vaddr, uint64_t size) {
-		if (ImageRangeOverlaps(address, this->size, vaddr, size)) {
-			m_cpu_dirty            = true;
-			m_maybe_cpu_dirty      = false;
-			m_maybe_cpu_hash_valid = false;
-			m_track_begin          = m_track_end;
-		} else if (ImagePageRangesOverlap(address, this->size, vaddr, size)) {
-			constexpr uint64_t page_mask = 4096 - 1;
-			if (vaddr + size <= address) {
-				const auto next_page = (address + page_mask) & ~page_mask;
-				m_track_begin        = std::min(m_track_end, std::max(m_track_begin, next_page));
-			} else if (vaddr >= address + this->size) {
-				const auto page = (address + this->size) & ~page_mask;
-				m_track_end     = std::max(m_track_begin, std::min(m_track_end, page));
-			}
-			m_maybe_cpu_dirty = m_track_begin == m_track_end;
-		}
-	}
-
-	[[nodiscard]] bool IsCpuDirty() const { return m_cpu_dirty || m_maybe_cpu_dirty; }
-	[[nodiscard]] bool IsDefinitelyCpuDirty() const { return m_cpu_dirty; }
-	[[nodiscard]] bool IsMaybeCpuDirty() const { return m_maybe_cpu_dirty; }
-	[[nodiscard]] bool NeedsMaybeCpuHash() const {
-		return m_maybe_cpu_dirty && !m_maybe_cpu_hash_valid;
-	}
-	[[nodiscard]] bool IsCpuTrackingComplete() const {
-		return m_track_begin == address && m_track_end == address + size;
-	}
-	void SetMaybeCpuHash(uint64_t hash) {
-		if (!NeedsMaybeCpuHash()) {
-			EXIT("sampled image cannot initialize maybe-dirty hash\n");
-		}
-		m_maybe_cpu_hash       = hash;
-		m_maybe_cpu_hash_valid = true;
-	}
-	[[nodiscard]] bool ResolveMaybeCpuHash(uint64_t hash) {
-		if (!m_maybe_cpu_dirty || !m_maybe_cpu_hash_valid || m_cpu_dirty) {
-			EXIT("sampled image cannot resolve maybe-dirty hash\n");
-		}
-		m_maybe_cpu_dirty      = false;
-		m_maybe_cpu_hash_valid = false;
-		m_cpu_dirty            = hash != m_maybe_cpu_hash;
-		if (!m_cpu_dirty) {
-			m_track_begin = address;
-			m_track_end   = address + size;
-		}
-		return m_cpu_dirty;
-	}
-
-	void RefreshComplete() {
-		if (!IsCpuDirty()) {
-			EXIT("clean sampled image cannot complete a refresh\n");
-		}
-		m_cpu_dirty            = false;
-		m_maybe_cpu_dirty      = false;
-		m_maybe_cpu_hash_valid = false;
-		m_track_begin          = address;
-		m_track_end            = address + size;
-	}
-
-private:
-	bool     m_cpu_dirty            = false;
-	bool     m_maybe_cpu_dirty      = false;
-	bool     m_maybe_cpu_hash_valid = false;
-	uint64_t m_track_begin          = 0;
-	uint64_t m_track_end            = 0;
-	uint64_t m_maybe_cpu_hash       = 0;
-};
-
-namespace ImageOps {
-
-[[nodiscard]] GpuTextureVulkanImage* CreateTexture(const ImageInfo& info,
-                                                   bool storage, vk::ComponentMapping& components);
-void CreateTextureViews(GpuTextureVulkanImage& image,
-                        const ImageInfo& info, bool storage, vk::ComponentMapping components);
-
-[[nodiscard]] RenderTextureVulkanImage* CreateRenderTarget(
-                                                           const RenderTargetInfo& info);
-[[nodiscard]] uint32_t                  RenderTargetTransferFormat(uint32_t bytes_per_element);
-void UploadRenderTargetLayers(RenderTextureVulkanImage& image,
-                              const RenderTargetInfo& info, uint32_t base_layer,
-                              uint32_t layer_count, bool refresh);
-void UploadRenderTarget(RenderTextureVulkanImage& image,
-                        const RenderTargetInfo& info, bool refresh);
-
-[[nodiscard]] DepthStencilVulkanImage* CreateDepthTarget(
-                                                         const DepthTargetInfo& info);
-
-void ValidateVideoOut(const VideoOutInfo& info);
-[[nodiscard]] VideoOutVulkanImage* CreateVideoOut(
-                                                  const VideoOutInfo& info);
-void                               SwapVideoOutBgra16(void* data, uint64_t size);
-void UploadVideoOut(VideoOutVulkanImage& image, const VideoOutInfo& info,
-                    bool refresh);
-
-[[nodiscard]] GpuTextureVulkanImage* CreateDummyTexture(bool uint_format,
-                                                        bool image_3d, bool storage);
-
-void Destroy(VulkanImage& image);
-
-} // namespace ImageOps
-
-struct ImageRetirementRange {
-	uint64_t address = 0;
-	uint64_t size    = 0;
-	bool     retire  = false;
-};
-
-struct ImageRetirementConflict {
-	size_t retired  = SIZE_MAX;
-	size_t retained = SIZE_MAX;
-
-	[[nodiscard]] bool Exists() const { return retired != SIZE_MAX; }
-};
-
-[[nodiscard]] inline ImageRetirementConflict
-FindImageRetirementConflict(std::span<const ImageRetirementRange> ranges) {
-	for (size_t retired = 0; retired < ranges.size(); retired++) {
-		if (!ranges[retired].retire) {
-			continue;
-		}
-		for (size_t retained = 0; retained < ranges.size(); retained++) {
-			if (ranges[retained].retire) {
-				continue;
-			}
-			if (ImageRangeOverlaps(ranges[retired].address, ranges[retired].size,
-			                       ranges[retained].address, ranges[retained].size)) {
-				return {retired, retained};
-			}
-		}
-	}
-	return {};
-}
-
-} // namespace Libs::Graphics
-
-#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_

src/graphics/host_gpu/renderer/image/blitHelper.cpp

@@ -0,0 +1,231 @@
+#include "graphics/host_gpu/renderer/image/blitHelper.h"
+
+#include "common/assert.h"
+#include "gpu_blit_shaders/gpu_blit_color_to_ms_depth_spv.h"
+#include "gpu_blit_shaders/gpu_blit_fs_triangle_spv.h"
+#include "graphics/host_gpu/graphicContext.h"
+#include "graphics/host_gpu/renderer/commandScheduler.h"
+#include "graphics/host_gpu/renderer/image/image.h"
+#include "graphics/host_gpu/renderer/renderTarget.h"
+
+#include <algorithm>
+#include <array>
+#include <iterator>
+
+namespace Libs::Graphics {
+
+BlitHelper::BlitHelper(GraphicContext& graphics, CommandScheduler& scheduler)
+    : m_graphics(graphics), m_scheduler(scheduler) {
+	vk::DescriptorSetLayoutBinding texture_binding {};
+	texture_binding.binding         = 0;
+	texture_binding.descriptorType  = vk::DescriptorType::eSampledImage;
+	texture_binding.descriptorCount = 1;
+	texture_binding.stageFlags      = vk::ShaderStageFlagBits::eFragment;
+
+	vk::DescriptorSetLayoutCreateInfo descriptor_info {};
+	descriptor_info.sType        = vk::StructureType::eDescriptorSetLayoutCreateInfo;
+	descriptor_info.flags        = vk::DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR;
+	descriptor_info.bindingCount = 1;
+	descriptor_info.pBindings    = &texture_binding;
+	RequireVulkanSuccess(m_graphics.device.createDescriptorSetLayout(&descriptor_info, nullptr,
+	                                                                 &m_descriptor_layout),
+	                     "create BlitHelper descriptor layout");
+
+	vk::PipelineLayoutCreateInfo layout_info {};
+	layout_info.sType          = vk::StructureType::ePipelineLayoutCreateInfo;
+	layout_info.setLayoutCount = 1;
+	layout_info.pSetLayouts    = &m_descriptor_layout;
+	RequireVulkanSuccess(
+	    m_graphics.device.createPipelineLayout(&layout_info, nullptr, &m_pipeline_layout),
+	    "create BlitHelper pipeline layout");
+
+	m_vertex_shader = CreateShader(GPU_BLIT_FS_TRIANGLE_SPV, std::size(GPU_BLIT_FS_TRIANGLE_SPV));
+	m_fragment_shader =
+	    CreateShader(GPU_BLIT_COLOR_TO_MS_DEPTH_SPV, std::size(GPU_BLIT_COLOR_TO_MS_DEPTH_SPV));
+}
+
+BlitHelper::~BlitHelper() {
+	for (const auto& pipeline: m_pipelines) {
+		m_graphics.device.destroyPipeline(pipeline.handle, nullptr);
+	}
+	if (m_fragment_shader != nullptr) {
+		m_graphics.device.destroyShaderModule(m_fragment_shader, nullptr);
+	}
+	if (m_vertex_shader != nullptr) {
+		m_graphics.device.destroyShaderModule(m_vertex_shader, nullptr);
+	}
+	if (m_pipeline_layout != nullptr) {
+		m_graphics.device.destroyPipelineLayout(m_pipeline_layout, nullptr);
+	}
+	if (m_descriptor_layout != nullptr) {
+		m_graphics.device.destroyDescriptorSetLayout(m_descriptor_layout, nullptr);
+	}
+}
+
+vk::ShaderModule BlitHelper::CreateShader(const uint32_t* code, size_t words) const {
+	EXIT_IF(code == nullptr || words == 0);
+	vk::ShaderModuleCreateInfo create {};
+	create.sType            = vk::StructureType::eShaderModuleCreateInfo;
+	create.codeSize         = words * sizeof(uint32_t);
+	create.pCode            = code;
+	vk::ShaderModule module = nullptr;
+	RequireVulkanSuccess(m_graphics.device.createShaderModule(&create, nullptr, &module),
+	                     "create BlitHelper shader module");
+	return module;
+}
+
+vk::Pipeline BlitHelper::GetPipeline(PipelineKey key) {
+	const auto cached = std::ranges::find(m_pipelines, key, &Pipeline::key);
+	if (cached != m_pipelines.end()) {
+		return cached->handle;
+	}
+
+	const auto samples = vulkan_sample_count(key.samples);
+	EXIT_IF(samples == vk::SampleCountFlagBits {} || key.format == vk::Format::eUndefined);
+
+	std::array<vk::PipelineShaderStageCreateInfo, 2> stages {};
+	stages[0].sType  = vk::StructureType::ePipelineShaderStageCreateInfo;
+	stages[0].stage  = vk::ShaderStageFlagBits::eVertex;
+	stages[0].module = m_vertex_shader;
+	stages[0].pName  = "main";
+	stages[1].sType  = vk::StructureType::ePipelineShaderStageCreateInfo;
+	stages[1].stage  = vk::ShaderStageFlagBits::eFragment;
+	stages[1].module = m_fragment_shader;
+	stages[1].pName  = "main";
+
+	vk::PipelineVertexInputStateCreateInfo vertex_input {};
+	vertex_input.sType = vk::StructureType::ePipelineVertexInputStateCreateInfo;
+	vk::PipelineInputAssemblyStateCreateInfo input_assembly {};
+	input_assembly.sType    = vk::StructureType::ePipelineInputAssemblyStateCreateInfo;
+	input_assembly.topology = vk::PrimitiveTopology::eTriangleList;
+	vk::PipelineViewportStateCreateInfo viewport {};
+	viewport.sType         = vk::StructureType::ePipelineViewportStateCreateInfo;
+	viewport.viewportCount = 1;
+	viewport.scissorCount  = 1;
+	vk::PipelineRasterizationStateCreateInfo rasterization {};
+	rasterization.sType       = vk::StructureType::ePipelineRasterizationStateCreateInfo;
+	rasterization.polygonMode = vk::PolygonMode::eFill;
+	rasterization.cullMode    = vk::CullModeFlagBits::eNone;
+	rasterization.lineWidth   = 1.0f;
+	vk::PipelineMultisampleStateCreateInfo multisample {};
+	multisample.sType                = vk::StructureType::ePipelineMultisampleStateCreateInfo;
+	multisample.rasterizationSamples = samples;
+	vk::PipelineDepthStencilStateCreateInfo depth {};
+	depth.sType            = vk::StructureType::ePipelineDepthStencilStateCreateInfo;
+	depth.depthTestEnable  = VK_TRUE;
+	depth.depthWriteEnable = VK_TRUE;
+	depth.depthCompareOp   = vk::CompareOp::eAlways;
+	vk::PipelineColorBlendStateCreateInfo color_blend {};
+	color_blend.sType = vk::StructureType::ePipelineColorBlendStateCreateInfo;
+	const std::array dynamic_states {vk::DynamicState::eViewport, vk::DynamicState::eScissor};
+	vk::PipelineDynamicStateCreateInfo dynamic {};
+	dynamic.sType             = vk::StructureType::ePipelineDynamicStateCreateInfo;
+	dynamic.dynamicStateCount = static_cast<uint32_t>(dynamic_states.size());
+	dynamic.pDynamicStates    = dynamic_states.data();
+
+	vk::PipelineRenderingCreateInfo rendering {};
+	rendering.sType                 = vk::StructureType::ePipelineRenderingCreateInfo;
+	rendering.depthAttachmentFormat = key.format;
+
+	vk::GraphicsPipelineCreateInfo create {};
+	create.sType               = vk::StructureType::eGraphicsPipelineCreateInfo;
+	create.pNext               = &rendering;
+	create.stageCount          = static_cast<uint32_t>(stages.size());
+	create.pStages             = stages.data();
+	create.pVertexInputState   = &vertex_input;
+	create.pInputAssemblyState = &input_assembly;
+	create.pViewportState      = &viewport;
+	create.pRasterizationState = &rasterization;
+	create.pMultisampleState   = &multisample;
+	create.pDepthStencilState  = &depth;
+	create.pColorBlendState    = &color_blend;
+	create.pDynamicState       = &dynamic;
+	create.layout              = m_pipeline_layout;
+
+	vk::Pipeline pipeline = nullptr;
+	RequireVulkanSuccess(
+	    m_graphics.device.createGraphicsPipelines(nullptr, 1, &create, nullptr, &pipeline),
+	    "create color-to-MS-depth pipeline");
+	m_pipelines.push_back({key, pipeline});
+	return pipeline;
+}
+
+void BlitHelper::ReinterpretColorAsMsDepth(Image& source, Image& destination) {
+	const auto& source_info      = source.info;
+	const auto& destination_info = destination.info;
+	EXIT_IF(DepthAspectTransferFormat(source_info.pixel_format) != vk::Format::eUndefined ||
+	        DepthAspectTransferFormat(destination_info.pixel_format) == vk::Format::eUndefined ||
+	        source_info.samples != 1 || destination_info.samples <= 1 ||
+	        destination_info.samples > 4 || source.backing.image_type != vk::ImageType::e2D ||
+	        destination.backing.image_type != vk::ImageType::e2D ||
+	        source_info.extent.width != destination_info.extent.width ||
+	        source_info.extent.height != destination_info.extent.height ||
+	        source_info.extent.depth != 1 || destination_info.extent.depth != 1 ||
+	        source.backing.image == nullptr || destination.backing.image == nullptr);
+	m_scheduler.EndRendering();
+
+	ImageViewInfo source_view_info {};
+	source_view_info.format = source_info.pixel_format;
+	source_view_info.type   = vk::ImageViewType::e2D;
+	source_view_info.aspect = vk::ImageAspectFlagBits::eColor;
+	source_view_info.usage  = vk::ImageUsageFlagBits::eSampled;
+	const auto source_view  = source.FindView(source_view_info);
+
+	ImageViewInfo destination_view_info {};
+	destination_view_info.format = destination_info.pixel_format;
+	destination_view_info.type   = vk::ImageViewType::e2D;
+	destination_view_info.aspect = vk::ImageAspectFlagBits::eDepth;
+	destination_view_info.usage  = vk::ImageUsageFlagBits::eDepthStencilAttachment;
+	const auto destination_view  = destination.FindView(destination_view_info);
+
+	auto& command_buffer = m_scheduler.Current();
+	auto  command        = command_buffer.Handle();
+	source.Transit(vk::ImageLayout::eShaderReadOnlyOptimal, vk::AccessFlagBits2::eShaderRead, {},
+	               command);
+	destination.Transit(ColorToMsDepthLayout, vk::AccessFlagBits2::eDepthStencilAttachmentWrite, {},
+	                    command);
+
+	vk::RenderingAttachmentInfo depth_attachment {};
+	depth_attachment.sType                   = vk::StructureType::eRenderingAttachmentInfo;
+	depth_attachment.imageView               = destination_view;
+	depth_attachment.imageLayout             = ColorToMsDepthLayout;
+	depth_attachment.loadOp                  = vk::AttachmentLoadOp::eClear;
+	depth_attachment.storeOp                 = vk::AttachmentStoreOp::eStore;
+	depth_attachment.clearValue.depthStencil = {0.0f, 0};
+
+	vk::RenderingInfo rendering {};
+	rendering.sType             = vk::StructureType::eRenderingInfo;
+	rendering.renderArea.extent = {destination_info.extent.width, destination_info.extent.height};
+	rendering.layerCount        = 1;
+	rendering.pDepthAttachment  = &depth_attachment;
+	command.beginRendering(&rendering);
+
+	vk::DescriptorImageInfo descriptor_image {};
+	descriptor_image.imageView   = source_view;
+	descriptor_image.imageLayout = vk::ImageLayout::eShaderReadOnlyOptimal;
+	vk::WriteDescriptorSet descriptor_write {};
+	descriptor_write.sType           = vk::StructureType::eWriteDescriptorSet;
+	descriptor_write.dstBinding      = 0;
+	descriptor_write.descriptorCount = 1;
+	descriptor_write.descriptorType  = vk::DescriptorType::eSampledImage;
+	descriptor_write.pImageInfo      = &descriptor_image;
+	command.pushDescriptorSetKHR(vk::PipelineBindPoint::eGraphics, m_pipeline_layout, 0, 1,
+	                             &descriptor_write);
+	command.bindPipeline(vk::PipelineBindPoint::eGraphics,
+	                     GetPipeline({destination_info.samples, destination_info.pixel_format}));
+
+	const vk::Viewport viewport {0.0f,
+	                             0.0f,
+	                             static_cast<float>(destination_info.extent.width),
+	                             static_cast<float>(destination_info.extent.height),
+	                             0.0f,
+	                             1.0f};
+	const vk::Rect2D   scissor {{0, 0},
+	                            {destination_info.extent.width, destination_info.extent.height}};
+	command.setViewport(0, 1, &viewport);
+	command.setScissor(0, 1, &scissor);
+	command.draw(3, 1, 0, 0);
+	command.endRendering();
+}
+
+} // namespace Libs::Graphics

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

@@ -0,0 +1,54 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BLITHELPER_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BLITHELPER_H_
+
+#include "common/common.h"
+#include "graphics/host_gpu/vulkanCommon.h"
+
+#include <compare>
+#include <vector>
+
+namespace Libs::Graphics {
+
+class CommandScheduler;
+class Image;
+struct GraphicContext;
+
+class BlitHelper final {
+public:
+	inline static constexpr auto ColorToMsDepthLayout =
+	    vk::ImageLayout::eDepthStencilAttachmentOptimal;
+
+	BlitHelper(GraphicContext& graphics, CommandScheduler& scheduler);
+	~BlitHelper();
+	KYTY_CLASS_NO_COPY(BlitHelper);
+
+	void ReinterpretColorAsMsDepth(Image& source, Image& destination);
+
+private:
+	struct PipelineKey {
+		uint32_t   samples = 1;
+		vk::Format format  = vk::Format::eUndefined;
+
+		auto operator<=>(const PipelineKey&) const = default;
+	};
+
+	struct Pipeline {
+		PipelineKey  key;
+		vk::Pipeline handle = nullptr;
+	};
+
+	[[nodiscard]] vk::ShaderModule CreateShader(const uint32_t* code, size_t words) const;
+	[[nodiscard]] vk::Pipeline     GetPipeline(PipelineKey key);
+
+	GraphicContext&         m_graphics;
+	CommandScheduler&       m_scheduler;
+	vk::DescriptorSetLayout m_descriptor_layout = nullptr;
+	vk::PipelineLayout      m_pipeline_layout   = nullptr;
+	vk::ShaderModule        m_vertex_shader     = nullptr;
+	vk::ShaderModule        m_fragment_shader   = nullptr;
+	std::vector<Pipeline>   m_pipelines;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_BLITHELPER_H_

src/graphics/host_gpu/renderer/image/image.cpp

@@ -0,0 +1,753 @@
+#include "graphics/host_gpu/renderer/image/image.h"
+
+#include "common/assert.h"
+#include "common/profiler.h"
+#include "graphics/host_gpu/renderer/cache/streamBuffer.h"
+#include "graphics/host_gpu/renderer/commandScheduler.h"
+#include "graphics/host_gpu/renderer/image/imageView.h"
+#include "graphics/host_gpu/renderer/renderTarget.h"
+#include "kernel/memory.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <xxhash.h>
+
+namespace Libs::Graphics {
+
+namespace {
+
+[[nodiscard]] vk::ImageType HostImageType(Prospero::ImageType type) {
+	switch (type) {
+		case Prospero::ImageType::kColor1D: return vk::ImageType::e1D;
+		case Prospero::ImageType::kColor3D: return vk::ImageType::e3D;
+		case Prospero::ImageType::kColor2D: return vk::ImageType::e2D;
+		default: EXIT("non-base image type: %u\n", static_cast<uint32_t>(type));
+	}
+}
+
+[[nodiscard]] vk::ImageCreateFlags ImageCreateFlags(const ImageInfo& info) {
+	vk::ImageCreateFlags flags {};
+	if (DepthAspectTransferFormat(info.pixel_format) == vk::Format::eUndefined) {
+		flags |= vk::ImageCreateFlagBits::eMutableFormat;
+		flags |= vk::ImageCreateFlagBits::eExtendedUsage;
+		if (Prospero::BlockCompressedBytesPerBlock(info.guest_format) != 0) {
+			flags |= vk::ImageCreateFlagBits::eBlockTexelViewCompatible;
+		}
+	}
+	if (info.IsVolume()) {
+		flags |= vk::ImageCreateFlagBits::e2DArrayCompatible;
+	}
+	return flags;
+}
+
+[[nodiscard]] bool HasFormatFeature(vk::FormatProperties      properties,
+                                    vk::FormatFeatureFlagBits feature) {
+	return static_cast<bool>(properties.optimalTilingFeatures & feature);
+}
+
+[[nodiscard]] vk::ImageUsageFlags ImageUsageFlags(GraphicContext& graphics, const ImageInfo& info) {
+	const auto properties = graphics.GetFormatProperties(info.pixel_format);
+	auto       usage = vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst;
+	if (HasFormatFeature(properties, vk::FormatFeatureFlagBits::eSampledImage)) {
+		usage |= vk::ImageUsageFlagBits::eSampled;
+	}
+	if (DepthAspectTransferFormat(info.pixel_format) != vk::Format::eUndefined) {
+		usage |= vk::ImageUsageFlagBits::eDepthStencilAttachment;
+		return usage;
+	}
+	if (HasFormatFeature(properties, vk::FormatFeatureFlagBits::eColorAttachment)) {
+		usage |= vk::ImageUsageFlagBits::eColorAttachment;
+	}
+	if (info.samples == 1 &&
+	    HasFormatFeature(properties, vk::FormatFeatureFlagBits::eStorageImage)) {
+		usage |= vk::ImageUsageFlagBits::eStorage;
+	} else if (info.samples == 1) {
+		const auto compatible = SrgbStorageViewFormat(info.pixel_format);
+		if (compatible != vk::Format::eUndefined &&
+		    HasFormatFeature(graphics.GetFormatProperties(compatible),
+		                     vk::FormatFeatureFlagBits::eStorageImage)) {
+			usage |= vk::ImageUsageFlagBits::eStorage;
+		}
+	}
+	return usage;
+}
+
+void ValidateRange(GuestRange range, const char* name) {
+	if ((range.address == 0) != (range.size == 0) ||
+	    (range.address != 0 && (range.address >= TRACKER_ADDRESS_SIZE ||
+	                            range.size > TRACKER_ADDRESS_SIZE - range.address))) {
+		EXIT("invalid %s image range: address=0x%016llx size=0x%016llx\n", name,
+		     static_cast<unsigned long long>(range.address),
+		     static_cast<unsigned long long>(range.size));
+	}
+}
+
+} // namespace
+
+vk::ImageAspectFlags Image::FullAspectMask(vk::Format format) noexcept {
+	switch (format) {
+		case vk::Format::eD16Unorm:
+		case vk::Format::eX8D24UnormPack32:
+		case vk::Format::eD32Sfloat: return vk::ImageAspectFlagBits::eDepth;
+		case vk::Format::eS8Uint: return vk::ImageAspectFlagBits::eStencil;
+		case vk::Format::eD16UnormS8Uint:
+		case vk::Format::eD24UnormS8Uint:
+		case vk::Format::eD32SfloatS8Uint:
+			return vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
+		default: return vk::ImageAspectFlagBits::eColor;
+	}
+}
+
+Image::Barriers Image::GetBarriers(vk::ImageLayout                      destination_layout,
+                                   vk::AccessFlags2                     destination_access,
+                                   vk::PipelineStageFlags2              destination_stage,
+                                   std::optional<ImageSubresourceRange> range) {
+	auto& state              = backing.state;
+	auto& subresource_states = backing.subresource_states;
+	if (range && info.IsVolume()) {
+		range->base_layer  = 0;
+		range->layer_count = 1;
+	}
+
+	const bool partial =
+	    range && (range->base_level != 0 || range->level_count != info.resources.levels ||
+	              range->base_layer != 0 || range->layer_count != info.resources.layers);
+	const bool has_subresource_states = !subresource_states.empty();
+
+	Barriers barriers;
+	if (partial || has_subresource_states) {
+		if (!has_subresource_states) {
+			subresource_states.resize(info.resources.levels * info.resources.layers, state);
+		}
+
+		const uint32_t base_level  = partial ? range->base_level : 0;
+		const uint32_t level_count = partial ? range->level_count : info.resources.levels;
+		const uint32_t base_layer  = partial ? range->base_layer : 0;
+		const uint32_t layer_count = partial ? range->layer_count : info.resources.layers;
+		for (uint32_t level = base_level; level < base_level + level_count; level++) {
+			for (uint32_t layer = base_layer; layer < base_layer + layer_count; layer++) {
+				const auto index = level * info.resources.layers + layer;
+				EXIT_IF(index >= subresource_states.size());
+				auto& subresource_state = subresource_states[index];
+
+				constexpr auto write_access = vk::AccessFlagBits2::eTransferWrite |
+				                              vk::AccessFlagBits2::eShaderWrite |
+				                              vk::AccessFlagBits2::eMemoryWrite;
+				const bool     repeated_write =
+				    static_cast<bool>(subresource_state.access_mask & write_access);
+				if (subresource_state.layout != destination_layout ||
+				    subresource_state.access_mask != destination_access || repeated_write) {
+					vk::ImageMemoryBarrier2 barrier {};
+					barrier.srcStageMask                    = subresource_state.pl_stage;
+					barrier.srcAccessMask                   = subresource_state.access_mask;
+					barrier.dstStageMask                    = destination_stage;
+					barrier.dstAccessMask                   = destination_access;
+					barrier.oldLayout                       = subresource_state.layout;
+					barrier.newLayout                       = destination_layout;
+					barrier.srcQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
+					barrier.dstQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
+					barrier.image                           = backing.image;
+					barrier.subresourceRange.aspectMask     = FullAspectMask(backing.format);
+					barrier.subresourceRange.baseMipLevel   = level;
+					barrier.subresourceRange.levelCount     = 1;
+					barrier.subresourceRange.baseArrayLayer = layer;
+					barrier.subresourceRange.layerCount     = 1;
+					barriers.push_back(barrier);
+					subresource_state = {destination_stage, destination_access, destination_layout};
+				}
+			}
+		}
+
+		if (!partial) {
+			subresource_states.clear();
+		}
+	} else {
+		constexpr auto write_access   = vk::AccessFlagBits2::eTransferWrite |
+		                                vk::AccessFlagBits2::eShaderWrite |
+		                                vk::AccessFlagBits2::eMemoryWrite;
+		const bool     repeated_write = static_cast<bool>(state.access_mask & write_access);
+		if (state.layout == destination_layout && state.access_mask == destination_access &&
+		    !repeated_write) {
+			return {};
+		}
+
+		vk::ImageMemoryBarrier2 barrier {};
+		barrier.srcStageMask                    = state.pl_stage;
+		barrier.srcAccessMask                   = state.access_mask;
+		barrier.dstStageMask                    = destination_stage;
+		barrier.dstAccessMask                   = destination_access;
+		barrier.oldLayout                       = state.layout;
+		barrier.newLayout                       = destination_layout;
+		barrier.srcQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
+		barrier.dstQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
+		barrier.image                           = backing.image;
+		barrier.subresourceRange.aspectMask     = FullAspectMask(backing.format);
+		barrier.subresourceRange.baseMipLevel   = 0;
+		barrier.subresourceRange.levelCount     = VK_REMAINING_MIP_LEVELS;
+		barrier.subresourceRange.baseArrayLayer = 0;
+		barrier.subresourceRange.layerCount     = VK_REMAINING_ARRAY_LAYERS;
+		barriers.push_back(barrier);
+	}
+
+	state = {destination_stage, destination_access, destination_layout};
+	return barriers;
+}
+
+void Image::Transit(vk::ImageLayout destination_layout, vk::AccessFlags2 destination_access,
+                    std::optional<ImageSubresourceRange> range, vk::CommandBuffer command_buffer) {
+	const auto transfer_access =
+	    vk::AccessFlagBits2::eTransferRead | vk::AccessFlagBits2::eTransferWrite;
+	vk::PipelineStageFlags2 destination_stage {};
+	if (static_cast<bool>(destination_access & transfer_access)) {
+		destination_stage |= vk::PipelineStageFlagBits2::eTransfer;
+	}
+	if (!destination_access ||
+	    static_cast<bool>(destination_access & ~vk::AccessFlags2 {transfer_access})) {
+		destination_stage |=
+		    vk::PipelineStageFlagBits2::eAllGraphics | vk::PipelineStageFlagBits2::eComputeShader;
+	}
+	const auto barriers =
+	    GetBarriers(destination_layout, destination_access, destination_stage, range);
+	if (barriers.empty()) {
+		return;
+	}
+	if (m_scheduler != nullptr) {
+		m_scheduler->EndRendering();
+	}
+	vk::DependencyInfo dependency {};
+	dependency.imageMemoryBarrierCount = static_cast<uint32_t>(barriers.size());
+	dependency.pImageMemoryBarriers    = barriers.data();
+	command_buffer.pipelineBarrier2(dependency);
+}
+
+void Image::Upload(std::span<const vk::BufferImageCopy> copies, vk::Buffer buffer, uint64_t offset,
+                   uint64_t size) {
+	EXIT_IF(m_scheduler == nullptr || copies.empty() || buffer == nullptr || size == 0);
+	m_scheduler->EndRendering();
+	vk::BufferMemoryBarrier2 buffer_barrier {};
+	buffer_barrier.srcStageMask        = vk::PipelineStageFlagBits2::eAllCommands;
+	buffer_barrier.srcAccessMask       = vk::AccessFlagBits2::eMemoryWrite;
+	buffer_barrier.dstStageMask        = vk::PipelineStageFlagBits2::eTransfer;
+	buffer_barrier.dstAccessMask       = vk::AccessFlagBits2::eTransferRead;
+	buffer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	buffer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	buffer_barrier.buffer              = buffer;
+	buffer_barrier.offset              = offset;
+	buffer_barrier.size                = size;
+	const auto image_barriers =
+	    GetBarriers(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite,
+	                vk::PipelineStageFlagBits2::eCopy, {});
+	vk::DependencyInfo dependency {};
+	dependency.dependencyFlags          = vk::DependencyFlagBits::eByRegion;
+	dependency.bufferMemoryBarrierCount = 1;
+	dependency.pBufferMemoryBarriers    = &buffer_barrier;
+	dependency.imageMemoryBarrierCount  = static_cast<uint32_t>(image_barriers.size());
+	dependency.pImageMemoryBarriers     = image_barriers.data();
+	auto command                        = m_scheduler->Current().Handle();
+	command.pipelineBarrier2(dependency);
+	command.copyBufferToImage(buffer, backing.image, vk::ImageLayout::eTransferDstOptimal,
+	                          static_cast<uint32_t>(copies.size()), copies.data());
+	buffer_barrier.srcStageMask  = vk::PipelineStageFlagBits2::eTransfer;
+	buffer_barrier.srcAccessMask = vk::AccessFlagBits2::eTransferRead;
+	buffer_barrier.dstStageMask  = vk::PipelineStageFlagBits2::eAllCommands;
+	buffer_barrier.dstAccessMask =
+	    vk::AccessFlagBits2::eMemoryRead | vk::AccessFlagBits2::eMemoryWrite;
+	dependency.imageMemoryBarrierCount = 0;
+	dependency.pImageMemoryBarriers    = nullptr;
+	command.pipelineBarrier2(dependency);
+	Transit(vk::ImageLayout::eGeneral,
+	        vk::AccessFlagBits2::eShaderRead | vk::AccessFlagBits2::eTransferRead, {}, command);
+}
+
+void Image::Download(std::span<const vk::BufferImageCopy> copies, vk::Buffer buffer,
+                     uint64_t offset, uint64_t size) {
+	EXIT_IF(m_scheduler == nullptr || copies.empty() || buffer == nullptr || size == 0);
+	m_scheduler->EndRendering();
+	vk::BufferMemoryBarrier2 buffer_barrier {};
+	buffer_barrier.srcStageMask = vk::PipelineStageFlagBits2::eAllCommands;
+	buffer_barrier.srcAccessMask =
+	    vk::AccessFlagBits2::eMemoryRead | vk::AccessFlagBits2::eMemoryWrite;
+	buffer_barrier.dstStageMask        = vk::PipelineStageFlagBits2::eCopy;
+	buffer_barrier.dstAccessMask       = vk::AccessFlagBits2::eTransferWrite;
+	buffer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	buffer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	buffer_barrier.buffer              = buffer;
+	buffer_barrier.offset              = offset;
+	buffer_barrier.size                = size;
+	const auto image_barriers =
+	    GetBarriers(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead,
+	                vk::PipelineStageFlagBits2::eCopy, {});
+	vk::DependencyInfo dependency {};
+	dependency.dependencyFlags          = vk::DependencyFlagBits::eByRegion;
+	dependency.bufferMemoryBarrierCount = 1;
+	dependency.pBufferMemoryBarriers    = &buffer_barrier;
+	dependency.imageMemoryBarrierCount  = static_cast<uint32_t>(image_barriers.size());
+	dependency.pImageMemoryBarriers     = image_barriers.data();
+	auto command                        = m_scheduler->Current().Handle();
+	command.pipelineBarrier2(dependency);
+	command.copyImageToBuffer(backing.image, vk::ImageLayout::eTransferSrcOptimal, buffer,
+	                          static_cast<uint32_t>(copies.size()), copies.data());
+	buffer_barrier.srcStageMask  = vk::PipelineStageFlagBits2::eCopy;
+	buffer_barrier.srcAccessMask = vk::AccessFlagBits2::eTransferWrite;
+	buffer_barrier.dstStageMask  = vk::PipelineStageFlagBits2::eAllCommands;
+	buffer_barrier.dstAccessMask =
+	    vk::AccessFlagBits2::eMemoryRead | vk::AccessFlagBits2::eMemoryWrite;
+	dependency.imageMemoryBarrierCount = 0;
+	dependency.pImageMemoryBarriers    = nullptr;
+	command.pipelineBarrier2(dependency);
+}
+
+std::pair<uint32_t, uint32_t> Image::SanitizeCopyLayers(const Image& source,
+                                                        const Image& destination, uint32_t depth) {
+	const auto source_type        = source.backing.image_type;
+	const auto destination_type   = destination.backing.image_type;
+	uint32_t   source_layers      = source.backing.layers;
+	uint32_t   destination_layers = destination.backing.layers;
+	if (source_type == vk::ImageType::e3D) {
+		source_layers = 1;
+	}
+	if (destination_type == vk::ImageType::e3D) {
+		destination_layers = 1;
+	}
+	if (source_type == destination_type) {
+		source_layers = destination_layers = std::min(source_layers, destination_layers);
+	} else if (source_type == vk::ImageType::e2D && destination_type == vk::ImageType::e3D) {
+		source_layers = depth;
+	} else if (source_type == vk::ImageType::e3D && destination_type == vk::ImageType::e2D) {
+		destination_layers = depth;
+	}
+	return {source_layers, destination_layers};
+}
+
+void Image::CopyImage(Image& source) {
+	EXIT_IF(m_scheduler == nullptr || source.backing.samples != backing.samples);
+	m_scheduler->EndRendering();
+	const uint32_t levels     = std::min(source.backing.mip_levels, backing.mip_levels);
+	const uint32_t base_depth = backing.image_type == vk::ImageType::e3D
+	                                ? backing.extent.depth
+	                                : source.backing.extent.depth;
+	const auto     source_aspect =
+	    FullAspectMask(source.backing.format) & ~vk::ImageAspectFlagBits::eStencil;
+	const auto destination_aspect =
+	    FullAspectMask(backing.format) & ~vk::ImageAspectFlagBits::eStencil;
+	std::vector<vk::ImageCopy> copies;
+	copies.reserve(levels);
+	for (uint32_t level = 0; level < levels; level++) {
+		const auto width  = std::max(source.backing.extent.width >> level, 1u);
+		const auto height = std::max(source.backing.extent.height >> level, 1u);
+		const auto depth  = std::max(base_depth >> level, 1u);
+		const auto [source_layers, destination_layers] = SanitizeCopyLayers(source, *this, depth);
+		vk::ImageCopy copy {};
+		copy.srcSubresource = {source_aspect, level, 0, 1};
+		copy.dstSubresource = {destination_aspect, level, 0, 1};
+		if (source.backing.image_type == backing.image_type) {
+			if (source.backing.image_type == vk::ImageType::e3D) {
+				copy.extent = {width, height, depth};
+			} else {
+				copy.srcSubresource.layerCount = std::min(source_layers, destination_layers);
+				copy.dstSubresource.layerCount = copy.srcSubresource.layerCount;
+				copy.extent                    = {width, height, 1};
+			}
+		} else if (source.backing.image_type == vk::ImageType::e2D) {
+			copy.srcSubresource.layerCount = source_layers;
+			copy.extent                    = {width, height, source_layers};
+		} else {
+			copy.dstSubresource.layerCount = destination_layers;
+			copy.extent                    = {width, height, destination_layers};
+		}
+		copies.push_back(copy);
+	}
+	if (copies.empty()) {
+		return;
+	}
+	auto command = m_scheduler->Current().Handle();
+	source.Transit(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead, {},
+	               command);
+	Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite, {}, command);
+	command.copyImage(source.backing.image, vk::ImageLayout::eTransferSrcOptimal, backing.image,
+	                  vk::ImageLayout::eTransferDstOptimal, static_cast<uint32_t>(copies.size()),
+	                  copies.data());
+	Transit(vk::ImageLayout::eGeneral,
+	        vk::AccessFlagBits2::eShaderRead | vk::AccessFlagBits2::eTransferRead, {}, command);
+}
+
+void Image::Resolve(Image& source, const ImageSubresourceRange& source_range,
+                    const ImageSubresourceRange& destination_range) {
+	EXIT_IF(m_scheduler == nullptr || backing.samples != 1 ||
+	        source.backing.image_type != vk::ImageType::e2D ||
+	        backing.image_type != vk::ImageType::e2D || source_range.level_count != 1 ||
+	        destination_range.level_count != 1 ||
+	        source_range.base_level >= source.backing.mip_levels ||
+	        destination_range.base_level >= backing.mip_levels ||
+	        source_range.base_layer >= source.backing.layers ||
+	        destination_range.base_layer >= backing.layers);
+	const auto layers       = std::min({source_range.layer_count, destination_range.layer_count,
+	                                    source.backing.layers - source_range.base_layer,
+	                                    backing.layers - destination_range.base_layer});
+	const auto source_width = std::max(source.backing.extent.width >> source_range.base_level, 1u);
+	const auto source_height =
+	    std::max(source.backing.extent.height >> source_range.base_level, 1u);
+	const auto destination_width =
+	    std::max(backing.extent.width >> destination_range.base_level, 1u);
+	const auto destination_height =
+	    std::max(backing.extent.height >> destination_range.base_level, 1u);
+	const bool copy = source.backing.samples == 1;
+	EXIT_IF(layers == 0 || info.extent.width > source_width || info.extent.height > source_height ||
+	        info.extent.width > destination_width || info.extent.height > destination_height ||
+	        (copy ? !ImageViewOps::FormatsCompatible(source.backing.format, backing.format)
+	              : source.backing.format != backing.format));
+	auto resolved_source_range             = source_range;
+	auto resolved_destination_range        = destination_range;
+	resolved_source_range.layer_count      = layers;
+	resolved_destination_range.layer_count = layers;
+	const vk::Extent3D resolve_extent {info.extent.width, info.extent.height, 1};
+
+	m_scheduler->EndRendering();
+	auto command = m_scheduler->Current().Handle();
+	source.Transit(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead,
+	               resolved_source_range, command);
+	Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite,
+	        resolved_destination_range, command);
+	if (copy) {
+		vk::ImageCopy region {};
+		region.srcSubresource = {vk::ImageAspectFlagBits::eColor, resolved_source_range.base_level,
+		                         resolved_source_range.base_layer, layers};
+		region.dstSubresource = {vk::ImageAspectFlagBits::eColor,
+		                         resolved_destination_range.base_level,
+		                         resolved_destination_range.base_layer, layers};
+		region.extent         = resolve_extent;
+		command.copyImage(source.backing.image, vk::ImageLayout::eTransferSrcOptimal, backing.image,
+		                  vk::ImageLayout::eTransferDstOptimal, region);
+	} else {
+		vk::ImageResolve region {};
+		region.srcSubresource = {vk::ImageAspectFlagBits::eColor, resolved_source_range.base_level,
+		                         resolved_source_range.base_layer, layers};
+		region.dstSubresource = {vk::ImageAspectFlagBits::eColor,
+		                         resolved_destination_range.base_level,
+		                         resolved_destination_range.base_layer, layers};
+		region.extent         = resolve_extent;
+		command.resolveImage(source.backing.image, vk::ImageLayout::eTransferSrcOptimal,
+		                     backing.image, vk::ImageLayout::eTransferDstOptimal, region);
+	}
+}
+
+uint32_t Image::CopyRows(uint64_t row_size, uint32_t rows, uint64_t capacity) noexcept {
+	if (row_size == 0 || rows == 0 || row_size > capacity) {
+		return 0;
+	}
+	return static_cast<uint32_t>(std::min<uint64_t>(rows, capacity / row_size));
+}
+
+void Image::CopyImageWithBuffer(Image& source, Buffer& buffer) {
+	EXIT_IF(m_scheduler == nullptr || buffer.Handle() == nullptr || source.backing.samples != 1 ||
+	        backing.samples != 1);
+	m_scheduler->EndRendering();
+	const uint32_t levels = std::min(source.backing.mip_levels, backing.mip_levels);
+	const auto     source_aspect =
+	    FullAspectMask(source.backing.format) & ~vk::ImageAspectFlagBits::eStencil;
+	const auto destination_aspect =
+	    FullAspectMask(backing.format) & ~vk::ImageAspectFlagBits::eStencil;
+	const auto     source_bytes      = DepthAspectTransferBytes(source.backing.format) != 0
+	                                       ? DepthAspectTransferBytes(source.backing.format)
+	                                       : source.info.bytes_per_block;
+	const auto     destination_bytes = DepthAspectTransferBytes(backing.format) != 0
+	                                       ? DepthAspectTransferBytes(backing.format)
+	                                       : info.bytes_per_block;
+	const uint32_t source_block      = source.info.IsBlock() ? 4u : 1u;
+	const uint32_t destination_block = info.IsBlock() ? 4u : 1u;
+	EXIT_IF(levels == 0 || source_bytes == 0 || source_bytes != destination_bytes ||
+	        source_block != destination_block);
+
+	vk::BufferMemoryBarrier2 barrier {};
+	barrier.srcStageMask        = vk::PipelineStageFlagBits2::eTransfer;
+	barrier.srcAccessMask       = vk::AccessFlagBits2::eTransferRead;
+	barrier.dstStageMask        = vk::PipelineStageFlagBits2::eTransfer;
+	barrier.dstAccessMask       = vk::AccessFlagBits2::eTransferWrite;
+	barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+	barrier.buffer              = buffer.Handle();
+	barrier.offset              = 0;
+	vk::DependencyInfo dependency {};
+	dependency.dependencyFlags          = vk::DependencyFlagBits::eByRegion;
+	dependency.bufferMemoryBarrierCount = 1;
+	dependency.pBufferMemoryBarriers    = &barrier;
+	auto command                        = m_scheduler->Current().Handle();
+	source.Transit(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead, {},
+	               command);
+	Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite, {}, command);
+	for (uint32_t level = 0; level < levels; level++) {
+		const auto width             = std::max(source.backing.extent.width >> level, 1u);
+		const auto height            = std::max(source.backing.extent.height >> level, 1u);
+		const auto source_depth      = source.backing.image_type == vk::ImageType::e3D
+		                                   ? std::max(source.backing.extent.depth >> level, 1u)
+		                                   : source.backing.layers;
+		const auto destination_depth = backing.image_type == vk::ImageType::e3D
+		                                   ? std::max(backing.extent.depth >> level, 1u)
+		                                   : backing.layers;
+		const auto slices            = std::min(source_depth, destination_depth);
+		const auto block_rows        = (height + source_block - 1) / source_block;
+		const auto row_size =
+		    static_cast<uint64_t>((width + source_block - 1) / source_block) * source_bytes;
+		const auto rows_per_copy = CopyRows(row_size, block_rows, buffer.Size());
+		EXIT_IF(slices == 0 || rows_per_copy == 0);
+		for (uint32_t slice = 0; slice < slices; slice++) {
+			for (uint32_t block_row = 0; block_row < block_rows; block_row += rows_per_copy) {
+				const auto          copy_rows   = std::min(rows_per_copy, block_rows - block_row);
+				const auto          y           = block_row * source_block;
+				const auto          copy_height = std::min(copy_rows * source_block, height - y);
+				const auto          copy_size   = row_size * copy_rows;
+				vk::BufferImageCopy source_copy {};
+				source_copy.imageSubresource = {
+				    source_aspect, level,
+				    source.backing.image_type == vk::ImageType::e3D ? 0u : slice, 1};
+				source_copy.imageOffset           = {0, static_cast<int32_t>(y),
+				                                     source.backing.image_type == vk::ImageType::e3D
+				                                         ? static_cast<int32_t>(slice)
+				                                         : 0};
+				source_copy.imageExtent           = {width, copy_height, 1};
+				auto destination_copy             = source_copy;
+				destination_copy.imageSubresource = {
+				    destination_aspect, level,
+				    backing.image_type == vk::ImageType::e3D ? 0u : slice, 1};
+				destination_copy.imageOffset.z =
+				    backing.image_type == vk::ImageType::e3D ? static_cast<int32_t>(slice) : 0;
+				barrier.size          = copy_size;
+				barrier.srcAccessMask = vk::AccessFlagBits2::eTransferRead;
+				barrier.dstAccessMask = vk::AccessFlagBits2::eTransferWrite;
+				command.pipelineBarrier2(dependency);
+				command.copyImageToBuffer(source.backing.image,
+				                          vk::ImageLayout::eTransferSrcOptimal, buffer.Handle(),
+				                          source_copy);
+				barrier.srcAccessMask = vk::AccessFlagBits2::eTransferWrite;
+				barrier.dstAccessMask = vk::AccessFlagBits2::eTransferRead;
+				command.pipelineBarrier2(dependency);
+				command.copyBufferToImage(buffer.Handle(), backing.image,
+				                          vk::ImageLayout::eTransferDstOptimal, destination_copy);
+			}
+		}
+	}
+	Transit(vk::ImageLayout::eGeneral,
+	        vk::AccessFlagBits2::eShaderRead | vk::AccessFlagBits2::eTransferRead, {}, command);
+}
+
+void Image::CopyMip(Image& source, uint32_t mip, uint32_t layer) {
+	EXIT_IF(m_scheduler == nullptr || source.backing.samples != backing.samples ||
+	        mip >= backing.mip_levels || layer >= backing.layers);
+	m_scheduler->EndRendering();
+	const auto width  = std::max(backing.extent.width >> mip, 1u);
+	const auto height = std::max(backing.extent.height >> mip, 1u);
+	const auto depth  = std::max(backing.extent.depth >> mip, 1u);
+	EXIT_IF(width != source.backing.extent.width || height != source.backing.extent.height);
+	const auto [source_layers, destination_layers] = SanitizeCopyLayers(source, *this, depth);
+	const auto aspects                             = FullAspectMask(source.backing.format);
+	EXIT_IF(aspects != FullAspectMask(backing.format));
+	std::array<vk::ImageCopy, 2> copies {};
+	uint32_t                     copy_count = 0;
+	for (const auto aspect: {vk::ImageAspectFlagBits::eColor, vk::ImageAspectFlagBits::eDepth,
+	                         vk::ImageAspectFlagBits::eStencil}) {
+		if (!static_cast<bool>(aspects & aspect)) {
+			continue;
+		}
+		auto& copy          = copies[copy_count++];
+		copy.srcSubresource = {aspect, 0, 0, source_layers};
+		copy.dstSubresource = {aspect, mip, layer, destination_layers};
+		copy.extent         = {width, height, depth};
+	}
+	auto command = m_scheduler->Current().Handle();
+	Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite, {}, command);
+	source.Transit(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead, {},
+	               command);
+	command.copyImage(source.backing.image, vk::ImageLayout::eTransferSrcOptimal, backing.image,
+	                  vk::ImageLayout::eTransferDstOptimal, copy_count, copies.data());
+	Transit(vk::ImageLayout::eGeneral,
+	        vk::AccessFlagBits2::eShaderRead | vk::AccessFlagBits2::eTransferRead, {}, command);
+}
+
+namespace ImageOps {
+
+void Validate(const ImageInfo& info) {
+	ValidateRange(info.data, "data");
+	ValidateRange(info.stencil, "stencil");
+
+	if (info.pixel_format == vk::Format::eUndefined) {
+		const bool metadata_empty =
+		    info.metadata.range.address == 0 && info.metadata.range.size == 0 &&
+		    info.metadata.kind == ImageMetadataKind::None && info.metadata.control == 0 &&
+		    info.metadata.compression == VideoOutCompression::Uncompressed &&
+		    !info.metadata.stencil_compressed;
+		if (info.data.Empty() || info.HasStencil() || !metadata_empty || info.extent.width == 0 ||
+		    info.extent.height == 0 || info.extent.depth == 0 || info.resources.levels != 1 ||
+		    info.resources.layers != 1 || info.samples != 1 || info.pitch != 0 ||
+		    info.bytes_per_block != 0) {
+			EXIT("invalid stencil association image\n");
+		}
+		return;
+	}
+
+	if (info.extent.width == 0 || info.extent.height == 0 || info.extent.depth == 0 ||
+	    info.resources.levels == 0 || info.resources.levels > info.mip_layout.size() ||
+	    info.resources.layers == 0 || info.samples == 0 ||
+	    vulkan_sample_count(info.samples) == vk::SampleCountFlagBits {} ||
+	    info.bytes_per_block == 0 || (info.data.address != 0 && info.pitch == 0)) {
+		EXIT("invalid image geometry or format\n");
+	}
+
+	switch (info.type) {
+		case Prospero::ImageType::kColor1D:
+			if (info.extent.height != 1 || info.extent.depth != 1) {
+				EXIT("invalid 1D image shape\n");
+			}
+			break;
+		case Prospero::ImageType::kColor3D:
+			if (info.resources.layers != 1) {
+				EXIT("3D images cannot have array layers\n");
+			}
+			break;
+		case Prospero::ImageType::kColor2D:
+			if (info.extent.depth != 1) {
+				EXIT("invalid 2D image shape\n");
+			}
+			break;
+		default: EXIT("non-base image type: %u\n", static_cast<uint32_t>(info.type));
+	}
+	if (info.samples > 1 && info.resources.levels != 1) {
+		EXIT("multisampled images cannot have mip levels\n");
+	}
+
+	if (info.metadata.stencil_compressed && !info.HasStencil()) {
+		EXIT("compressed stencil metadata requires a stencil plane\n");
+	}
+	switch (info.metadata.kind) {
+		case ImageMetadataKind::None:
+			if (info.metadata.range.address != 0 || info.metadata.range.size != 0 ||
+			    info.metadata.control != 0 ||
+			    info.metadata.compression != VideoOutCompression::Uncompressed ||
+			    info.metadata.stencil_compressed) {
+				EXIT("metadata-free image has metadata state\n");
+			}
+			break;
+		case ImageMetadataKind::Htile:
+			ValidateRange(info.metadata.range, "HTILE");
+			if (info.metadata.range.Empty() ||
+			    info.metadata.compression != VideoOutCompression::Uncompressed) {
+				EXIT("invalid HTILE metadata\n");
+			}
+			break;
+		case ImageMetadataKind::Dcc:
+			if (info.metadata.range.address == 0 ||
+			    info.metadata.range.address >= TRACKER_ADDRESS_SIZE ||
+			    (info.metadata.range.size != 0 &&
+			     info.metadata.range.size > TRACKER_ADDRESS_SIZE - info.metadata.range.address) ||
+			    info.metadata.compression == VideoOutCompression::Unsupported) {
+				EXIT("invalid DCC metadata\n");
+			}
+			break;
+	}
+}
+
+uint32_t RenderTargetTransferFormat(uint32_t bytes_per_element) {
+	switch (bytes_per_element) {
+		case 1: return Prospero::GpuEnumValue(Prospero::BufferFormat::k8UNorm);
+		case 2: return Prospero::GpuEnumValue(Prospero::BufferFormat::k16UNorm);
+		case 4: return Prospero::GpuEnumValue(Prospero::BufferFormat::k32Float);
+		case 8: return Prospero::GpuEnumValue(Prospero::BufferFormat::k16_16_16_16Float);
+		case 16: return Prospero::GpuEnumValue(Prospero::BufferFormat::k32_32_32_32Float);
+		default: EXIT("unsupported render-target element size: %u\n", bytes_per_element);
+	}
+}
+
+} // namespace ImageOps
+
+Image::Image(GraphicContext& graphics, CommandScheduler& scheduler, const ImageInfo& image_info)
+    : info(image_info), m_graphics(&graphics), m_scheduler(&scheduler) {
+	KYTY_PROFILER_FUNCTION();
+	ImageOps::Validate(info);
+	m_cpu_dirty = !info.data.Empty();
+	if (info.pixel_format == vk::Format::eUndefined) {
+		return;
+	}
+
+	backing.format      = info.pixel_format;
+	backing.image_type  = HostImageType(info.type);
+	backing.extent      = info.extent;
+	backing.guest_pitch = info.pitch;
+	backing.layers      = info.IsVolume() ? 1u : info.resources.layers;
+	backing.mip_levels  = info.resources.levels;
+	backing.samples     = info.samples;
+	backing.flags       = ImageCreateFlags(info);
+	backing.usage       = ImageUsageFlags(graphics, info);
+
+	vk::ImageCreateInfo create {};
+	create.sType         = vk::StructureType::eImageCreateInfo;
+	create.flags         = backing.flags;
+	create.imageType     = backing.image_type;
+	create.extent        = backing.extent;
+	create.mipLevels     = backing.mip_levels;
+	create.arrayLayers   = backing.layers;
+	create.format        = backing.format;
+	create.tiling        = vk::ImageTiling::eOptimal;
+	create.initialLayout = backing.state.layout;
+	create.usage         = backing.usage;
+	create.sharingMode   = vk::SharingMode::eExclusive;
+	create.samples       = vulkan_sample_count(backing.samples);
+
+	vk::ImageFormatProperties properties {};
+	if (graphics.GetImageFormatProperties(create.format, create.imageType, create.tiling,
+	                                      create.usage, create.flags,
+	                                      &properties) != vk::Result::eSuccess ||
+	    !static_cast<bool>(properties.sampleCounts & create.samples)) {
+		EXIT("image format does not support required usage: format=%d type=%d usage=0x%x "
+		     "flags=0x%x samples=%u\n",
+		     static_cast<int>(create.format), static_cast<int>(create.imageType),
+		     static_cast<vk::ImageUsageFlags::MaskType>(create.usage),
+		     static_cast<vk::ImageCreateFlags::MaskType>(create.flags), backing.samples);
+	}
+
+	backing.memory.property = vk::MemoryPropertyFlagBits::eDeviceLocal;
+	if (!graphics.CreateImage(create, backing)) {
+		EXIT("failed to create image: extent=%ux%ux%u format=%d layers=%u levels=%u\n",
+		     create.extent.width, create.extent.height, create.extent.depth,
+		     static_cast<int>(create.format), create.arrayLayers, create.mipLevels);
+	}
+}
+
+uint64_t Image::HashGuestEdges() const {
+	constexpr uint64_t                         page_mask = TRACKER_PAGE_SIZE - 1;
+	std::array<uint8_t, TRACKER_PAGE_SIZE * 2> bytes {};
+	const auto                                 range = info.data;
+	const uint64_t head_end     = std::min(range.End(), (range.address + page_mask) & ~page_mask);
+	const uint64_t tail_begin   = std::max(range.address, range.End() & ~page_mask);
+	const uint64_t head_size    = head_end - range.address;
+	const uint64_t tail_address = tail_begin < head_end ? head_end : tail_begin;
+	const uint64_t tail_size    = range.End() - tail_address;
+	if ((head_size != 0 &&
+	     !LibKernel::Memory::TryReadBacking(range.address, bytes.data(), head_size)) ||
+	    (tail_size != 0 &&
+	     !LibKernel::Memory::TryReadBacking(tail_address, bytes.data() + head_size, tail_size))) {
+		EXIT("Image: failed to hash guest backing\n");
+	}
+	return XXH3_64bits(bytes.data(), static_cast<size_t>(head_size + tail_size));
+}
+
+Image::~Image() {
+	KYTY_PROFILER_FUNCTION();
+	if (m_graphics == nullptr) {
+		return;
+	}
+	{
+		std::lock_guard lock(views.mutex);
+		for (auto& cached: views.views) {
+			if (cached.view != nullptr) {
+				m_graphics->device.destroyImageView(cached.view, nullptr);
+				cached.view = nullptr;
+			}
+		}
+		views.views.clear();
+	}
+	if (backing.image != nullptr) {
+		m_graphics->DeleteImage(backing);
+	}
+}
+
+} // namespace Libs::Graphics

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

@@ -0,0 +1,198 @@
+#ifndef EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_
+#define EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_
+
+#include "common/assert.h"
+#include "graphics/host_gpu/graphicContext.h"
+#include "graphics/host_gpu/renderer/image/imageInfo.h"
+
+#include <compare>
+#include <limits>
+#include <mutex>
+#include <optional>
+#include <span>
+#include <utility>
+#include <vector>
+
+namespace Libs::Graphics {
+
+class Buffer;
+class CommandScheduler;
+struct ImageTestAccess;
+
+struct ImageId {
+	uint32_t index      = std::numeric_limits<uint32_t>::max();
+	uint32_t generation = 0;
+
+	[[nodiscard]] explicit operator bool() const noexcept {
+		return index != std::numeric_limits<uint32_t>::max();
+	}
+	auto operator<=>(const ImageId&) const = default;
+};
+
+struct CachedImageView {
+	ImageViewInfo info;
+	vk::ImageView view = nullptr;
+};
+
+struct ImageViewCache {
+	ImageViewCache() = default;
+	KYTY_CLASS_NO_COPY(ImageViewCache);
+
+	std::mutex                   mutex;
+	std::vector<CachedImageView> views;
+};
+
+struct ImageUsage {
+	bool texture       = false;
+	bool storage       = false;
+	bool render_target = false;
+	bool depth_target  = false;
+	bool video_out     = false;
+};
+
+struct ImageBinding {
+	bool is_bound      = false;
+	bool is_target     = false;
+	bool needs_rebind  = false;
+	bool force_general = false;
+};
+
+class Image final {
+public:
+	Image(GraphicContext& graphics, CommandScheduler& scheduler, const ImageInfo& info);
+	~Image();
+	KYTY_CLASS_NO_COPY(Image);
+
+	[[nodiscard]] vk::ImageView FindView(const ImageViewInfo& view_info);
+	void                        AssociateDepth(ImageId image_id) { depth_id = image_id; }
+	using Barriers = std::vector<vk::ImageMemoryBarrier2>;
+	[[nodiscard]] Barriers GetBarriers(vk::ImageLayout                      destination_layout,
+	                                   vk::AccessFlags2                     destination_access,
+	                                   vk::PipelineStageFlags2              destination_stage,
+	                                   std::optional<ImageSubresourceRange> range);
+	void Transit(vk::ImageLayout destination_layout, vk::AccessFlags2 destination_access,
+	             std::optional<ImageSubresourceRange> range, vk::CommandBuffer command_buffer);
+	void Upload(std::span<const vk::BufferImageCopy> copies, vk::Buffer buffer, uint64_t offset,
+	            uint64_t size);
+	void Download(std::span<const vk::BufferImageCopy> copies, vk::Buffer buffer, uint64_t offset,
+	              uint64_t size);
+	void CopyImage(Image& source);
+	void Resolve(Image& source, const ImageSubresourceRange& source_range,
+	             const ImageSubresourceRange& destination_range);
+	void CopyImageWithBuffer(Image& source, Buffer& buffer);
+	void CopyMip(Image& source, uint32_t mip, uint32_t layer);
+
+	void InvalidateCpuWrite(uint64_t vaddr, uint64_t size) {
+		if (ImageRangeOverlaps(info.data.address, info.data.size, vaddr, size)) {
+			m_cpu_dirty        = true;
+			m_maybe_cpu_dirty  = false;
+			m_maybe_hash_valid = false;
+		} else if (ImagePageRangesOverlap(info.data.address, info.data.size, vaddr, size)) {
+			m_maybe_cpu_dirty = true;
+		}
+	}
+
+	[[nodiscard]] bool IsCpuDirty() const { return m_cpu_dirty || m_maybe_cpu_dirty; }
+	[[nodiscard]] bool IsDefinitelyCpuDirty() const { return m_cpu_dirty; }
+	[[nodiscard]] bool IsMaybeCpuDirty() const { return m_maybe_cpu_dirty; }
+	void               MarkMaybeCpuDirty() {
+		if (!m_cpu_dirty) {
+			m_maybe_cpu_dirty = true;
+		}
+	}
+	[[nodiscard]] bool NeedsMaybeCpuHash() const {
+		return m_maybe_cpu_dirty && !m_maybe_hash_valid;
+	}
+	void SetMaybeCpuHash(uint64_t hash) {
+		if (!NeedsMaybeCpuHash()) {
+			EXIT("image cannot initialize maybe-dirty hash\n");
+		}
+		m_maybe_cpu_hash   = hash;
+		m_maybe_hash_valid = true;
+	}
+	[[nodiscard]] bool ResolveMaybeCpuHash(uint64_t hash) {
+		if (!m_maybe_cpu_dirty || !m_maybe_hash_valid || m_cpu_dirty) {
+			EXIT("image cannot resolve maybe-dirty hash\n");
+		}
+		m_maybe_cpu_dirty  = false;
+		m_maybe_hash_valid = false;
+		m_cpu_dirty |= hash != m_maybe_cpu_hash;
+		return m_cpu_dirty;
+	}
+
+	void RefreshComplete() {
+		if (!IsCpuDirty()) {
+			EXIT("clean image cannot complete a refresh\n");
+		}
+		m_cpu_dirty        = false;
+		m_maybe_cpu_dirty  = false;
+		m_maybe_hash_valid = false;
+	}
+
+	[[nodiscard]] bool IsGpuModified() const noexcept { return m_gpu_modified; }
+	void               MarkGpuModified() noexcept { m_gpu_modified = true; }
+	void               ClearGpuModified() noexcept { m_gpu_modified = false; }
+
+	[[nodiscard]] bool IsBufferModified() const noexcept { return m_buffer_modified; }
+	void               MarkBufferModified() noexcept { m_buffer_modified = true; }
+	void               ClearBufferModified() noexcept { m_buffer_modified = false; }
+
+	[[nodiscard]] bool Overlaps(uint64_t address, uint64_t size,
+	                            bool pages = false) const noexcept {
+		return pages ? ImagePageRangesOverlap(info.data.address, info.data.size, address, size)
+		             : ImageRangeOverlaps(info.data.address, info.data.size, address, size);
+	}
+	[[nodiscard]] bool GpuOverlaps(uint64_t address, uint64_t size) const noexcept {
+		return IsGpuModified() && Overlaps(address, size);
+	}
+	[[nodiscard]] bool SafeToDownload() const noexcept {
+		return IsGpuModified() && !IsBufferModified() && !IsCpuDirty();
+	}
+	[[nodiscard]] bool IsTracked() const noexcept { return track_addr != 0 && track_addr_end != 0; }
+	[[nodiscard]] uint64_t AccountedSize() const noexcept {
+		return backing.image == nullptr ? 0 : (info.data.size + 1023) & ~uint64_t {1023};
+	}
+	[[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;
+
+private:
+	friend struct ImageTestAccess;
+
+	[[nodiscard]] static vk::ImageAspectFlags FullAspectMask(vk::Format format) noexcept;
+	[[nodiscard]] static uint32_t             CopyRows(uint64_t row_size, uint32_t rows,
+	                                                   uint64_t capacity) noexcept;
+	[[nodiscard]] static std::pair<uint32_t, uint32_t>
+	SanitizeCopyLayers(const Image& source, const Image& destination, uint32_t depth);
+
+	GraphicContext*   m_graphics         = nullptr;
+	CommandScheduler* m_scheduler        = nullptr;
+	uint64_t          m_maybe_cpu_hash   = 0;
+	bool              m_cpu_dirty        = false;
+	bool              m_maybe_cpu_dirty  = false;
+	bool              m_maybe_hash_valid = false;
+	bool              m_gpu_modified     = false;
+	bool              m_buffer_modified  = false;
+};
+
+namespace ImageOps {
+
+void                   Validate(const ImageInfo& info);
+[[nodiscard]] uint32_t RenderTargetTransferFormat(uint32_t bytes_per_element);
+
+} // namespace ImageOps
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_IMAGE_H_