Improve memory markings

Add test markers. Handle the case of flush range and objects
not aligning. Add more test cases. Fix various issues.

Author: per-mathisen-arm

external/tracetooltests

@@ -1228,11 +1228,14 @@ static void translate_marked_offsets(lava_file_reader& reader, const VkMarkedOff
 	{
 		if (markings->pMarkingTypes[i] != VK_MARKING_TYPE_DEVICE_ADDRESS_ARM) continue;
 		const uint64_t offset = markings->pOffsets[i];
-		uint64_t* addr = (uint64_t*)(((char*)ptr) + offset);
-		const uint64_t current = *addr;
+		void* addr = (char*)ptr + offset;
+		uint64_t current = 0;
+		// Use memcpy to handle unaligned device address storage.
+		memcpy(&current, addr, sizeof(current));
 		const uint64_t newval = reader.parent->device_address_remapping.translate_address(current);
+		assert(newval != 0 || !reader.run);
 		DLOG("%u: Changing memory value at offset %lu from %lu to %lu", (unsigned)i, (unsigned long)offset, (unsigned long)current, (unsigned long)newval);
-		*addr = newval;
+		memcpy(addr, &newval, sizeof(newval));
 	}
 }
 

src/hardcode_read.cpp

@@ -1765,34 +1765,63 @@ void trace_post_vkFlushMappedMemoryRanges(lava_file_writer& writer, VkResult res
 	{
 		const VkMappedMemoryRange& v = pMemoryRanges[i];
 		auto* memory_data = writer.parent->records.VkDeviceMemory_index.at(v.memory);
+		assert(memory_data->ptr != nullptr && memory_data->size != 0); // the memory must be memory mapped
+		const uint64_t mapped_base = memory_data->offset;
+		const uint64_t mapped_limit = memory_data->offset + memory_data->size;
+		assert(v.offset >= mapped_base && v.offset <= mapped_limit);
 		VkDeviceSize size = v.size;
 		if (v.size == VK_WHOLE_SIZE)
 		{
-			size = memory_data->allocationSize - v.offset;
+			size = mapped_limit - v.offset;
 		}
-		assert(memory_data->ptr != nullptr && memory_data->size != 0); // the memory must be memory mapped
-		memory_data->exposed.add_os(v.offset, size);
+		assert(v.offset + size <= mapped_limit);
+		const uint64_t mapped_start = v.offset;
+		const uint64_t mapped_end = mapped_start + size;
+		memory_data->exposed.add_os(mapped_start, size);
 		// Handle VK_ARM_trace_helpers
 		VkMarkedOffsetsARM* ar = (VkMarkedOffsetsARM*)find_extension(&v, VK_STRUCTURE_TYPE_MARKED_OFFSETS_ARM);
 		// Handle VK_ARM_explicit_host_updates and/or VK_ARM_trace_helpers
 		if (device_data->explicit_host_updates || ar)
 		{
 			for (auto& pair : memory_data->usage)
 			{
-				if (pair.first > v.offset + size) continue; // our beginning is later than its end
+				if (pair.first > mapped_end) continue; // our beginning is later than its end
 				trackedobject* object_data = pair.second;
 				assert(pair.first == object_data->offset);
-				if (pair.first + object_data->size <= v.offset) continue; // its beginning is later than our end
+				if (pair.first + object_data->size <= mapped_start) continue; // its beginning is later than our end
 				char* cloneptr = memory_data->clone + object_data->offset;
 				char* changedptr = memory_data->ptr + object_data->offset - memory_data->offset;
-				uint64_t start = std::max<uint64_t>(object_data->offset, v.offset) - object_data->offset;
-				uint64_t end = std::min<uint64_t>(object_data->offset + object_data->size, v.offset + size) - object_data->offset;
-				if (ar && v.offset != object_data->offset) // flush range has a different offset than the object, modify the offsets in ar->pOffsets to be relative to start of the object in memory
+				uint64_t start = std::max<uint64_t>(object_data->offset, mapped_start) - object_data->offset;
+				uint64_t end = std::min<uint64_t>(object_data->offset + object_data->size, mapped_end) - object_data->offset;
+				VkMarkedOffsetsARM adjusted = {};
+				VkMarkedOffsetsARM* ar_use = nullptr;
+				std::vector<VkDeviceSize> adjusted_offsets;
+				std::vector<VkMarkingTypeARM> adjusted_types;
+				std::vector<VkMarkingSubTypeARM> adjusted_subtypes;
+				if (ar && ar->count > 0 && ar->pOffsets && ar->pMarkingTypes)
 				{
-					// TBD
-					assert(false);
+					adjusted = *ar;
+					adjusted_offsets.reserve(ar->count);
+					adjusted_types.reserve(ar->count);
+					if (ar->pSubTypes) adjusted_subtypes.reserve(ar->count);
+					for (uint32_t mark_i = 0; mark_i < ar->count; mark_i++)
+					{
+						const uint64_t mark_abs = v.offset + ar->pOffsets[mark_i];
+						if (mark_abs < object_data->offset || mark_abs >= object_data->offset + object_data->size) continue;
+						adjusted_offsets.push_back(mark_abs - object_data->offset);
+						adjusted_types.push_back(ar->pMarkingTypes[mark_i]);
+						if (ar->pSubTypes) adjusted_subtypes.push_back(ar->pSubTypes[mark_i]);
+					}
+					if (!adjusted_offsets.empty())
+					{
+						adjusted.count = static_cast<uint32_t>(adjusted_offsets.size());
+						adjusted.pOffsets = adjusted_offsets.data();
+						adjusted.pMarkingTypes = adjusted_types.data();
+						adjusted.pSubTypes = ar->pSubTypes ? adjusted_subtypes.data() : nullptr;
+						ar_use = &adjusted;
+					}
 				}
-				else uint64_t written = write_out_object(writer, device_data, object_data, cloneptr, changedptr, start, end - start, ar);
+				uint64_t written = write_out_object(writer, device_data, object_data, cloneptr, changedptr, start, end - start, ar_use);
 				ILOG("vkFlushMappedMemoryRanges[%u] flushing %s[%u] obj(%lu to %lu) object memory offset=%lu object size=%lu flush(off=%u, size=%u)", i, pretty_print_VkObjectType(object_data->object_type),
 				     (unsigned)object_data->index, (unsigned long)start, (unsigned long)end, (unsigned long)object_data->offset, (unsigned long)object_data->size, (unsigned)v.offset, (unsigned)v.size);
 			}

src/hardcode_write.cpp

@@ -312,7 +312,15 @@ static void trace_4()
 			VkMappedMemoryRange range = {}; // and only one flush call!
 			range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
 			range.memory = origin_memory;
-			range.size = VK_WHOLE_SIZE;
+			if (map_variant == 2)
+			{
+				range.offset = 10;
+				range.size = 20;
+			}
+			else
+			{
+				range.size = VK_WHOLE_SIZE;
+			}
 			result = trace_vkFlushMappedMemoryRanges(vulkan.device, 1, &range);
 			check(result);
 		}
@@ -345,7 +353,15 @@ static void trace_4()
 			VkMappedMemoryRange range = {}; // and only one flush call! not N calls to flush the entire memory area...
 			range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
 			range.memory = origin_memory;
-			range.size = VK_WHOLE_SIZE;
+			if (map_variant == 2)
+			{
+				range.offset = 10;
+				range.size = 20;
+			}
+			else
+			{
+				range.size = VK_WHOLE_SIZE;
+			}
 			result = trace_vkFlushMappedMemoryRanges(vulkan.device, 1, &range);
 			check(result);
 		}
@@ -376,7 +392,15 @@ static void trace_4()
 			VkMappedMemoryRange range = {}; // and only one flush call! not N calls to flush the entire memory area...
 			range.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
 			range.memory = origin_memory;
-			range.size = VK_WHOLE_SIZE;
+			if (map_variant == 2)
+			{
+				range.offset = 10;
+				range.size = 20;
+			}
+			else
+			{
+				range.size = VK_WHOLE_SIZE;
+			}
 			result = trace_vkFlushMappedMemoryRanges(vulkan.device, 1, &range);
 			check(result);
 		}

