feat: identify build provenance in the crash log report (#196)

* feat: identify build provenance in the crash log report

* cmake: reuse git version dependency target

---------

Co-authored-by: nmzik <Nmzik@mail.ru>

src/common/CMakeLists.txt

@@ -24,6 +24,7 @@ target_link_libraries(common
 		Tracy::TracyClient
 	PRIVATE
 		cpuinfo
+		kyty_git_version
 		spdlog::spdlog
 )
 

src/common/assert.cpp

@@ -3,6 +3,7 @@
 #include "common/debug.h"
 #include "common/logging/log.h"
 #include "common/subsystems.h"
+#include "kytyGitVersion.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -23,7 +24,7 @@ static std::string BuildFatalReport(const char* title, std::string_view text, co
 	DebugStack stack;
 	DebugStack::Trace(&stack);
 
-	std::string report = "--- Stack Trace ---\n";
+	std::string report = "--- Build ---\n" KYTY_BUILD_LABEL "\n--- Stack Trace ---\n";
 	for (int i = PRINT_STACK_FROM; i < stack.depth; i++) {
 		report += fmt::format("[{}] {:016x}\n", i - PRINT_STACK_FROM,
 		                      static_cast<uint64_t>(stack.GetAddr(i)));

src/graphics/guest_gpu/command_processor/pm4Handlers.cpp

@@ -2682,14 +2682,21 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 	const bool gl2_writeback = ((gcr_cntl & GcrGl2Writeback) != 0);
 
 	auto trigger_interrupt = [&]() {
+		bool queued = false;
 		switch (interrupt_selector) {
 			case 0x00:
 			case 0x03: break;
 			case 0x01:
 			case 0x02:
-			case 0x04: cp.TriggerEopEventAtEndOfPipe(interrupt_context_id); break;
+			case 0x04:
+				cp.TriggerEopEventAtEndOfPipe(interrupt_context_id);
+				queued = true;
+				break;
 			default: EXIT("unknown release_mem interrupt selector\n");
 		}
+		if (queued) {
+			cp.BufferFlush();
+		}
 	};
 
 	if (data_sel == 0 || interrupt_selector == 4) {
@@ -2697,10 +2704,6 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 			cp.EmitGlobalBarrier();
 		}
 
-		if (gl2_writeback) {
-			cp.SynchronizeGpu();
-		}
-
 		trigger_interrupt();
 
 		return 7;
@@ -2711,10 +2714,6 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 			cp.EmitGlobalBarrier();
 		}
 
-		if (gl2_writeback) {
-			cp.SynchronizeGpu();
-		}
-
 		trigger_interrupt();
 
 		return 7;
@@ -2728,17 +2727,6 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 	cache_policy      = 0;
 
 	if (data_sel == 1) {
-		static std::atomic<uint32_t> log_count {0};
-		const auto                   dst_addr = reinterpret_cast<uint64_t>(dst_gpu_addr);
-		if ((dst_addr & 0xffffffffff000000ull) == 0x0000001021000000ull || log_count.load() < 64) {
-			if (log_count.fetch_add(1) < 256) {
-				LOGF(
-				    "\t runtime release_mem32: dst=0x%016" PRIx64 ", value=0x%08" PRIx32
-				    ", action=0x%02" PRIx32 ", gcr=0x%04" PRIx32 ", cache_action=0x%08" PRIx32 "\n",
-				    dst_addr, static_cast<uint32_t>(value), eop_event_type, gcr_cntl, cache_action);
-			}
-		}
-
 		eop_event_type    = 0x2f;
 		event_index       = 6;
 		auto event_source = 2u;
@@ -2753,7 +2741,6 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 
 	if (data_sel == 5) {
 		if (gl2_writeback) {
-			cp.SynchronizeGpu();
 			cache_action = 0;
 		}
 
@@ -2764,7 +2751,9 @@ KYTY_CP_OP_PARSER(CpOpReleaseMem) {
 		cp.WriteAtEndOfPipe32(cache_policy, event_write_dest, eop_event_type, cache_action,
 		                      event_index, event_source, dst_gpu_addr, static_cast<uint32_t>(value),
 		                      interrupt_selector, interrupt_context_id);
-		cp.BufferFlush();
+		if (interrupt_selector == 0x01) {
+			cp.BufferFlush();
+		}
 
 		return 7;
 	}

src/graphics/guest_gpu/graphicsRun.cpp

@@ -124,7 +124,6 @@ private:
 		uint64_t       flip_request_id               = 0;
 	};
 
-	void              WaitLocked();
 	void              Enqueue(Submission submission);
 	void              WaitForIdle();
 	void              ProcessCommands();
@@ -276,10 +275,8 @@ void GpuState::SubmitFlipPreparation(uint64_t request_id) {
 
 void GpuState::Done() {
 	GpuMutexLock lock(m_submission_mutex);
-	if (IsGpuThread()) {
-		m_gfx_cp->BufferWait();
-	} else {
-		WaitLocked();
+	if (!IsGpuThread()) {
+		WaitForIdle();
 	}
 	m_graphics_done = true;
 	m_done_num++;
@@ -289,11 +286,6 @@ int GpuState::GetFrameNum() {
 	return m_done_num;
 }
 
-void GpuState::WaitLocked() {
-	WaitForIdle();
-	SendCommandSync([this] { m_gfx_cp->BufferWait(); });
-}
-
 CommandProcessor& GpuState::GetProcessor(uint32_t queue_id) {
 	EXIT_IF(queue_id >= QueueCount);
 	if (queue_id == 0) {
@@ -307,8 +299,6 @@ CommandProcessor& GpuState::GetProcessor(uint32_t queue_id) {
 }
 
 void CommandProcessor::Reset() {
-	BufferWait();
-
 	m_sh_ctx.Reset();
 	m_ucfg.Reset();
 	m_ctx.Reset();
@@ -385,7 +375,6 @@ void CommandProcessor::WaitDeDiff(uint32_t diff) {
 }
 
 void CommandProcessor::IncrementDe() {
-	BufferWait();
 	m_de_count++;
 }
 
@@ -1352,6 +1341,9 @@ void CommandProcessor::WriteAtEndOfPipe(uint32_t cache_policy, uint32_t event_wr
 					              value >> 16u);
 					Sync::WriteAtEndOfPipeGds32(m_submit_id, CurrentBuffer(), dst, value & 0xffffu,
 					                            value >> 16u);
+					if (with_interrupt) {
+						m_renderer.TriggerEopEvent(interrupt_context_id);
+					}
 					return;
 				}
 			} else if (eop_event_type == 0x04 && cache_action == 0x00 && event_index == 0x05) {
@@ -1554,7 +1546,6 @@ void CommandProcessor::TriggerEvent(uint32_t event_type, uint32_t event_index) {
 				     event_index);
 			}
 			EmitGlobalBarrier();
-			SynchronizeGpu();
 			break;
 		// DbDataWritebackInvalidate, DbMetadataWritebackInvalidate, CbMetadataWritebackInvalidate.
 		case 0x0000002a:

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

@@ -22,30 +22,9 @@ 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 {
@@ -191,21 +170,18 @@ void BufferCache::QueueGarbageDownload(std::span<const DownloadCopy> copies, Ret
 	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);
+		    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);
 	    });
 }
 
@@ -276,9 +252,6 @@ void BufferCache::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 	    size > TRACKER_ADDRESS_SIZE - vaddr) {
 		EXIT("BufferCache: invalid memory-invalidation range\n");
 	}
-	if (!IsRegionRegistered(vaddr, size)) {
-		return;
-	}
 	m_memory_tracker.InvalidateRegion(vaddr, size,
 	                                  [this, vaddr, size] { ReadMemory(vaddr, size, true); });
 }
@@ -298,60 +271,58 @@ void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size, bool is_write) {
 }
 
 void BufferCache::ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write) {
+	// CPU invalidation reaches this point only for a GPU-owned tracker page. Resolve the exact
+	// Buffer owner on the GPU thread so the cache index remains single-thread-owned.
+	if (is_write && !IsRegionRegistered(vaddr, size)) {
+		return;
+	}
 	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;
+	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()) {
-			if (!is_write) {
-				return;
-			}
-			// A preceding read fault can consume the last GPU-owned copy after this write
-			// invalidation has already chosen to flush. Complete the CPU ownership handoff even
-			// though this callback no longer has bytes to download.
-			m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
+		    }
+	    });
+	if (copies.empty()) {
+		if (!is_write) {
 			return;
 		}
+		// A preceding read fault can consume the last GPU-owned copy after this write invalidation
+		// has already chosen to flush. Complete the CPU ownership handoff even though this callback
+		// no longer has bytes to download.
+		m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
+		return;
 	}
 	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);
