<div dir="ltr"><div>Looks good to me. All three are </div>Reviewed-by: Jason Ekstrand <<a href="mailto:jason@jlekstrand.net">jason@jlekstrand.net</a>> </div><div class="gmail_extra"> <div class="gmail_quote">On Tue, Feb 27, 2018 at 12:10 AM, Tapani Pälli <<a href="mailto:tapani.palli@intel.com" target="_blank">tapani.palli@intel.com</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Patch adds a new test that is expected to fail, new option and some minor refactor done to check_memory_contents to allow this. Signed-off-by: Tapani Pälli <<a href="mailto:tapani.palli@intel.com">tapani.palli@intel.com</a>> --- src/tests/func/sync/semaphore-fd.c | 105 +++++++++++++++++++++++++++++++++++-- 1 file changed, 101 insertions(+), 4 deletions(-) diff --git a/src/tests/func/sync/semaphore-fd.c b/src/tests/func/sync/semaphore-fd.c index ea54369..385edde 100644 --- a/src/tests/func/sync/semaphore-fd.c +++ b/src/tests/func/sync/semaphore-fd.c @@ -563,7 +563,7 @@ init_memory_contents(struct test_context *ctx, static void check_memory_contents(struct test_context *ctx, uint32_t *data, VkDeviceMemory memory, - bool multi_ctx) + bool multi_ctx, bool expect_failure) { /* First, do the computation on the CPU */ cpu_process_data(data); @@ -589,6 +589,13 @@ check_memory_contents(struct test_context *ctx, .size = sizeof(struct buffer_layout), }); + /* If expecting a failure, do a simple memcmp. */ + if (expect_failure) { + t_assert(memcmp(data, map->data, sizeof(map->data)) != 0); + vkUnmapMemory(ctx->device, tmp_mem); + return; + } + t_assert(map->atomic == NUM_HASH_ITERATIONS); for (unsigned i = 0; i < NUM_HASH_ITERATIONS; i++) { unsigned ctx_iter = multi_ctx ? (i >> 1) : i; @@ -635,7 +642,7 @@ test_sanity(void) } } - check_memory_contents(&ctx, cpu_data, mem, false); + check_memory_contents(&ctx, cpu_data, mem, false, false); } test_define { @@ -813,7 +820,7 @@ test_opaque_fd(void) logi("All compute batches queued\n"); - check_memory_contents(&ctx1, cpu_data, mem1, true); + check_memory_contents(&ctx1, cpu_data, mem1, true, false); } test_define { @@ -822,6 +829,96 @@ test_define { .no_image = true, }; +static void +test_opaque_fd_no_sync(void) +{ + t_require_ext("VK_KHR_external_memory"); + t_require_ext("VK_KHR_external_memory_capabilities"); + t_require_ext("VK_KHR_external_memory_fd"); + t_require_ext("VK_EXT_global_priority"); + + struct test_context ctx1, ctx2; + init_context(&ctx1, 1.0, VK_QUEUE_GLOBAL_PRIORITY_MEDIUM); + init_context(&ctx2, 0.0, VK_QUEUE_GLOBAL_PRIORITY_LOW); + +#define GET_FUNCTION_PTR(name, device) \ + PFN_vk##name name = (PFN_vk##name)vkGetDeviceProcAddr(device, "vk"#name) + GET_FUNCTION_PTR(GetMemoryFdKHR, ctx1.device); +#undef GET_FUNCTION_PTR + + VkMemoryRequirements buffer_reqs = + qoGetBufferMemoryRequirements(ctx1.device, ctx1.buffer); + + VkDeviceMemory mem1 = + qoAllocMemoryFromRequirements(ctx1.device, &buffer_reqs, + .properties = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + .pNext = &(VkExportMemoryAllocateInfoKHR) { + .sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, + .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + }); + + int fd; + VkResult result = GetMemoryFdKHR(ctx1.device, + &(VkMemoryGetFdInfoKHR) { + .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, + .memory = mem1, + .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + }, &fd); + t_assert(result == VK_SUCCESS); + t_assert(fd >= 0); + + VkDeviceMemory mem2 = + qoAllocMemoryFromRequirements(ctx2.device, &buffer_reqs, + .properties = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + .pNext = &(VkImportMemoryFdInfoKHR) { + .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR, + .fd = fd, + }); + + qoBindBufferMemory(ctx1.device, ctx1.buffer, mem1, 0); + qoBindBufferMemory(ctx2.device, ctx2.buffer, mem2, 0); + + uint32_t cpu_data[LOCAL_WORKGROUP_SIZE * 2]; + init_memory_contents(&ctx1, cpu_data, mem1); + + VkCommandBuffer cmd_buffer1 = create_command_buffer(&ctx1, 0); + VkCommandBuffer cmd_buffer2 = create_command_buffer(&ctx2, 1); + + logi("Begin queuing batches\n"); + + /* NUM_HASH_ITERATIONS is odd, so we use ctx1 for both the first and + * last submissions. This makes keeping track of where the memory is a + * bit easier. + */ + for (unsigned i = 0; i < NUM_HASH_ITERATIONS; i++) { + VkSubmitInfo submit = { + .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, + .commandBufferCount = 1, + }; + + if ((i & 1) == 0) { + submit.pCommandBuffers = &cmd_buffer1; + result = vkQueueSubmit(ctx1.queue, 1, &submit, VK_NULL_HANDLE); + t_assert(result == VK_SUCCESS); + } else { + submit.pCommandBuffers = &cmd_buffer2; + result = vkQueueSubmit(ctx2.queue, 1, &submit, VK_NULL_HANDLE); + t_assert(result == VK_SUCCESS); + } + } + + logi("All compute batches queued\n"); + + check_memory_contents(&ctx1, cpu_data, mem1, true, true); +} + +test_define { + .name = "func.sync.semaphore-fd.opaque-fd-no-sync", + .start = test_opaque_fd_no_sync, + .no_image = true, +}; + static void test_sync_fd(void) { @@ -964,7 +1061,7 @@ test_sync_fd(void) logi("All compute batches queued\n"); - check_memory_contents(&ctx1, cpu_data, mem1, true); + check_memory_contents(&ctx1, cpu_data, mem1, true, false); } test_define { -- 2.14.3 </blockquote></div> </div>