tests/tracing4.cpp

@@ -19,11 +19,15 @@ static void trace()
 	vulkan_setup_t vulkan = test_init(TEST_NAME_1, reqs);
 
 	VkBuffer buf;
+	VkBuffer buf2;
 	VkBufferCreateInfo bufferCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, nullptr };
 	bufferCreateInfo.size = BUFFER_SIZE;
 	bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR;
 	bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 	VkResult result = trace_vkCreateBuffer(vulkan.device, &bufferCreateInfo, nullptr, &buf);
+	check(result);
+	result = trace_vkCreateBuffer(vulkan.device, &bufferCreateInfo, nullptr, &buf2);
+	check(result);
 
 	VkMemoryRequirements req;
 	trace_vkGetBufferMemoryRequirements(vulkan.device, buf, &req);
@@ -35,13 +39,15 @@ static void trace()
 	VkMemoryAllocateInfo pAllocateMemInfo = {};
 	pAllocateMemInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 	pAllocateMemInfo.memoryTypeIndex = memoryTypeIndex;
-	pAllocateMemInfo.allocationSize = req.size;
+	pAllocateMemInfo.allocationSize = aligned_size * 2;
 	VkDeviceMemory memory = 0;
 	result = trace_vkAllocateMemory(vulkan.device, &pAllocateMemInfo, nullptr, &memory);
 	check(result);
 	assert(memory != 0);
 