-		if (is_write) {
-			m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
-		}
+	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);
+	if (is_write) {
+		m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
 	}
 }
 
@@ -362,43 +333,40 @@ void BufferCache::UnmapMemory(uint64_t vaddr, uint64_t size) {
 	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) {
+			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, cached]: m_buffers) {
+		if (vaddr >= begin + cached->size || begin >= vaddr + size ||
+		    !m_memory_tracker.IsRegionGpuModified(begin, cached->size)) {
+			continue;
 		}
-		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});
-				    }
-			    });
+		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);
@@ -409,29 +377,26 @@ void BufferCache::UnmapMemory(uint64_t vaddr, uint64_t size) {
 		// 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;
+	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;
 		}
 	}
 }
@@ -539,29 +504,22 @@ BufferBinding BufferCache::ObtainBuffer(CommandBuffer& command, uint64_t vaddr,
 		(void)m_texture_cache.InvalidateMemoryFromGPU(vaddr, size, true);
 	}
 
-	std::shared_ptr<Buffer> owner;
-	uint64_t                offset = 0;
-	{
-		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);
-		}
-		owner  = cached.buffer;
-		offset = cached.buffer->Offset(vaddr);
+	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);
 	}
+	auto     owner  = cached.buffer;
+	uint64_t offset = cached.buffer->Offset(vaddr);
 	if (is_formatted && is_read && !is_written) {
 		(void)SynchronizeBufferFromImage(*owner, vaddr, size);
 	}
