From d82c42d818e49a46e511a324b10d4d9869900ce1 Mon Sep 17 00:00:00 2001 From: ahmad Date: Fri, 9 Oct 2026 22:36:19 +0300 Subject: [PATCH] feat(vkbridge): self-checking smoke test, frame dump, WSI extensions and crash log on the server Smoke test passes 9/9 through the bridge on RADV (dmabuf) and lavapipe (hostptr, UMA model); vkcube renders correctly over Wayland dma-buf, wl_shm and X11. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR --- app/src/main/cpp/vkbridge/server_conn.c | 5 + app/src/main/cpp/vkbridge/server_instance.c | 9 +- app/src/main/cpp/vkbridge/server_main.c | 24 + tools/vkbridge/client/wsi.c | 39 ++ tools/vkbridge/host/bridge_env.sh | 14 + tools/vkbridge/tests/gen_shaders.sh | 12 + tools/vkbridge/tests/shaders/smoke.comp | 9 + tools/vkbridge/tests/shaders/smoke.frag | 4 + tools/vkbridge/tests/shaders/smoke.vert | 5 + tools/vkbridge/tests/smoke.c | 513 ++++++++++++++++++++ tools/vkbridge/tests/smoke_spv.h | 108 +++++ 11 files changed, 741 insertions(+), 1 deletion(-) create mode 100755 tools/vkbridge/host/bridge_env.sh create mode 100755 tools/vkbridge/tests/gen_shaders.sh create mode 100644 tools/vkbridge/tests/shaders/smoke.comp create mode 100644 tools/vkbridge/tests/shaders/smoke.frag create mode 100644 tools/vkbridge/tests/shaders/smoke.vert create mode 100644 tools/vkbridge/tests/smoke.c create mode 100644 tools/vkbridge/tests/smoke_spv.h diff --git a/app/src/main/cpp/vkbridge/server_conn.c b/app/src/main/cpp/vkbridge/server_conn.c index 4c7e64740..e85cb3b59 100644 --- a/app/src/main/cpp/vkbridge/server_conn.c +++ b/app/src/main/cpp/vkbridge/server_conn.c @@ -21,6 +21,7 @@ static pthread_mutex_t procs_lock = PTHREAD_MUTEX_INITIALIZER; static vkb_srv_proc *procs; static __thread vkb_srv_table *tls_table; +__thread const char *vkb_srv_current_cmd; vkb_srv_table *vkb_srv_current_table(void) { return tls_table; } void vkb_srv_set_current_table(vkb_srv_table *t) { tls_table = t; } @@ -193,7 +194,9 @@ void vkb_sv_vkEndCommandBuffer(vkb_srv_call *c) sub.table = c->table; sub.conn = c->conn; sub.in_stream = 1; + vkb_srv_current_cmd = vkb_cmd_names[id]; vkb_srv_handlers[id](&sub); + vkb_srv_current_cmd = vkb_cmd_names[VKB_CMD_vkEndCommandBuffer]; scratch = sub.r; if (sub.status != VKB_ST_OK) { VKB_ERR("command stream: %s failed (status %u)", vkb_cmd_names[id], sub.status); @@ -274,7 +277,9 @@ static void *conn_main(void *arg) if (c.status == VKB_ST_OK) { vkb_srv_set_current_table(c.table); if (vkb_verbose) VKB_DBG("-> %s", vkb_cmd_names[h.cmd]); + vkb_srv_current_cmd = vkb_cmd_names[h.cmd]; vkb_srv_handlers[h.cmd](&c); + vkb_srv_current_cmd = NULL; vkb_srv_set_current_table(NULL); } } diff --git a/app/src/main/cpp/vkbridge/server_instance.c b/app/src/main/cpp/vkbridge/server_instance.c index 401f8b4a0..6cf6844f3 100644 --- a/app/src/main/cpp/vkbridge/server_instance.c +++ b/app/src/main/cpp/vkbridge/server_instance.c @@ -246,7 +246,7 @@ void vkb_sv_vkCreateDevice(vkb_srv_call *c) inst->real.vkEnumerateDeviceExtensionProperties(pd, NULL, &avail_n, avail); uint32_t extra_n = 0; const char *const *extra = vkb_mem_required_extensions(strategy, &extra_n); - const char **exts = vkb_dec_alloc(&c->d, (ci->enabledExtensionCount + extra_n + 1) * sizeof(char *)); + const char **exts = vkb_dec_alloc(&c->d, (ci->enabledExtensionCount + extra_n + 8) * sizeof(char *)); uint32_t n = 0; for (uint32_t i = 0; i < ci->enabledExtensionCount; i++) { const char *e = ci->ppEnabledExtensionNames[i]; @@ -258,6 +258,13 @@ void vkb_sv_vkCreateDevice(vkb_srv_call *c) } for (uint32_t i = 0; i < extra_n; i++) if (has_ext(avail, avail_n, extra[i]) && !list_has(exts, n, extra[i])) exts[n++] = extra[i]; + /* What the client's presentation code uses on every device (dma-buf swapchains, sync fds). */ + static const char *const wsi_exts[] = { + "VK_KHR_external_memory_fd", "VK_EXT_external_memory_dma_buf", "VK_KHR_image_format_list", + "VK_EXT_image_drm_format_modifier", "VK_KHR_external_semaphore_fd", "VK_KHR_external_fence_fd", + }; + for (size_t i = 0; i < sizeof(wsi_exts) / sizeof(wsi_exts[0]); i++) + if (has_ext(avail, avail_n, wsi_exts[i]) && !list_has(exts, n, wsi_exts[i])) exts[n++] = wsi_exts[i]; ci->enabledExtensionCount = n; ci->ppEnabledExtensionNames = exts; ci->enabledLayerCount = 0; diff --git a/app/src/main/cpp/vkbridge/server_main.c b/app/src/main/cpp/vkbridge/server_main.c index 59c665130..13664b7af 100644 --- a/app/src/main/cpp/vkbridge/server_main.c +++ b/app/src/main/cpp/vkbridge/server_main.c @@ -67,6 +67,25 @@ void vkb_log(int level, const char *fmt, ...) #endif } +extern __thread const char *vkb_srv_current_cmd; + +/* A crash is almost always the driver's: say in which call, then die as we would have. */ +static void on_crash(int sig) +{ + char buf[256]; + const char *cmd = vkb_srv_current_cmd ? vkb_srv_current_cmd : "(no Vulkan call)"; + int n = snprintf(buf, sizeof(buf), "vkbridge-server E crashed with signal %d in %s\n", sig, cmd); + if (log_file) { + if (write(fileno(log_file), buf, (size_t)n) < 0) {} + } + if (write(2, buf, (size_t)n) < 0) {} +#ifdef __ANDROID__ + __android_log_write(ANDROID_LOG_FATAL, "vkbridge", buf); +#endif + signal(sig, SIG_DFL); + raise(sig); +} + static void *load_vulkan(const char *override) { const char *names[] = { @@ -149,6 +168,11 @@ int main(int argc, char **argv) if (!log_file) fprintf(stderr, "vkbridge-server: cannot open log %s: %s\n", log_path, strerror(errno)); } signal(SIGPIPE, SIG_IGN); + signal(SIGSEGV, on_crash); + signal(SIGBUS, on_crash); + signal(SIGABRT, on_crash); + signal(SIGILL, on_crash); + signal(SIGFPE, on_crash); /* The server is the app's child: when the app dies, so does the session's GPU. */ prctl(PR_SET_PDEATHSIG, SIGTERM); diff --git a/tools/vkbridge/client/wsi.c b/tools/vkbridge/client/wsi.c index 9dc4273ef..b97c4c3fe 100644 --- a/tools/vkbridge/client/wsi.c +++ b/tools/vkbridge/client/wsi.c @@ -6,7 +6,9 @@ #include "wsi.h" #include "gen/vkb_client_gen.h" +#include #include +#include #include #include @@ -709,6 +711,42 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImage2KHR(VkDevice device, co return vkb_ep_vkAcquireNextImageKHR(device, pInfo->swapchain, pInfo->timeout, pInfo->semaphore, pInfo->fence, pImageIndex); } +/* VKBRIDGE_WSI_DUMP=/path/prefix: writes presented frame 60 as a PPM (debugging aid). */ +static void dump_frame(vkb_swapchain *sc, uint32_t index) +{ + if (sc->presents != 60) return; + uint32_t w = sc->info.imageExtent.width, h = sc->info.imageExtent.height, stride = w * 4; + const uint8_t *px = NULL; + void *map = NULL; + size_t maplen = 0; + if (sc->copy_present) { + px = sc->staging_ptr; + } else if (sc->images[index].dmabuf_fd >= 0) { + stride = sc->images[index].stride; + maplen = (size_t)sc->images[index].offset + (size_t)stride * h; + map = mmap(NULL, maplen, PROT_READ, MAP_SHARED, sc->images[index].dmabuf_fd, 0); + if (map == MAP_FAILED) return; + px = (const uint8_t *)map + sc->images[index].offset; + } + if (!px) return; + char path[512]; + snprintf(path, sizeof(path), "%s-%d.ppm", getenv("VKBRIDGE_WSI_DUMP"), (int)getpid()); + FILE *f = fopen(path, "wb"); + if (f) { + int bgr = sc->info.imageFormat == VK_FORMAT_B8G8R8A8_UNORM || sc->info.imageFormat == VK_FORMAT_B8G8R8A8_SRGB; + fprintf(f, "P6 %u %u 255\n", w, h); + for (uint32_t y = 0; y < h; y++) + for (uint32_t x = 0; x < w; x++) { + const uint8_t *p = px + (size_t)y * stride + x * 4; + uint8_t rgb[3] = {p[bgr ? 2 : 0], p[1], p[bgr ? 0 : 2]}; + fwrite(rgb, 1, 3, f); + } + fclose(f); + VKB_INFO("dumped frame to %s", path); + } + if (map) munmap(map, maplen); +} + VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) { const VkPresentRegionsKHR *regions = NULL; @@ -729,6 +767,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueuePresentKHR(VkQueue queue, const VkP sc->images[index].busy = sc->dmabuf && !sc->copy_present; } pthread_mutex_unlock(&sc->lock); + if (r >= 0 && getenv("VKBRIDGE_WSI_DUMP")) dump_frame(sc, index); if (r >= 0) { r = sc->backend->present(sc, index, regions && i < regions->swapchainCount ? ®ions->pRegions[i] : NULL); sc->presents++; diff --git a/tools/vkbridge/host/bridge_env.sh b/tools/vkbridge/host/bridge_env.sh new file mode 100755 index 000000000..0d4d7efbf --- /dev/null +++ b/tools/vkbridge/host/bridge_env.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Source this: starts a host vkbridge server on the given desktop driver (default RADV) and +# points this shell's Vulkan programs at the bridge ICD. +# . tools/vkbridge/host/bridge_env.sh [icd-json] +_vkb_host=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +_vkb_icd=${1:-/usr/share/vulkan/icd.d/radeon_icd.json} +export VKBRIDGE_SOCKET=${VKBRIDGE_SOCKET:-${XDG_RUNTIME_DIR:-/tmp}/vkbridge-host.sock} +pgrep -x vkbridge-server >/dev/null && kill $(pgrep -x vkbridge-server) 2>/dev/null; sleep 0.3 +rm -f "$VKBRIDGE_SOCKET" +VK_DRIVER_FILES=$_vkb_icd VK_ICD_FILENAMES= nohup "$_vkb_host/out/vkbridge-server" --socket "$VKBRIDGE_SOCKET" \ + --log "$_vkb_host/out/server.log" >/dev/null 2>&1 & +for _i in $(seq 50); do [ -S "$VKBRIDGE_SOCKET" ] && break; sleep 0.1; done +export VK_DRIVER_FILES=$_vkb_host/out/vkbridge_icd.json +echo "vkbridge server up ($_vkb_icd) at $VKBRIDGE_SOCKET" diff --git a/tools/vkbridge/tests/gen_shaders.sh b/tools/vkbridge/tests/gen_shaders.sh new file mode 100755 index 000000000..b856b8e36 --- /dev/null +++ b/tools/vkbridge/tests/gen_shaders.sh @@ -0,0 +1,12 @@ +#!/bin/bash +# Compiles the test shaders into C arrays (tests/smoke_spv.h). Needs glslangValidator. +set -eu +cd "$(dirname "$0")" +out=smoke_spv.h +echo "/* Generated by gen_shaders.sh from shaders/ - do not edit. */" > $out +for s in shaders/*.comp shaders/*.vert shaders/*.frag; do + name=$(basename "$s" | tr . _) + glslangValidator -V --vn "spv_$name" -o tmp.h "$s" >/dev/null + grep -v '^ *//' tmp.h | sed 's/^const uint32_t/static const uint32_t/' >> $out + rm -f tmp.h +done diff --git a/tools/vkbridge/tests/shaders/smoke.comp b/tools/vkbridge/tests/shaders/smoke.comp new file mode 100644 index 000000000..a12276b26 --- /dev/null +++ b/tools/vkbridge/tests/shaders/smoke.comp @@ -0,0 +1,9 @@ +#version 450 +layout(local_size_x = 64) in; +layout(std430, binding = 0) readonly buffer In { uint v[]; } src; +layout(std430, binding = 1) writeonly buffer Out { uint v[]; } dst; +layout(push_constant) uniform PC { uint mul; uint add; } pc; +void main() { + uint i = gl_GlobalInvocationID.x; + dst.v[i] = src.v[i] * pc.mul + pc.add; +} diff --git a/tools/vkbridge/tests/shaders/smoke.frag b/tools/vkbridge/tests/shaders/smoke.frag new file mode 100644 index 000000000..31de6fb23 --- /dev/null +++ b/tools/vkbridge/tests/shaders/smoke.frag @@ -0,0 +1,4 @@ +#version 450 +layout(push_constant) uniform PC { vec4 color; } pc; +layout(location = 0) out vec4 o; +void main() { o = pc.color; } diff --git a/tools/vkbridge/tests/shaders/smoke.vert b/tools/vkbridge/tests/shaders/smoke.vert new file mode 100644 index 000000000..d6fb0f0b8 --- /dev/null +++ b/tools/vkbridge/tests/shaders/smoke.vert @@ -0,0 +1,5 @@ +#version 450 +void main() { + vec2 p = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2); + gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0); +} diff --git a/tools/vkbridge/tests/smoke.c b/tools/vkbridge/tests/smoke.c new file mode 100644 index 000000000..ee87ed90d --- /dev/null +++ b/tools/vkbridge/tests/smoke.c @@ -0,0 +1,513 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * droiddeck-vkbridge-smoke: a self-checking Vulkan test, run at session start (Mali bridge on) + * and on the host against the bridge. Every check compares real bytes; output goes to stdout + * one line per check, exit status 0 only if all pass. + * + * droiddeck-vkbridge-smoke [--gpu N] [--quiet] + */ +#define VK_NO_PROTOTYPES +#include + +#include +#include +#include +#include +#include + +#include "smoke_spv.h" + +static PFN_vkGetInstanceProcAddr gipa; +static VkInstance inst; +static VkPhysicalDevice pd; +static VkDevice dev; +static VkQueue queue; +static uint32_t qfam; +static VkCommandPool pool; +static VkPhysicalDeviceMemoryProperties mp; +static int failures, checks; + +#define I(name) PFN_##name name +static I(vkCreateInstance); static I(vkEnumeratePhysicalDevices); static I(vkGetPhysicalDeviceProperties); +static I(vkGetPhysicalDeviceQueueFamilyProperties); static I(vkGetPhysicalDeviceMemoryProperties); static I(vkCreateDevice); +static I(vkGetDeviceProcAddr); static I(vkDestroyInstance); static I(vkGetPhysicalDeviceFeatures); +static I(vkGetDeviceQueue); static I(vkCreateCommandPool); static I(vkAllocateCommandBuffers); static I(vkBeginCommandBuffer); +static I(vkEndCommandBuffer); static I(vkQueueSubmit); static I(vkQueueWaitIdle); static I(vkCreateBuffer); +static I(vkGetBufferMemoryRequirements); static I(vkAllocateMemory); static I(vkBindBufferMemory); static I(vkMapMemory); +static I(vkCmdFillBuffer); static I(vkCmdCopyBuffer); static I(vkCmdUpdateBuffer); static I(vkCmdPipelineBarrier); +static I(vkCreateShaderModule); static I(vkCreateDescriptorSetLayout); static I(vkCreatePipelineLayout); +static I(vkCreateComputePipelines); static I(vkCreateDescriptorPool); static I(vkAllocateDescriptorSets); +static I(vkUpdateDescriptorSets); static I(vkCmdBindPipeline); static I(vkCmdBindDescriptorSets); static I(vkCmdPushConstants); +static I(vkCmdDispatch); static I(vkCreateImage); static I(vkGetImageMemoryRequirements); static I(vkBindImageMemory); +static I(vkCmdClearColorImage); static I(vkCmdCopyImageToBuffer); static I(vkCreateImageView); static I(vkCreateRenderPass); +static I(vkCreateFramebuffer); static I(vkCreateGraphicsPipelines); static I(vkCmdBeginRenderPass); static I(vkCmdEndRenderPass); +static I(vkCmdDraw); static I(vkCreateSemaphore); static I(vkSignalSemaphore); static I(vkWaitSemaphores); +static I(vkGetSemaphoreCounterValue); static I(vkDestroyDevice); static I(vkFlushMappedMemoryRanges); +static I(vkInvalidateMappedMemoryRanges); static I(vkCmdSetViewport); static I(vkCmdSetScissor); +static I(vkCreateFence); static I(vkWaitForFences); static I(vkCmdCopyBufferToImage); +#undef I + +static void check(int ok, const char *what, const char *detail) +{ + checks++; + if (!ok) failures++; + printf("%s %s%s%s\n", ok ? "PASS" : "FAIL", what, detail && *detail ? ": " : "", detail ? detail : ""); + fflush(stdout); +} + +static double now_ms(void) +{ + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + return t.tv_sec * 1e3 + t.tv_nsec / 1e6; +} + +static uint32_t find_type(uint32_t bits, VkMemoryPropertyFlags want) +{ + for (uint32_t i = 0; i < mp.memoryTypeCount; i++) + if ((bits & (1u << i)) && (mp.memoryTypes[i].propertyFlags & want) == want) return i; + return UINT32_MAX; +} + +typedef struct { + VkBuffer buf; + VkDeviceMemory mem; + void *ptr; + VkMemoryPropertyFlags flags; +} buffer; + +static int make_buffer(buffer *b, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags want) +{ + VkBufferCreateInfo ci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, 0, size, usage, VK_SHARING_MODE_EXCLUSIVE, 0, NULL}; + if (vkCreateBuffer(dev, &ci, NULL, &b->buf)) return 0; + VkMemoryRequirements r; + vkGetBufferMemoryRequirements(dev, b->buf, &r); + uint32_t t = find_type(r.memoryTypeBits, want); + if (t == UINT32_MAX) return 0; + b->flags = mp.memoryTypes[t].propertyFlags; + VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, r.size, t}; + if (vkAllocateMemory(dev, &ai, NULL, &b->mem) || vkBindBufferMemory(dev, b->buf, b->mem, 0)) return 0; + b->ptr = NULL; + if (want & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) { + if (vkMapMemory(dev, b->mem, 0, VK_WHOLE_SIZE, 0, &b->ptr)) return 0; + } + return 1; +} + +static void sync_to_gpu(buffer *b) +{ + if (b->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) return; + VkMappedMemoryRange r = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, b->mem, 0, VK_WHOLE_SIZE}; + vkFlushMappedMemoryRanges(dev, 1, &r); +} + +static void sync_from_gpu(buffer *b) +{ + if (b->flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) return; + VkMappedMemoryRange r = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, b->mem, 0, VK_WHOLE_SIZE}; + vkInvalidateMappedMemoryRanges(dev, 1, &r); +} + +static VkCommandBuffer begin(void) +{ + VkCommandBufferAllocateInfo ai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1}; + VkCommandBuffer cb; + vkAllocateCommandBuffers(dev, &ai, &cb); + VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, NULL}; + vkBeginCommandBuffer(cb, &bi); + return cb; +} + +static int submit(VkCommandBuffer cb) +{ + VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT, VK_ACCESS_HOST_READ_BIT}; + vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &mb, 0, NULL, 0, NULL); + if (vkEndCommandBuffer(cb)) return 0; + VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + VkFence f; + vkCreateFence(dev, &fci, NULL, &f); + VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 1, &cb, 0, NULL}; + return !vkQueueSubmit(queue, 1, &si, f) && !vkWaitForFences(dev, 1, &f, VK_TRUE, 10000000000ull); +} + +static VkShaderModule shader(const uint32_t *code, size_t size) +{ + VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, size, code}; + VkShaderModule m = VK_NULL_HANDLE; + vkCreateShaderModule(dev, &ci, NULL, &m); + return m; +} + +/* ------------------------------------------------------------------ tests */ + +static void test_memory(void) +{ + char d[160]; + buffer b; + const uint32_t n = 1 << 16; + if (!make_buffer(&b, n * 4, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { + check(0, "host-visible buffer", "cannot create/map"); + return; + } + uint32_t *p = b.ptr; + for (uint32_t i = 0; i < n; i++) p[i] = i ^ 0x5a5a0000u; + sync_to_gpu(&b); + VkCommandBuffer cb = begin(); + vkCmdFillBuffer(cb, b.buf, 0, n, 0xC0FFEE00u); /* words [0, n/4) */ + VkBufferCopy c = {n * 2, n * 3, n}; /* words [n/2, 3n/4) -> [3n/4, n) */ + vkCmdCopyBuffer(cb, b.buf, b.buf, 1, &c); + uint32_t upd[16]; + for (int i = 0; i < 16; i++) upd[i] = 0xABC00000u + (uint32_t)i; + vkCmdUpdateBuffer(cb, b.buf, n + 64, sizeof(upd), upd); /* words [n/4 + 16, +16) */ + int ok = submit(cb); + sync_from_gpu(&b); + int bad = -1; + for (uint32_t i = 0; ok && i < n; i++) { + uint32_t want; + if (i < n / 4) want = 0xC0FFEE00u; + else if (i >= n / 4 + 16 && i < n / 4 + 32) want = 0xABC00000u + (i - n / 4 - 16); + else if (i >= 3 * n / 4) want = (i - n / 4) ^ 0x5a5a0000u; + else want = i ^ 0x5a5a0000u; + if (p[i] != want) { + bad = (int)i; + break; + } + } + snprintf(d, sizeof(d), bad < 0 ? "fill/copy/update seen through the mapping (memory flags 0x%x)" : "word %d wrong", bad < 0 ? (int)b.flags : bad); + check(ok && bad < 0, "mapped memory + transfer commands", d); +} + +static void test_compute(void) +{ + char d[160]; + const uint32_t n = 4096; + buffer in, out; + if (!make_buffer(&in, n * 4, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) || + !make_buffer(&out, n * 4, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { + check(0, "compute", "buffers"); + return; + } + for (uint32_t i = 0; i < n; i++) ((uint32_t *)in.ptr)[i] = i; + sync_to_gpu(&in); + VkDescriptorSetLayoutBinding binds[2] = {{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}, + {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}}; + VkDescriptorSetLayoutCreateInfo lci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL, 0, 2, binds}; + VkDescriptorSetLayout dsl; + vkCreateDescriptorSetLayout(dev, &lci, NULL, &dsl); + VkPushConstantRange pcr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, 8}; + VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0, 1, &dsl, 1, &pcr}; + VkPipelineLayout pl; + vkCreatePipelineLayout(dev, &plci, NULL, &pl); + VkComputePipelineCreateInfo cpci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO}; + cpci.stage = (VkPipelineShaderStageCreateInfo){VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_COMPUTE_BIT, + shader(spv_smoke_comp, sizeof(spv_smoke_comp)), "main", NULL}; + cpci.layout = pl; + VkPipeline pipe; + double t0 = now_ms(); + VkResult r = vkCreateComputePipelines(dev, VK_NULL_HANDLE, 1, &cpci, NULL, &pipe); + if (r) { + check(0, "compute pipeline", "creation failed"); + return; + } + VkDescriptorPoolSize ps = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2}; + VkDescriptorPoolCreateInfo dpci = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, NULL, 0, 1, 1, &ps}; + VkDescriptorPool dp; + vkCreateDescriptorPool(dev, &dpci, NULL, &dp); + VkDescriptorSetAllocateInfo dsai = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, dp, 1, &dsl}; + VkDescriptorSet set; + vkAllocateDescriptorSets(dev, &dsai, &set); + VkDescriptorBufferInfo bi[2] = {{in.buf, 0, VK_WHOLE_SIZE}, {out.buf, 0, VK_WHOLE_SIZE}}; + VkWriteDescriptorSet w[2] = {{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, set, 0, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, NULL, &bi[0], NULL}, + {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, set, 1, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, NULL, &bi[1], NULL}}; + vkUpdateDescriptorSets(dev, 2, w, 0, NULL); + VkCommandBuffer cb = begin(); + vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pipe); + vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pl, 0, 1, &set, 0, NULL); + uint32_t pc[2] = {3, 7}; + vkCmdPushConstants(cb, pl, VK_SHADER_STAGE_COMPUTE_BIT, 0, 8, pc); + vkCmdDispatch(cb, n / 64, 1, 1); + int ok = submit(cb); + sync_from_gpu(&out); + int bad = -1; + for (uint32_t i = 0; ok && i < n; i++) + if (((uint32_t *)out.ptr)[i] != i * 3 + 7) { + bad = (int)i; + break; + } + snprintf(d, sizeof(d), bad < 0 ? "%u invocations correct (%.1f ms incl. pipeline)" : "element %d wrong", bad < 0 ? n : (unsigned)bad, + now_ms() - t0); + check(ok && bad < 0, "compute shader", d); +} + +static VkImage make_image(VkFormat fmt, uint32_t w, uint32_t h, VkImageUsageFlags usage) +{ + VkImageCreateInfo ci = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, NULL, 0, VK_IMAGE_TYPE_2D, fmt, {w, h, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, + VK_IMAGE_TILING_OPTIMAL, usage, VK_SHARING_MODE_EXCLUSIVE, 0, NULL, VK_IMAGE_LAYOUT_UNDEFINED}; + VkImage img; + if (vkCreateImage(dev, &ci, NULL, &img)) return VK_NULL_HANDLE; + VkMemoryRequirements r; + vkGetImageMemoryRequirements(dev, img, &r); + uint32_t t = find_type(r.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + if (t == UINT32_MAX) t = find_type(r.memoryTypeBits, 0); + VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, r.size, t}; + VkDeviceMemory m; + if (vkAllocateMemory(dev, &ai, NULL, &m) || vkBindImageMemory(dev, img, m, 0)) return VK_NULL_HANDLE; + return img; +} + +static void barrier(VkCommandBuffer cb, VkImage img, VkImageLayout from, VkImageLayout to) +{ + VkImageMemoryBarrier b = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT, + VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, from, to, VK_QUEUE_FAMILY_IGNORED, + VK_QUEUE_FAMILY_IGNORED, img, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; + vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, &b); +} + +static void test_image_clear(void) +{ + const uint32_t w = 64, h = 64; + VkImage img = make_image(VK_FORMAT_R8G8B8A8_UNORM, w, h, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + buffer rb; + if (!img || !make_buffer(&rb, w * h * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { + check(0, "image clear + readback", "setup"); + return; + } + VkCommandBuffer cb = begin(); + barrier(cb, img, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + VkClearColorValue col = {.float32 = {1.0f, 0.5f, 0.0f, 1.0f}}; + VkImageSubresourceRange rng = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}; + vkCmdClearColorImage(cb, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &col, 1, &rng); + /* upload a 8x8 block from the buffer over the corner, to test buffer->image too */ + for (int i = 0; i < 64; i++) ((uint32_t *)rb.ptr)[i] = 0xFF112233u; + sync_to_gpu(&rb); + VkBufferImageCopy up = {0, 8, 8, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {8, 8, 1}}; + vkCmdCopyBufferToImage(cb, rb.buf, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &up); + barrier(cb, img, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); + VkBufferImageCopy c = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {w, h, 1}}; + VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT}; + vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &mb, 0, NULL, 0, NULL); + vkCmdCopyImageToBuffer(cb, img, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rb.buf, 1, &c); + int ok = submit(cb); + sync_from_gpu(&rb); + uint32_t *p = rb.ptr; + uint32_t want_clear = 0xFF0080FFu; /* R=255 G=128 B=0 A=255, little endian; 0.5 -> 127 or 128 */ + int bad = -1; + for (uint32_t y = 0; ok && y < h; y++) + for (uint32_t x = 0; x < w; x++) { + uint32_t v = p[y * w + x]; + int corner = x < 8 && y < 8; + int good = corner ? v == 0xFF112233u : ((v & 0xFFFF00FFu) == (want_clear & 0xFFFF00FFu) && ((v >> 8) & 0xFF) >= 127 && ((v >> 8) & 0xFF) <= 128); + if (!good && bad < 0) bad = (int)(y * w + x); + } + char d[128]; + snprintf(d, sizeof(d), bad < 0 ? "64x64 RGBA8 clear, upload and readback exact" : "pixel %d = 0x%08x", bad, bad < 0 ? 0 : p[bad]); + check(ok && bad < 0, "image clear/upload/readback", d); +} + +static void test_draw(void) +{ + const uint32_t w = 128, h = 96; + VkFormat fmt = VK_FORMAT_B8G8R8A8_UNORM; + VkImage img = make_image(fmt, w, h, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT); + buffer rb; + if (!img || !make_buffer(&rb, w * h * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) { + check(0, "draw", "setup"); + return; + } + VkImageViewCreateInfo vci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, NULL, 0, img, VK_IMAGE_VIEW_TYPE_2D, fmt, {0}, + {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}}; + VkImageView view; + vkCreateImageView(dev, &vci, NULL, &view); + VkAttachmentDescription att = {0, fmt, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE, + VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL}; + VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; + VkSubpassDescription sub = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, NULL, 1, &ref, NULL, NULL, 0, NULL}; + VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, NULL, 0, 1, &att, 1, &sub, 0, NULL}; + VkRenderPass rp; + vkCreateRenderPass(dev, &rpci, NULL, &rp); + VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, NULL, 0, rp, 1, &view, w, h, 1}; + VkFramebuffer fb; + vkCreateFramebuffer(dev, &fci, NULL, &fb); + VkPushConstantRange pcr = {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16}; + VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0, 0, NULL, 1, &pcr}; + VkPipelineLayout pl; + vkCreatePipelineLayout(dev, &plci, NULL, &pl); + VkPipelineShaderStageCreateInfo st[2] = { + {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_VERTEX_BIT, shader(spv_smoke_vert, sizeof(spv_smoke_vert)), "main", NULL}, + {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_FRAGMENT_BIT, shader(spv_smoke_frag, sizeof(spv_smoke_frag)), "main", NULL}}; + VkPipelineVertexInputStateCreateInfo vi = {VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO}; + VkPipelineInputAssemblyStateCreateInfo ia = {VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, NULL, 0, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0}; + VkPipelineViewportStateCreateInfo vp = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, NULL, 0, 1, NULL, 1, NULL}; + VkPipelineRasterizationStateCreateInfo rs = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO}; + rs.polygonMode = VK_POLYGON_MODE_FILL; + rs.cullMode = VK_CULL_MODE_NONE; + rs.lineWidth = 1.0f; + VkPipelineMultisampleStateCreateInfo ms = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, NULL, 0, VK_SAMPLE_COUNT_1_BIT}; + VkPipelineColorBlendAttachmentState cba = {0}; + cba.colorWriteMask = 0xF; + VkPipelineColorBlendStateCreateInfo cb_ = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, NULL, 0, 0, 0, 1, &cba, {0}}; + VkDynamicState dyn[2] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; + VkPipelineDynamicStateCreateInfo ds = {VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, NULL, 0, 2, dyn}; + VkGraphicsPipelineCreateInfo gpci = {VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, NULL, 0, 2, st, &vi, &ia, NULL, &vp, &rs, &ms, NULL, &cb_, &ds, + pl, rp, 0, VK_NULL_HANDLE, -1}; + VkPipeline pipe; + if (vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &gpci, NULL, &pipe)) { + check(0, "graphics pipeline", "creation failed"); + return; + } + VkCommandBuffer cb = begin(); + VkClearValue clear = {.color = {.float32 = {0, 0, 0, 1}}}; + VkRenderPassBeginInfo rbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, NULL, rp, fb, {{0, 0}, {w, h}}, 1, &clear}; + vkCmdBeginRenderPass(cb, &rbi, VK_SUBPASS_CONTENTS_INLINE); + vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, pipe); + /* left half only: the right half keeps the clear colour */ + VkViewport v = {0, 0, (float)w, (float)h, 0, 1}; + VkRect2D sc = {{0, 0}, {w / 2, h}}; + vkCmdSetViewport(cb, 0, 1, &v); + vkCmdSetScissor(cb, 0, 1, &sc); + float color[4] = {0.0f, 1.0f, 0.0f, 1.0f}; + vkCmdPushConstants(cb, pl, VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16, color); + vkCmdDraw(cb, 3, 1, 0, 0); + vkCmdEndRenderPass(cb); + VkBufferImageCopy c = {0, 0, 0, {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1}, {0, 0, 0}, {w, h, 1}}; + vkCmdCopyImageToBuffer(cb, img, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, rb.buf, 1, &c); + int ok = submit(cb); + sync_from_gpu(&rb); + uint32_t *p = rb.ptr; + int bad = -1; + for (uint32_t y = 0; ok && y < h; y++) + for (uint32_t x = 0; x < w; x++) { + uint32_t want = x < w / 2 ? 0xFF00FF00u : 0xFF000000u; /* BGRA: green / black */ + if (p[y * w + x] != want && bad < 0) bad = (int)(y * w + x); + } + char d[128]; + snprintf(d, sizeof(d), bad < 0 ? "render pass + pipeline + scissor exact (%ux%u)" : "pixel %d = 0x%08x", bad < 0 ? w : (unsigned)bad, + bad < 0 ? h : p[bad]); + check(ok && bad < 0, "draw", d); +} + +static void test_timeline(void) +{ + VkSemaphoreTypeCreateInfo t = {VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, NULL, VK_SEMAPHORE_TYPE_TIMELINE, 5}; + VkSemaphoreCreateInfo ci = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, &t, 0}; + VkSemaphore s; + if (!vkCreateSemaphore || vkCreateSemaphore(dev, &ci, NULL, &s) || !vkSignalSemaphore) { + check(1, "timeline semaphore", "skipped (Vulkan 1.2 not available)"); + return; + } + VkSemaphoreSignalInfo si = {VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, NULL, s, 9}; + vkSignalSemaphore(dev, &si); + uint64_t v = 0; + vkGetSemaphoreCounterValue(dev, s, &v); + uint64_t want = 9; + VkSemaphoreWaitInfo wi = {VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, NULL, 0, 1, &s, &want}; + VkResult r = vkWaitSemaphores(dev, &wi, 1000000000ull); + char d[64]; + snprintf(d, sizeof(d), "value %llu", (unsigned long long)v); + check(v == 9 && r == VK_SUCCESS, "timeline semaphore", d); +} + +static void test_roundtrip_rate(void) +{ + /* Bridge overhead: how many trivial synchronous calls per second. */ + VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, NULL, VK_FENCE_CREATE_SIGNALED_BIT}; + VkFence f; + vkCreateFence(dev, &fci, NULL, &f); + PFN_vkGetFenceStatus gfs = (PFN_vkGetFenceStatus)vkGetDeviceProcAddr(dev, "vkGetFenceStatus"); + double t0 = now_ms(); + int n = 2000; + for (int i = 0; i < n; i++) gfs(dev, f); + double us = (now_ms() - t0) * 1000.0 / n; + char d[64]; + snprintf(d, sizeof(d), "%.1f us per synchronous call", us); + check(1, "call latency", d); +} + +int main(int argc, char **argv) +{ + int gpu = 0; + for (int i = 1; i < argc; i++) + if (!strcmp(argv[i], "--gpu") && i + 1 < argc) gpu = atoi(argv[++i]); + void *lib = dlopen("libvulkan.so.1", RTLD_NOW); + if (!lib) { + printf("FAIL loader: %s\n", dlerror()); + return 2; + } + gipa = (PFN_vkGetInstanceProcAddr)dlsym(lib, "vkGetInstanceProcAddr"); +#define G(n) n = (PFN_##n)gipa(inst, #n) + G(vkCreateInstance); + VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO, NULL, "vkbridge-smoke", 1, "vkbridge", 1, VK_API_VERSION_1_2}; + VkInstanceCreateInfo ici = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, NULL, 0, &app, 0, NULL, 0, NULL}; + VkResult r = vkCreateInstance(&ici, NULL, &inst); + check(r == VK_SUCCESS, "instance", r ? "vkCreateInstance failed" : ""); + if (r) return 1; + G(vkEnumeratePhysicalDevices); G(vkGetPhysicalDeviceProperties); G(vkGetPhysicalDeviceQueueFamilyProperties); + G(vkGetPhysicalDeviceMemoryProperties); G(vkCreateDevice); G(vkGetDeviceProcAddr); G(vkDestroyInstance); + G(vkGetPhysicalDeviceFeatures); + uint32_t n = 0; + vkEnumeratePhysicalDevices(inst, &n, NULL); + VkPhysicalDevice pds[8]; + if (n > 8) n = 8; + vkEnumeratePhysicalDevices(inst, &n, pds); + if ((uint32_t)gpu >= n) { + check(0, "physical device", "none"); + return 1; + } + pd = pds[gpu]; + VkPhysicalDeviceProperties props; + vkGetPhysicalDeviceProperties(pd, &props); + char d[300]; + snprintf(d, sizeof(d), "%s, Vulkan %u.%u.%u", props.deviceName, VK_API_VERSION_MAJOR(props.apiVersion), + VK_API_VERSION_MINOR(props.apiVersion), VK_API_VERSION_PATCH(props.apiVersion)); + check(1, "physical device", d); + vkGetPhysicalDeviceMemoryProperties(pd, &mp); + for (uint32_t i = 0; i < mp.memoryTypeCount; i++) + printf(" memory type %u: heap %u flags 0x%x\n", i, mp.memoryTypes[i].heapIndex, mp.memoryTypes[i].propertyFlags); + uint32_t nq = 0; + vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, NULL); + VkQueueFamilyProperties qp[16]; + if (nq > 16) nq = 16; + vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, qp); + for (qfam = 0; qfam < nq; qfam++) + if (qp[qfam].queueFlags & VK_QUEUE_GRAPHICS_BIT) break; + float prio = 1.0f; + VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, NULL, 0, qfam, 1, &prio}; + VkPhysicalDeviceVulkan12Features f12 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES}; + f12.timelineSemaphore = VK_TRUE; + VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, props.apiVersion >= VK_API_VERSION_1_2 ? &f12 : NULL, 0, 1, &qci, 0, NULL, 0, NULL, NULL}; + r = vkCreateDevice(pd, &dci, NULL, &dev); + check(r == VK_SUCCESS, "device", r ? "vkCreateDevice failed" : ""); + if (r) return 1; +#undef G +#define G(n) n = (PFN_##n)vkGetDeviceProcAddr(dev, #n) + G(vkGetDeviceQueue); G(vkCreateCommandPool); G(vkAllocateCommandBuffers); G(vkBeginCommandBuffer); G(vkEndCommandBuffer); + G(vkQueueSubmit); G(vkQueueWaitIdle); G(vkCreateBuffer); G(vkGetBufferMemoryRequirements); G(vkAllocateMemory); + G(vkBindBufferMemory); G(vkMapMemory); G(vkCmdFillBuffer); G(vkCmdCopyBuffer); G(vkCmdUpdateBuffer); G(vkCmdPipelineBarrier); + G(vkCreateShaderModule); G(vkCreateDescriptorSetLayout); G(vkCreatePipelineLayout); G(vkCreateComputePipelines); + G(vkCreateDescriptorPool); G(vkAllocateDescriptorSets); G(vkUpdateDescriptorSets); G(vkCmdBindPipeline); + G(vkCmdBindDescriptorSets); G(vkCmdPushConstants); G(vkCmdDispatch); G(vkCreateImage); G(vkGetImageMemoryRequirements); + G(vkBindImageMemory); G(vkCmdClearColorImage); G(vkCmdCopyImageToBuffer); G(vkCreateImageView); G(vkCreateRenderPass); + G(vkCreateFramebuffer); G(vkCreateGraphicsPipelines); G(vkCmdBeginRenderPass); G(vkCmdEndRenderPass); G(vkCmdDraw); + G(vkCreateSemaphore); G(vkSignalSemaphore); G(vkWaitSemaphores); G(vkGetSemaphoreCounterValue); G(vkDestroyDevice); + G(vkFlushMappedMemoryRanges); G(vkInvalidateMappedMemoryRanges); G(vkCmdSetViewport); G(vkCmdSetScissor); + G(vkCreateFence); G(vkWaitForFences); G(vkCmdCopyBufferToImage); +#undef G + vkGetDeviceQueue(dev, qfam, 0, &queue); + VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, qfam}; + vkCreateCommandPool(dev, &pci, NULL, &pool); + + test_memory(); + test_compute(); + test_image_clear(); + test_draw(); + test_timeline(); + test_roundtrip_rate(); + + vkDestroyDevice(dev, NULL); + vkDestroyInstance(inst, NULL); + printf("%s: %d of %d checks passed\n", failures ? "FAILED" : "OK", checks - failures, checks); + return failures ? 1 : 0; +} diff --git a/tools/vkbridge/tests/smoke_spv.h b/tools/vkbridge/tests/smoke_spv.h new file mode 100644 index 000000000..6c6188854 --- /dev/null +++ b/tools/vkbridge/tests/smoke_spv.h @@ -0,0 +1,108 @@ +/* Generated by gen_shaders.sh from shaders/ - do not edit. */ + // 1115.1.0 + #pragma once +static const uint32_t spv_smoke_comp[] = { + 0x07230203,0x00010000,0x0008000b,0x0000002e,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000005,0x00000004,0x6e69616d,0x00000000,0x0000000b,0x00060010,0x00000004, + 0x00000011,0x00000040,0x00000001,0x00000001,0x00030003,0x00000002,0x000001c2,0x00040005, + 0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000008,0x00000069,0x00080005,0x0000000b, + 0x475f6c67,0x61626f6c,0x766e496c,0x7461636f,0x496e6f69,0x00000044,0x00030005,0x00000011, + 0x0074754f,0x00040006,0x00000011,0x00000000,0x00000076,0x00030005,0x00000013,0x00747364, + 0x00030005,0x00000018,0x00006e49,0x00040006,0x00000018,0x00000000,0x00000076,0x00030005, + 0x0000001a,0x00637273,0x00030005,0x0000001f,0x00004350,0x00040006,0x0000001f,0x00000000, + 0x006c756d,0x00040006,0x0000001f,0x00000001,0x00646461,0x00030005,0x00000021,0x00006370, + 0x00040047,0x0000000b,0x0000000b,0x0000001c,0x00040047,0x00000010,0x00000006,0x00000004, + 0x00030047,0x00000011,0x00000003,0x00040048,0x00000011,0x00000000,0x00000019,0x00050048, + 0x00000011,0x00000000,0x00000023,0x00000000,0x00030047,0x00000013,0x00000019,0x00040047, + 0x00000013,0x00000021,0x00000001,0x00040047,0x00000013,0x00000022,0x00000000,0x00040047, + 0x00000017,0x00000006,0x00000004,0x00030047,0x00000018,0x00000003,0x00040048,0x00000018, + 0x00000000,0x00000018,0x00050048,0x00000018,0x00000000,0x00000023,0x00000000,0x00030047, + 0x0000001a,0x00000018,0x00040047,0x0000001a,0x00000021,0x00000000,0x00040047,0x0000001a, + 0x00000022,0x00000000,0x00030047,0x0000001f,0x00000002,0x00050048,0x0000001f,0x00000000, + 0x00000023,0x00000000,0x00050048,0x0000001f,0x00000001,0x00000023,0x00000004,0x00040047, + 0x0000002d,0x0000000b,0x00000019,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002, + 0x00040015,0x00000006,0x00000020,0x00000000,0x00040020,0x00000007,0x00000007,0x00000006, + 0x00040017,0x00000009,0x00000006,0x00000003,0x00040020,0x0000000a,0x00000001,0x00000009, + 0x0004003b,0x0000000a,0x0000000b,0x00000001,0x0004002b,0x00000006,0x0000000c,0x00000000, + 0x00040020,0x0000000d,0x00000001,0x00000006,0x0003001d,0x00000010,0x00000006,0x0003001e, + 0x00000011,0x00000010,0x00040020,0x00000012,0x00000002,0x00000011,0x0004003b,0x00000012, + 0x00000013,0x00000002,0x00040015,0x00000014,0x00000020,0x00000001,0x0004002b,0x00000014, + 0x00000015,0x00000000,0x0003001d,0x00000017,0x00000006,0x0003001e,0x00000018,0x00000017, + 0x00040020,0x00000019,0x00000002,0x00000018,0x0004003b,0x00000019,0x0000001a,0x00000002, + 0x00040020,0x0000001c,0x00000002,0x00000006,0x0004001e,0x0000001f,0x00000006,0x00000006, + 0x00040020,0x00000020,0x00000009,0x0000001f,0x0004003b,0x00000020,0x00000021,0x00000009, + 0x00040020,0x00000022,0x00000009,0x00000006,0x0004002b,0x00000014,0x00000026,0x00000001, + 0x0004002b,0x00000006,0x0000002b,0x00000040,0x0004002b,0x00000006,0x0000002c,0x00000001, + 0x0006002c,0x00000009,0x0000002d,0x0000002b,0x0000002c,0x0000002c,0x00050036,0x00000002, + 0x00000004,0x00000000,0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000007,0x00000008, + 0x00000007,0x00050041,0x0000000d,0x0000000e,0x0000000b,0x0000000c,0x0004003d,0x00000006, + 0x0000000f,0x0000000e,0x0003003e,0x00000008,0x0000000f,0x0004003d,0x00000006,0x00000016, + 0x00000008,0x0004003d,0x00000006,0x0000001b,0x00000008,0x00060041,0x0000001c,0x0000001d, + 0x0000001a,0x00000015,0x0000001b,0x0004003d,0x00000006,0x0000001e,0x0000001d,0x00050041, + 0x00000022,0x00000023,0x00000021,0x00000015,0x0004003d,0x00000006,0x00000024,0x00000023, + 0x00050084,0x00000006,0x00000025,0x0000001e,0x00000024,0x00050041,0x00000022,0x00000027, + 0x00000021,0x00000026,0x0004003d,0x00000006,0x00000028,0x00000027,0x00050080,0x00000006, + 0x00000029,0x00000025,0x00000028,0x00060041,0x0000001c,0x0000002a,0x00000013,0x00000015, + 0x00000016,0x0003003e,0x0000002a,0x00000029,0x000100fd,0x00010038 +}; + // 1115.1.0 + #pragma once +static const uint32_t spv_smoke_vert[] = { + 0x07230203,0x00010000,0x0008000b,0x0000002b,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0007000f,0x00000000,0x00000004,0x6e69616d,0x00000000,0x0000000c,0x0000001d,0x00030003, + 0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000,0x00030005,0x00000009, + 0x00000070,0x00060005,0x0000000c,0x565f6c67,0x65747265,0x646e4978,0x00007865,0x00060005, + 0x0000001b,0x505f6c67,0x65567265,0x78657472,0x00000000,0x00060006,0x0000001b,0x00000000, + 0x505f6c67,0x7469736f,0x006e6f69,0x00070006,0x0000001b,0x00000001,0x505f6c67,0x746e696f, + 0x657a6953,0x00000000,0x00070006,0x0000001b,0x00000002,0x435f6c67,0x4470696c,0x61747369, + 0x0065636e,0x00070006,0x0000001b,0x00000003,0x435f6c67,0x446c6c75,0x61747369,0x0065636e, + 0x00030005,0x0000001d,0x00000000,0x00040047,0x0000000c,0x0000000b,0x0000002a,0x00030047, + 0x0000001b,0x00000002,0x00050048,0x0000001b,0x00000000,0x0000000b,0x00000000,0x00050048, + 0x0000001b,0x00000001,0x0000000b,0x00000001,0x00050048,0x0000001b,0x00000002,0x0000000b, + 0x00000003,0x00050048,0x0000001b,0x00000003,0x0000000b,0x00000004,0x00020013,0x00000002, + 0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007, + 0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040015,0x0000000a, + 0x00000020,0x00000001,0x00040020,0x0000000b,0x00000001,0x0000000a,0x0004003b,0x0000000b, + 0x0000000c,0x00000001,0x0004002b,0x0000000a,0x0000000e,0x00000001,0x0004002b,0x0000000a, + 0x00000010,0x00000002,0x00040017,0x00000017,0x00000006,0x00000004,0x00040015,0x00000018, + 0x00000020,0x00000000,0x0004002b,0x00000018,0x00000019,0x00000001,0x0004001c,0x0000001a, + 0x00000006,0x00000019,0x0006001e,0x0000001b,0x00000017,0x00000006,0x0000001a,0x0000001a, + 0x00040020,0x0000001c,0x00000003,0x0000001b,0x0004003b,0x0000001c,0x0000001d,0x00000003, + 0x0004002b,0x0000000a,0x0000001e,0x00000000,0x0004002b,0x00000006,0x00000020,0x40000000, + 0x0004002b,0x00000006,0x00000022,0x3f800000,0x0004002b,0x00000006,0x00000025,0x00000000, + 0x00040020,0x00000029,0x00000003,0x00000017,0x00050036,0x00000002,0x00000004,0x00000000, + 0x00000003,0x000200f8,0x00000005,0x0004003b,0x00000008,0x00000009,0x00000007,0x0004003d, + 0x0000000a,0x0000000d,0x0000000c,0x000500c4,0x0000000a,0x0000000f,0x0000000d,0x0000000e, + 0x000500c7,0x0000000a,0x00000011,0x0000000f,0x00000010,0x0004006f,0x00000006,0x00000012, + 0x00000011,0x0004003d,0x0000000a,0x00000013,0x0000000c,0x000500c7,0x0000000a,0x00000014, + 0x00000013,0x00000010,0x0004006f,0x00000006,0x00000015,0x00000014,0x00050050,0x00000007, + 0x00000016,0x00000012,0x00000015,0x0003003e,0x00000009,0x00000016,0x0004003d,0x00000007, + 0x0000001f,0x00000009,0x0005008e,0x00000007,0x00000021,0x0000001f,0x00000020,0x00050050, + 0x00000007,0x00000023,0x00000022,0x00000022,0x00050083,0x00000007,0x00000024,0x00000021, + 0x00000023,0x00050051,0x00000006,0x00000026,0x00000024,0x00000000,0x00050051,0x00000006, + 0x00000027,0x00000024,0x00000001,0x00070050,0x00000017,0x00000028,0x00000026,0x00000027, + 0x00000025,0x00000022,0x00050041,0x00000029,0x0000002a,0x0000001d,0x0000001e,0x0003003e, + 0x0000002a,0x00000028,0x000100fd,0x00010038 +}; + // 1115.1.0 + #pragma once +static const uint32_t spv_smoke_frag[] = { + 0x07230203,0x00010000,0x0008000b,0x00000012,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, + 0x0006000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x00000009,0x00030010,0x00000004, + 0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d,0x00000000, + 0x00030005,0x00000009,0x0000006f,0x00030005,0x0000000a,0x00004350,0x00050006,0x0000000a, + 0x00000000,0x6f6c6f63,0x00000072,0x00030005,0x0000000c,0x00006370,0x00040047,0x00000009, + 0x0000001e,0x00000000,0x00030047,0x0000000a,0x00000002,0x00050048,0x0000000a,0x00000000, + 0x00000023,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003,0x00000002,0x00030016, + 0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000004,0x00040020,0x00000008, + 0x00000003,0x00000007,0x0004003b,0x00000008,0x00000009,0x00000003,0x0003001e,0x0000000a, + 0x00000007,0x00040020,0x0000000b,0x00000009,0x0000000a,0x0004003b,0x0000000b,0x0000000c, + 0x00000009,0x00040015,0x0000000d,0x00000020,0x00000001,0x0004002b,0x0000000d,0x0000000e, + 0x00000000,0x00040020,0x0000000f,0x00000009,0x00000007,0x00050036,0x00000002,0x00000004, + 0x00000000,0x00000003,0x000200f8,0x00000005,0x00050041,0x0000000f,0x00000010,0x0000000c, + 0x0000000e,0x0004003d,0x00000007,0x00000011,0x00000010,0x0003003e,0x00000009,0x00000011, + 0x000100fd,0x00010038 +};