+	test_marker(vulkan, "Bind buffers");
 	trace_vkBindBufferMemory(vulkan.device, buf, memory, 0);
+	trace_vkBindBufferMemory(vulkan.device, buf2, memory, aligned_size);
 
 	VkBufferDeviceAddressInfo bdainfo = { VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, nullptr };
 	bdainfo.buffer = buf;
@@ -57,6 +63,7 @@ static void trace()
 	ar.pMarkingTypes = markingTypes.data();
 	ar.pSubTypes = subTypes.data();
 
+	test_marker(vulkan, "Device address at first byte - " + std::to_string(address));
 	char* ptr = nullptr;
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
@@ -71,27 +78,82 @@ static void trace()
 	testFlushMemory(vulkan, memory, 0, pAllocateMemInfo.allocationSize, true, &ar);
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// 8-byte-aligned address
+	test_marker(vulkan, "Device address at bytes 32 and 128"); // 8-byte-aligned address
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	uint64_t* u64ptr = (uint64_t*)ptr;
+	u64ptr[4] = address; // second address, on 8 byte aligned boundary
 	u64ptr[16] = address; // second address, on 8 byte aligned boundary
-	ar.count = 1; // we only changed one value
-	offsets[0] = 16 * sizeof(uint64_t); // and it is here
+	ar.count = 2; // we only changed one value
+	offsets[0] = 4 * sizeof(uint64_t); // and it is here
+	offsets[1] = 16 * sizeof(uint64_t); // and it is here too
 	testFlushMemory(vulkan, memory, 0, pAllocateMemInfo.allocationSize, true, &ar);
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// 4-byte-aligned address that is _not_ 8 byte aligned
+	test_marker(vulkan, "Partial flush");
+	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
+	check(result);
+	u64ptr = (uint64_t*)ptr;
+	const VkDeviceSize flush_offset = 64 * sizeof(uint64_t);
+	const VkDeviceSize flush_size = 32 * sizeof(uint64_t);
+	const VkDeviceSize marked_offset = flush_offset + (4 * sizeof(uint64_t));
+	u64ptr[marked_offset / sizeof(uint64_t)] = address;
+	ar.count = 1;
+	offsets[0] = marked_offset - flush_offset;
+	testFlushMemory(vulkan, memory, flush_offset, flush_size, true, &ar);
+	trace_vkUnmapMemory(vulkan.device, memory);
+
+	test_marker(vulkan, "Flush with mapped offset");
+	result = trace_vkMapMemory(vulkan.device, memory, 192, VK_WHOLE_SIZE, 0, (void**)&ptr);
+	check(result);
+	u64ptr = (uint64_t*)ptr;
+	*u64ptr = address;
+	ar.count = 1;
+	offsets[0] = 0;
+	testFlushMemory(vulkan, memory, 192, 64, true, &ar);
+	trace_vkUnmapMemory(vulkan.device, memory);
+
+	test_marker(vulkan, "Flush with mapped offset and limited window");
+	result = trace_vkMapMemory(vulkan.device, memory, 200, 64, 0, (void**)&ptr);
+	check(result);
+	u64ptr = (uint64_t*)ptr;
+	u64ptr[1] = address;
+	ar.count = 1;
+	offsets[0] = 8;
+	testFlushMemory(vulkan, memory, 200, VK_WHOLE_SIZE, true, &ar);
+	trace_vkUnmapMemory(vulkan.device, memory);
+
+	test_marker(vulkan, "Flush with out of bounds offset");
+	result = trace_vkMapMemory(vulkan.device, memory, 8, 64, 0, (void**)&ptr);
+	check(result);
+	ar.count = 1;
+	offsets[0] = UINT32_MAX;
+	testFlushMemory(vulkan, memory, 8, VK_WHOLE_SIZE, true, &ar);
+	trace_vkUnmapMemory(vulkan.device, memory);
+
+	test_marker(vulkan, "Device address on a 4 byte alignment");
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	u64ptr = (uint64_t*)(ptr + 4);
 	u64ptr[64] = address; // add one more address at non-8-byte-aligned boundary
 	ar.count = 1; // we still only changed one value