@@ -569,19 +527,14 @@ BufferBinding BufferCache::ObtainBuffer(CommandBuffer& command, uint64_t 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;
+	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);
 	const std::array<uint8_t, 16> zeros {};
-	Upload(m_scheduler.Current(), *buffer, 0, zeros.data(), zeros.size());
-	return buffer;
+	Upload(m_scheduler.Current(), *m_null_buffer, 0, zeros.data(), zeros.size());
+	return m_null_buffer;
 }
 
 ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t size) {
@@ -599,11 +552,10 @@ ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t siz
 	};
 
 	{
-		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();
+		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");
 
@@ -674,10 +626,9 @@ ImageBufferSource BufferCache::ObtainBufferForImage(uint64_t vaddr, uint64_t siz
 	}
 	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();
+	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");
 	}
@@ -710,8 +661,7 @@ void BufferCache::WriteHostMemory(uint64_t vaddr, std::span<const uint8_t> data)
 	}
 	Libs::LibKernel::Memory::WriteBacking(vaddr, data.data(), data.size());
 
-	FaultSafeCacheLock lock(this, m_mutex);
-	const auto         end = vaddr + data.size();
+	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);
@@ -836,7 +786,6 @@ bool BufferCache::IsRegionRegistered(uint64_t vaddr, uint64_t size) {
 	    size > TRACKER_ADDRESS_SIZE - vaddr) {
 		EXIT("BufferCache: invalid registered-region query\n");
 	}
-	FaultSafeCacheLock lock(this, m_mutex);
 	// Cached buffers are ordered and non-overlapping. The last buffer beginning before the query
 	// end is therefore the only possible intersection.
 	const auto candidate = m_buffers.lower_bound(vaddr + size);
@@ -852,7 +801,6 @@ bool BufferCache::IsRegionGpuModified(uint64_t vaddr, uint64_t size) {
 }
 
 bool BufferCache::HasGpuDirtyBytes(uint64_t vaddr, uint64_t size) {
-	FaultSafeCacheLock lock(this, m_mutex);
 	return !m_gpu_modified_ranges.Intersections(vaddr, size).empty();
 }
 
