render: remove redundant cache setup

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

@@ -408,7 +408,6 @@ bool BufferCache::SynchronizeBuffer(Buffer& buffer, uint64_t vaddr, uint64_t siz
 		command.EndRendering();
 		const auto native = command.Handle();
 		vk::BufferMemoryBarrier before {};
-		before.sType         = vk::StructureType::eBufferMemoryBarrier;
 		before.srcAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite |
 		                       vk::AccessFlagBits::eTransferRead |
 		                       vk::AccessFlagBits::eTransferWrite;
@@ -643,29 +642,27 @@ void BufferCache::CopyBuffer(uint64_t dst_vaddr, uint64_t src_vaddr, uint64_t si
 		     " size=0x%016" PRIx64 " src_gds=%d dst_gds=%d\n",
 		     src_vaddr, dst_vaddr, size, static_cast<int>(src_gds), static_cast<int>(dst_gds));
 	}
-	if (src_memory || dst_memory) {
+	const auto src_region =
-		const auto src_region =
+	    src_memory ? m_texture_cache.QueryRegion(src_vaddr, size) : TextureCache::RegionInfo {};
-		    src_memory ? m_texture_cache.QueryRegion(src_vaddr, size) : TextureCache::RegionInfo {};
+	const auto dst_region =
-		const auto dst_region =
+	    dst_memory ? m_texture_cache.QueryRegion(dst_vaddr, size) : TextureCache::RegionInfo {};
-		    dst_memory ? m_texture_cache.QueryRegion(dst_vaddr, size) : TextureCache::RegionInfo {};
+	if (src_memory && dst_memory && !HasGpuDirtyBytes(src_vaddr, size) &&
-		if (src_memory && dst_memory && !HasGpuDirtyBytes(src_vaddr, size) &&
+	    !HasGpuDirtyBytes(dst_vaddr, size) && !src_region.gpu_image_bytes &&
-		    !HasGpuDirtyBytes(dst_vaddr, size) && !src_region.gpu_image_bytes &&
+	    !dst_region.gpu_image_bytes) {
-		    !dst_region.gpu_image_bytes) {
+		if (dst_region.image_bytes) {
-			if (dst_region.image_bytes) {
+			m_texture_cache.InvalidateMemory(dst_vaddr, size);
-				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;
 		}
+		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();

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

@@ -39,7 +39,6 @@ FaultManager::FaultManager(GraphicContext& graphics, CommandScheduler& scheduler
 	    {1, vk::DescriptorType::eStorageBuffer, 1, vk::ShaderStageFlagBits::eCompute, nullptr},
 	};
 	vk::DescriptorSetLayoutCreateInfo layout_info {};
-	layout_info.sType        = vk::StructureType::eDescriptorSetLayoutCreateInfo;
 	layout_info.flags        = vk::DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR;
 	layout_info.bindingCount = std::size(bindings);
 	layout_info.pBindings    = bindings;
@@ -49,7 +48,6 @@ FaultManager::FaultManager(GraphicContext& graphics, CommandScheduler& scheduler
 	    "create fault-buffer descriptor layout");
 
 	vk::ShaderModuleCreateInfo module_info {};
-	module_info.sType    = vk::StructureType::eShaderModuleCreateInfo;
 	module_info.codeSize = std::size(FAULT_BUFFER_PROCESS_SPV) * sizeof(uint32_t);
 	module_info.pCode    = FAULT_BUFFER_PROCESS_SPV;
 	vk::ShaderModule module = nullptr;
@@ -57,7 +55,6 @@ FaultManager::FaultManager(GraphicContext& graphics, CommandScheduler& scheduler
 	                     "create fault-buffer shader module");
 
 	vk::PipelineLayoutCreateInfo pipeline_layout_info {};
-	pipeline_layout_info.sType          = vk::StructureType::ePipelineLayoutCreateInfo;
 	pipeline_layout_info.setLayoutCount = 1;
 	pipeline_layout_info.pSetLayouts    = &m_fault_process_desc_layout;
 	RequireVulkanSuccess(
@@ -66,12 +63,10 @@ FaultManager::FaultManager(GraphicContext& graphics, CommandScheduler& scheduler
 	    "create fault-buffer pipeline layout");
 
 	vk::PipelineShaderStageCreateInfo stage {};
-	stage.sType  = vk::StructureType::ePipelineShaderStageCreateInfo;
 	stage.stage  = vk::ShaderStageFlagBits::eCompute;
 	stage.module = module;
 	stage.pName  = "main";
 	vk::ComputePipelineCreateInfo pipeline_info {};
-	pipeline_info.sType  = vk::StructureType::eComputePipelineCreateInfo;
 	pipeline_info.stage  = stage;
 	pipeline_info.layout = m_fault_process_pipeline_layout;
 	const auto result = m_graphics.device.createComputePipelines(
@@ -99,7 +94,6 @@ void FaultManager::ProcessFaultBuffer() {
 	m_download_buffer.Flush(offset, PageFaultAreaSize);
 
 	vk::BufferMemoryBarrier2 pre_barrier {};
-	pre_barrier.sType         = vk::StructureType::eBufferMemoryBarrier2;
 	pre_barrier.srcStageMask  = vk::PipelineStageFlagBits2::eAllCommands;
 	pre_barrier.srcAccessMask = vk::AccessFlagBits2::eShaderWrite;
 	pre_barrier.dstStageMask  = vk::PipelineStageFlagBits2::eComputeShader;
@@ -119,7 +113,6 @@ void FaultManager::ProcessFaultBuffer() {
 	};
 	std::array<vk::WriteDescriptorSet, 2> writes {};
 	for (uint32_t index = 0; index < writes.size(); ++index) {
-		writes[index].sType           = vk::StructureType::eWriteDescriptorSet;
 		writes[index].dstBinding      = index;
 		writes[index].descriptorCount = 1;
 		writes[index].descriptorType  = vk::DescriptorType::eStorageBuffer;
@@ -129,7 +122,6 @@ void FaultManager::ProcessFaultBuffer() {
 	m_scheduler.EndRendering();
 	auto command = m_scheduler.Current().Handle();
 	vk::DependencyInfo dependency {};
-	dependency.sType                    = vk::StructureType::eDependencyInfo;
 	dependency.dependencyFlags          = vk::DependencyFlagBits::eByRegion;
 	dependency.bufferMemoryBarrierCount = 1;
 	dependency.pBufferMemoryBarriers    = &pre_barrier;

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

@@ -116,9 +116,6 @@ vk::Sampler SamplerCache::GetSampler(const ShaderSamplerResource& r) {
 		default: EXIT("unknown border color: %d", static_cast<int>(r.BorderColorType()));
 	}
 
-	sampler_info.sType     = vk::StructureType::eSamplerCreateInfo;
-	sampler_info.pNext     = nullptr;
-	sampler_info.flags     = {};
 	sampler_info.magFilter = to_vk_filter(mag_filter);
 	sampler_info.minFilter = to_vk_filter(min_filter);
 	sampler_info.mipmapMode =

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

@@ -71,7 +71,6 @@ Buffer::Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsag
 	vk::BufferCreateInfo buffer_info {};
 	buffer_info.size        = size;
 	buffer_info.usage       = flags;
-	buffer_info.sharingMode = vk::SharingMode::eExclusive;
 
 	const bool with_bda = bool(flags & vk::BufferUsageFlagBits::eShaderDeviceAddress);
 	const VmaAllocationCreateFlags bda_flag =
@@ -105,7 +104,6 @@ Buffer::Buffer(GraphicContext& graphics, CommandScheduler& scheduler, MemoryUsag
 	graphics.device.getBufferMemoryRequirements(m_buffer->buffer, &m_buffer->memory.requirements);
 	if (static_cast<bool>(flags & vk::BufferUsageFlagBits::eShaderDeviceAddress)) {
 		vk::BufferDeviceAddressInfo address_info {};
-		address_info.sType  = vk::StructureType::eBufferDeviceAddressInfo;
 		address_info.buffer = m_buffer->buffer;
 		m_device_address    = graphics.device.getBufferAddress(address_info);
 		EXIT_IF(m_device_address == 0);
@@ -174,7 +172,6 @@ vk::BufferMemoryBarrier Buffer::Barrier(uint64_t offset, uint64_t size, vk::Acce
 		     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;

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

@@ -116,10 +116,8 @@ bool TextureCache::SameBacking(const ImageInfo& cached, const ImageInfo& request
 	if (cached.tile_mode != requested.tile_mode) {
 		return false;
 	}
-	if (!ImageViewOps::FormatsCompatible(cached.pixel_format, requested.pixel_format)) {
+	if (!ImageViewOps::FormatsCompatible(cached.pixel_format, requested.pixel_format) ||
-		return false;
+	    (cached.type != requested.type && requested.extent != vk::Extent3D {1, 1, 1})) {
-	}
-	if (cached.type != requested.type && requested.extent != vk::Extent3D {1, 1, 1}) {
 		return false;
 	}
 	if (exact_format && cached.pixel_format != requested.pixel_format) {
@@ -1036,18 +1034,14 @@ void TextureCache::InitializeImage(ImageId id) {
 	if (image.info.samples > 1) {
 		return;
 	}
-	bool       data_imported = false;
+	const bool upload = image.IsBufferModified() || image.IsCpuDirty();
-	const bool upload        = image.IsBufferModified() || image.IsCpuDirty();
 	if (upload) {
 		const auto [source, source_offset] =
 		    m_buffer_cache.ObtainBufferForImage(image.info.data.address, image.info.data.size);
 		if (source == nullptr) {
 			EXIT("TextureCache: failed to obtain image upload source\n");
 		}
-		data_imported = true;
 		UploadImage(image, *source, source_offset);
-	}
-	if (data_imported) {
 		image.ClearBufferModified();
 	}
 	if (image.IsCpuDirty()) {
@@ -1694,7 +1688,6 @@ bool TextureCache::TryDownloadImage(ImageId id) {
 
 	DownloadImageData(image, download, offset, range.size, std::move(plan));
 	vk::BufferMemoryBarrier barrier {};
-	barrier.sType         = vk::StructureType::eBufferMemoryBarrier;
 	barrier.srcAccessMask = vk::AccessFlagBits::eMemoryWrite | vk::AccessFlagBits::eTransferWrite |
 	                        vk::AccessFlagBits::eShaderWrite;
 	barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;