-	offsets[0] = 64 * sizeof(uint32_t); // and it is here
+	offsets[0] = 64 * sizeof(uint64_t) + 4; // and it is here
 	testFlushMemory(vulkan, memory, 0, pAllocateMemInfo.allocationSize, true, &ar);
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// no address changes -- send empty address list
+	test_marker(vulkan, "Device address in a second buffer and flush covering both");
+	result = trace_vkMapMemory(vulkan.device, memory, 0, VK_WHOLE_SIZE, 0, (void**)&ptr);
+	check(result);
+	u64ptr = (uint64_t*)(ptr + aligned_size);
+	u64ptr[0] = address;
+	u64ptr[1] = address;
+	ar.count = 2;
+	offsets[0] = aligned_size;
+	offsets[1] = aligned_size + 8;
+	testFlushMemory(vulkan, memory, 0, VK_WHOLE_SIZE, true, &ar);
+	trace_vkUnmapMemory(vulkan.device, memory);
+
+	test_marker(vulkan, "No address changes, empty address list sent");
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	u64ptr = (uint64_t*)ptr;
@@ -100,30 +162,30 @@ static void trace()
 	testFlushMemory(vulkan, memory, 0, pAllocateMemInfo.allocationSize, true, &ar);
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// no address changes -- no address list
+	test_marker(vulkan, "No address changes, no address list sent");
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	u64ptr = (uint64_t*)ptr;
 	u64ptr[20] = 0;
 	testFlushMemory(vulkan, memory, 0, pAllocateMemInfo.allocationSize, true, nullptr);
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// no address changes -- no info bit, just flush
+	test_marker(vulkan, "No address changes, just flush");
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	u64ptr = (uint64_t*)ptr;
 	u64ptr[21] = 0;
 	testFlushMemory(vulkan, memory, 0, pAllocateMemInfo.allocationSize, false, nullptr);
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// no address changes -- no flush even
+	test_marker(vulkan, "No address changes, no flush");
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	u64ptr = (uint64_t*)ptr;
 	u64ptr[22] = 0;
 	trace_vkUnmapMemory(vulkan.device, memory);
 
-	// remove all addresses -- notice their removal if we scan for them
+	test_marker(vulkan, "Reset buffer back to dead pattern and flush");
 	result = trace_vkMapMemory(vulkan.device, memory, 0, pAllocateMemInfo.allocationSize, 0, (void**)&ptr);
 	check(result);
 	u32ptr = (uint32_t*)ptr;