@@ -876,7 +824,6 @@ void BufferCache::RunGarbageCollector() {
 	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;
@@ -924,7 +871,6 @@ void BufferCache::RunGarbageCollector() {
 		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 ||

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

@@ -3,7 +3,6 @@
 
 #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"
@@ -60,6 +59,7 @@ public:
 	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);
+	// Cache-index and exact dirty-range queries require GPU-thread serialization.
 	[[nodiscard]] bool IsRegionRegistered(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool HasGpuDirtyBytes(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] bool IsRegionCpuModified(uint64_t vaddr, uint64_t size);
@@ -99,7 +99,6 @@ private:
 	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;

src/graphics/presentation/window/window.cpp

@@ -938,13 +938,6 @@ void WindowContext::UpdateTitle() {
 	static constexpr auto build_type = "Unknown";
 #endif
 
-#if defined(KYTY_OFFICIAL_BUILD)
-	static constexpr auto build_label = "Official build " KYTY_RELEASE_TAG;
-#elif defined(KYTY_FORK_BUILD)
-	static constexpr auto build_label = "Fork build " KYTY_BUILD_REPOSITORY " " KYTY_GIT_HASH;
-#else
-	static constexpr auto build_label = "Source build " KYTY_GIT_HASH;
-#endif
 
 	const auto now       = Common::Timer::QueryPerformanceCounter();
 	const auto frequency = Common::Timer::QueryPerformanceFrequency();
@@ -957,7 +950,7 @@ void WindowContext::UpdateTitle() {
 		fps_frames  = 0;
 	}
 
-	auto fps = fmt::format("[{} | {}] {}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", build_label,
+	auto fps = fmt::format("[{} | {}] {}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", KYTY_BUILD_LABEL,
 	                       build_type, (has_title ? title : ""), (has_title ? ", " : ""),
 	                       (has_title_id ? title_id : ""), (has_title_id ? ", " : ""),
 	                       (has_app_ver ? app_ver : ""), (has_app_ver ? " " : ""), device_name,

src/kytyGitVersion.h.in

@@ -1,2 +1,13 @@
+#include "cmake_config.h"
+
 #define KYTY_GIT_VERSION "@KYTY_GIT_VERSION@"
 #define KYTY_GIT_HASH "@KYTY_GIT_HASH@"
+
+/* Build provenance, shown in the window title and in crash reports. */
+#if defined(KYTY_OFFICIAL_BUILD)
+#define KYTY_BUILD_LABEL "Official build " KYTY_RELEASE_TAG
+#elif defined(KYTY_FORK_BUILD)
+#define KYTY_BUILD_LABEL "Fork build " KYTY_BUILD_REPOSITORY " " KYTY_GIT_HASH
+#else
+#define KYTY_BUILD_LABEL "Source build " KYTY_GIT_HASH
+#endif

src/libs/controller.cpp

@@ -208,7 +208,8 @@ void GameController::AddState(const ControllerState& state) {
 void GameController::Button(int id, uint32_t button, bool down) {
 	Common::LockGuard lock(m_mutex);
 
-	if (m_active_id == id) {
+	// The keyboard shares the player-1 pad with the active gamepad.
+	if (m_active_id == id || id == HOST_INPUT_CONTROLLER_ID) {
 		auto state = GetLastState();
 
 		state.time = LibKernel::KernelGetProcessTime();
@@ -226,7 +227,7 @@ void GameController::Button(int id, uint32_t button, bool down) {
 void GameController::Axis(int id, Controller::Axis axis, int value) {
 	Common::LockGuard lock(m_mutex);
 
-	if (m_active_id == id) {
+	if (m_active_id == id || id == HOST_INPUT_CONTROLLER_ID) {
 		auto state = GetLastState();
 
 		state.time = LibKernel::KernelGetProcessTime();

tests/ShaderRecompilerComputeTests.cpp

@@ -1607,6 +1607,146 @@ public:
 		        order == 2 && gpu_thread != caller_thread && nested_thread == gpu_thread,
 		        "host command did not run on the GPU thread or nested sync deadlocked");
 
+		{
+			const auto make_release_mem = [](uint32_t data_sel, uint32_t interrupt_selector,
+			                                 void* destination, uint64_t value) {
+				std::array<uint32_t, 8> packet {};
+				const auto              address = reinterpret_cast<uint64_t>(destination);
+				constexpr uint32_t       eop_none = 0x28u;
+				constexpr uint32_t       gcr_gl2_writeback = 1u << 9u;
+				packet[0] = KYTY_PM4(8, Pm4::IT_NOP, Pm4::R_RELEASE_MEM);
+				packet[1] = eop_none | (gcr_gl2_writeback << 12u);
+				packet[2] = (interrupt_selector << 24u) | (data_sel << 29u);
+				packet[3] = static_cast<uint32_t>(address);
+				packet[4] = static_cast<uint32_t>(address >> 32u);
+				packet[5] = static_cast<uint32_t>(value);
+				packet[6] = static_cast<uint32_t>(value >> 32u);
+				packet[7] = 0x123u;
+				return packet;
+			};
+
+			vk::SemaphoreTypeCreateInfo timeline_type {};
+			timeline_type.sType         = vk::StructureType::eSemaphoreTypeCreateInfo;
+			timeline_type.semaphoreType = vk::SemaphoreType::eTimeline;
+			vk::SemaphoreCreateInfo timeline_create {};
+			timeline_create.sType           = vk::StructureType::eSemaphoreCreateInfo;
+			timeline_create.pNext           = &timeline_type;
+			vk::Semaphore blocked_timeline = nullptr;
+			Require("GpuCommandLane", "blocked timeline create",
+			        m_runtime_context.device.createSemaphore(
+			            &timeline_create, nullptr, &blocked_timeline) == vk::Result::eSuccess &&
+			            blocked_timeline != nullptr,
+			        "failed to create the blocked GPU timeline");
+
+			constexpr uint64_t release_tick = 1;
+			auto&              gpu_scheduler = context.GetCommandScheduler();
+			auto               processor     = std::make_unique<CommandProcessor>(context);
+			gpu.SendCommandSync([&] {
+				processor->BufferInit();
+				SubmitInfo blocked_submit;
+				blocked_submit.AddWait(blocked_timeline, release_tick);
+				gpu_scheduler.Flush(blocked_submit);
+			});
+
+			std::binary_semaphore parser_complete {0};
+			alignas(uint64_t) uint64_t interrupt_only_gds_label = UINT64_MAX;
+			bool                       parser_kept_nonblocking_boundaries = false;
+			std::jthread               no_gpu_wait([&] {
+				gpu.SendCommandSync([&] {
+					processor->BufferInit();
+					const auto tick_before = gpu_scheduler.CurrentTick();
+					processor->TriggerEvent(0x16u, 0u);
+					auto         packet = make_release_mem(0, 0, nullptr, 0);
+					Pm4Execution execution;
+					const auto   result = processor->Process(execution, packet.data(), packet.size());
+					processor->IncrementDe();
+					const bool cache_and_counter_did_not_submit =
+					    result == Pm4ProcessResult::Complete &&
+					    gpu_scheduler.CurrentTick() == tick_before;
+
+					auto gds_interrupt_only =
+					    make_release_mem(5, 1, &interrupt_only_gds_label, 1ull << 16u);
+					Pm4Execution gds_interrupt_execution;
+					const auto   interrupt_tick = gpu_scheduler.CurrentTick();
+					const auto   interrupt_result = processor->Process(
+					    gds_interrupt_execution, gds_interrupt_only.data(), gds_interrupt_only.size());
+					parser_kept_nonblocking_boundaries =
+					    cache_and_counter_did_not_submit &&
+					    interrupt_result == Pm4ProcessResult::Complete &&
+					    gpu_scheduler.CurrentTick() == interrupt_tick + 1 &&
+					    interrupt_only_gds_label == UINT64_MAX;
+				});
+				parser_complete.release();
+			});
+			const bool parser_did_not_wait_gpu =
+			    parser_complete.try_acquire_for(std::chrono::seconds(2));
+
+			vk::SemaphoreSignalInfo signal_info {};
+			signal_info.sType     = vk::StructureType::eSemaphoreSignalInfo;
+			signal_info.semaphore = blocked_timeline;
+			signal_info.value     = release_tick;
+			Require("GpuCommandLane", "blocked timeline signal",
+			        m_runtime_context.device.signalSemaphore(&signal_info) == vk::Result::eSuccess,
+			        "failed to release the blocked GPU timeline");
+			no_gpu_wait.join();
+			gpu.SendCommandSync([&] { gpu_scheduler.Finish(); });
+			m_runtime_context.device.destroySemaphore(blocked_timeline, nullptr);
+			Require("GpuCommandLane", "nonblocking GPU packets",
+			        parser_did_not_wait_gpu && parser_kept_nonblocking_boundaries,
+			        "a cache event, GL2 writeback, DE counter, or interrupt boundary used the wrong "
+			        "submission behavior");
+
+			alignas(uint64_t) uint64_t release_label = 0;
+			alignas(uint64_t) uint64_t gds_label     = UINT64_MAX;
+			bool                       release_mem_submission_counts = false;
+			gpu.SendCommandSync([&] {
+				processor->BufferInit();
+
+				auto         immediate = make_release_mem(1, 0, &release_label, 0x11223344u);
+				Pm4Execution immediate_execution;
+				const auto   immediate_tick = gpu_scheduler.CurrentTick();
+				const auto   immediate_result =
+				    processor->Process(immediate_execution, immediate.data(), immediate.size());
+				const bool immediate_split_once =
+				    gpu_scheduler.CurrentTick() == immediate_tick + 1;
+
+				auto         gds = make_release_mem(5, 0, &gds_label, 1ull << 16u);
+				Pm4Execution gds_execution;
+				const auto   gds_tick   = gpu_scheduler.CurrentTick();
+				const auto   gds_result = processor->Process(gds_execution, gds.data(), gds.size());
+				const bool   gds_waited_once = gpu_scheduler.CurrentTick() == gds_tick + 1;
+
+				auto         interrupt_only = make_release_mem(0, 4, nullptr, 0);
+				Pm4Execution interrupt_execution;
+				const auto   interrupt_tick = gpu_scheduler.CurrentTick();
+				const auto interrupt_result = processor->Process(
+				    interrupt_execution, interrupt_only.data(), interrupt_only.size());
+				const bool interrupt_split_once =
+				    gpu_scheduler.CurrentTick() == interrupt_tick + 1;
+
+				auto         gds_interrupt = make_release_mem(5, 2, &gds_label, 1ull << 16u);
+				Pm4Execution gds_interrupt_execution;
+				const auto   gds_interrupt_tick = gpu_scheduler.CurrentTick();
+				const auto   gds_interrupt_result = processor->Process(
+				    gds_interrupt_execution, gds_interrupt.data(), gds_interrupt.size());
+				const bool gds_interrupt_waited_once =
+				    gpu_scheduler.CurrentTick() == gds_interrupt_tick + 1;
+
+				release_mem_submission_counts =
+				    immediate_result == Pm4ProcessResult::Complete && immediate_split_once &&
+				    gds_result == Pm4ProcessResult::Complete && gds_waited_once &&
+				    interrupt_result == Pm4ProcessResult::Complete && interrupt_split_once &&
+				    gds_interrupt_result == Pm4ProcessResult::Complete &&
+				    gds_interrupt_waited_once;
+			});
+			gpu.SendCommandSync([&] { gpu_scheduler.Finish(); });
+			Require("GpuCommandLane", "RELEASE_MEM submission counts",
+			        release_mem_submission_counts &&
+			            static_cast<uint32_t>(release_label) == 0x11223344u &&
+			            static_cast<uint32_t>(gds_label) == 0,
+			        "RELEASE_MEM lost its required split/readback or retained a redundant GPU wait");
+		}
+
 		alignas(uint32_t) uint32_t packet_marker_a = 0;
 		alignas(uint32_t) uint32_t packet_marker_b = 0;
 		const auto write_packet = [](uint32_t* packet, uint32_t* destination, uint32_t value) {
@@ -3089,40 +3229,17 @@ public:
 			        "prefix, or transferred ownership");
 
 			auto& buffer_cache = resources.GetBufferCache();
-			Require(name, "formatted lock-handoff fixture",
-			        !buffer_cache.IsRegionRegistered(mip_desc.info.data.address,
-			                                          mip_desc.info.data.size),
-			        "formatted image already had a cached Buffer owner");
-			BufferBinding         mip_formatted;
-			std::binary_semaphore obtain_entered {0};
-			std::binary_semaphore obtain_complete {0};
-			std::binary_semaphore buffer_visible {0};
-			auto                  texture_lock = TextureCacheTestAccess::Lock(texture_cache);
-			gpu.SendCommand([&] {
-				obtain_entered.release();
+			BufferBinding mip_formatted;
+			bool          formatted_owner_was_absent = false;
+			gpu.SendCommandSync([&] {
+				formatted_owner_was_absent =
+				    !buffer_cache.IsRegionRegistered(mip_desc.info.data.address,
+				                                     mip_desc.info.data.size);
 				mip_formatted = buffer_cache.ObtainBuffer(command, mip_desc.info.data.address,
 				                                            mip_desc.info.data.size, false, true, true);
-				obtain_complete.release();
 			});
-			obtain_entered.acquire();
-			std::jthread buffer_probe([&] {
-				while (!buffer_cache.IsRegionRegistered(mip_desc.info.data.address,
-				                                         mip_desc.info.data.size)) {
-					std::this_thread::yield();
-				}
-				buffer_visible.release();
-			});
-			const bool buffer_released_before_texture =
-			    buffer_visible.try_acquire_for(std::chrono::seconds(2));
-			texture_lock.unlock();
-			if (!buffer_released_before_texture) {
-				buffer_visible.acquire();
-			}
-			obtain_complete.acquire();
-			buffer_probe.join();
-			Require(name, "formatted cache lock handoff", buffer_released_before_texture,
-			        "formatted Buffer acquisition retained the BufferCache lock while waiting for "
-			        "TextureCache");
+			Require(name, "formatted cache fixture", formatted_owner_was_absent,
+			        "formatted image already had a cached Buffer owner");
 			Require(name, "formatted Buffer path",
 			        mip_formatted.owner != nullptr && mip_formatted.buffer != nullptr &&
 			            texture_cache.GetImage(mip_image).IsGpuModified(),
@@ -18420,14 +18537,16 @@ void CheckPm4CeCompletion(RenderContext& renderer) {
 	uint32_t         suffix  = 0;
 	const auto       address = reinterpret_cast<uint64_t>(&suffix);
 
-	std::array<uint32_t, 7> commands {};
+	std::array<uint32_t, 9> commands {};
 	commands[0] = 0xc0008600u;
 	commands[1] = 1;
-	commands[2] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
+	commands[2] = 0xc0008500u;
 	commands[3] = 0;
-	commands[4] = static_cast<uint32_t>(address);
-	commands[5] = static_cast<uint32_t>(address >> 32u);
-	commands[6] = 33;
+	commands[4] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
+	commands[5] = 0;
+	commands[6] = static_cast<uint32_t>(address);
+	commands[7] = static_cast<uint32_t>(address >> 32u);
+	commands[8] = 33;
 
 	processor.ResetDeCe();
 	Pm4Execution execution;
@@ -18437,11 +18556,30 @@ void CheckPm4CeCompletion(RenderContext& renderer) {
 	            suffix == 0,
 	        "DE did not wait for an active CE stream");
 
-	processor.SetCeComplete(true);
-	Require("Pm4CeCompletion", "complete",
+	std::array<uint32_t, 2> ce_increment {0xc0008400u, 1};
+	Pm4Execution            ce_execution;
+	Require("Pm4CeCompletion", "CE increment",
+	        processor.Process(ce_execution, ce_increment.data(), ce_increment.size()) ==
+	            Pm4ProcessResult::Complete,
+	        "CE counter increment did not complete");
+	Require("Pm4CeCompletion", "counter gate",
 	        processor.Process(execution, commands.data(), commands.size()) ==
 	                Pm4ProcessResult::Complete &&
 	            suffix == 33,
+	        "DE did not resume after CE advanced or failed to increment its counter");
+
+	suffix = 0;
+	Pm4Execution balanced_execution;
+	Require("Pm4CeCompletion", "balanced wait",
+	        processor.Process(balanced_execution, commands.data(), commands.size()) ==
+	                Pm4ProcessResult::Blocked &&
+	            suffix == 0,
+	        "balanced CE/DE counters did not gate the next DE packet");
+	processor.SetCeComplete(true);
+	Require("Pm4CeCompletion", "stream complete",
+	        processor.Process(balanced_execution, commands.data(), commands.size()) ==
+	                Pm4ProcessResult::Complete &&
+	            suffix == 33,
 	        "DE remained blocked after the CE stream completed");
 	std::printf("[host]    %-32s ok\n", "Pm4CeCompletion");
 }