diff --git a/app/src/main/cpp/vkbridge/server_conn.c b/app/src/main/cpp/vkbridge/server_conn.c index 670535cc7..7d97980d8 100644 --- a/app/src/main/cpp/vkbridge/server_conn.c +++ b/app/src/main/cpp/vkbridge/server_conn.c @@ -105,6 +105,7 @@ void vkb_proc_cleanup(vkb_srv_proc *p) if (t->is_device) { VKB_INFO("process %d exited without destroying device %u; cleaning up", p->pid, t->id); if (t->real.vkDeviceWaitIdle) t->real.vkDeviceWaitIdle(t->device); + vkb_dsmap_device_destroy(t); vkb_pcache_device_destroy(t); vkb_emu_device_destroy(t); vkb_mem_free_all(t); diff --git a/app/src/main/cpp/vkbridge/server_dsmap.c b/app/src/main/cpp/vkbridge/server_dsmap.c new file mode 100644 index 000000000..8d769841d --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_dsmap.c @@ -0,0 +1,337 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Descriptor sets named by the client. Where the client keeps a pool's books it knows an + * allocation will succeed, so it names the sets itself (VKB_DS_TAG | n) and sends the allocation + * without waiting (vkbAllocDescSets) - DXVK allocates a set or two per draw, and a round trip + * each was most of the bridge's remaining cost per frame. Here those names map to the driver's + * sets: wrappers in the device's dispatch table translate them wherever a set goes back to the + * driver (updates, template updates, binds, frees), and a pool's reset or destruction forgets its + * sets. Sets the server named itself (the synchronous path) pass through untouched. + */ +#define _GNU_SOURCE +#include "vkb_server.h" + +#include +#include + +#define VKB_DS_TAG (1ull << 63) +#define DS_BUCKETS 8192 +#define DS_LOCAL 64 + +typedef struct ds_ent { + uint64_t id; + VkDescriptorSet set; + struct ds_ent *next; /* bucket chain */ + struct ds_ent *pool_next; /* the pool's sets */ +} ds_ent; + +typedef struct ds_pool { + VkDescriptorPool pool; + ds_ent *sets; + struct ds_pool *next; +} ds_pool; + +typedef struct vkb_dsmap { + pthread_mutex_t lock; + ds_ent *buckets[DS_BUCKETS]; + ds_pool *pools; + int warned; + PFN_vkAllocateDescriptorSets allocate; + PFN_vkUpdateDescriptorSets update; + PFN_vkUpdateDescriptorSetWithTemplate update_template; + PFN_vkCmdBindDescriptorSets bind; + PFN_vkCmdBindDescriptorSets2 bind2; + PFN_vkFreeDescriptorSets free_sets; + PFN_vkResetDescriptorPool reset_pool; + PFN_vkDestroyDescriptorPool destroy_pool; +} vkb_dsmap; + +static unsigned bucket(uint64_t id) +{ + id *= 0x9e3779b97f4a7c15ull; + return (unsigned)(id >> 51) & (DS_BUCKETS - 1); +} + +static vkb_dsmap *cur(void) +{ + vkb_srv_table *t = vkb_srv_current_table(); + return t ? t->dsmap : NULL; +} + +static int tagged(VkDescriptorSet s) +{ + return ((uint64_t)s & VKB_DS_TAG) != 0; +} + +/* The driver's set for a client name; VK_NULL_HANDLE when its allocation failed. */ +static VkDescriptorSet lookup(vkb_dsmap *m, VkDescriptorSet s) +{ + if (!tagged(s)) return s; + uint64_t id = (uint64_t)s; + pthread_mutex_lock(&m->lock); + ds_ent *e = m->buckets[bucket(id)]; + while (e && e->id != id) e = e->next; + VkDescriptorSet r = e ? e->set : VK_NULL_HANDLE; + pthread_mutex_unlock(&m->lock); + return r; +} + +static void missing(vkb_dsmap *m, const char *where) +{ + if (__atomic_fetch_add(&m->warned, 1, __ATOMIC_RELAXED) < 20) + VKB_ERR("%s: a descriptor set the client allocated ahead does not exist (its allocation failed); skipped", where); +} + +static ds_pool *pool_get(vkb_dsmap *m, VkDescriptorPool pool, int create) +{ + for (ds_pool *p = m->pools; p; p = p->next) + if (p->pool == pool) return p; + if (!create) return NULL; + ds_pool *p = calloc(1, sizeof(*p)); + if (!p) return NULL; + p->pool = pool; + p->next = m->pools; + m->pools = p; + return p; +} + +/* Forgets the pool's sets (a reset or destruction freed them); the record goes with destroy. */ +static void pool_forget(vkb_dsmap *m, VkDescriptorPool pool, int destroy) +{ + pthread_mutex_lock(&m->lock); + for (ds_pool **pp = &m->pools; *pp; pp = &(*pp)->next) { + ds_pool *p = *pp; + if (p->pool != pool) continue; + while (p->sets) { + ds_ent *e = p->sets; + p->sets = e->pool_next; + ds_ent **bp = &m->buckets[bucket(e->id)]; + while (*bp && *bp != e) bp = &(*bp)->next; + if (*bp) *bp = e->next; + free(e); + } + if (destroy) { + *pp = p->next; + free(p); + } + break; + } + pthread_mutex_unlock(&m->lock); +} + +/* ------------------------------------------------------------------ the allocation request */ + +/* vkbAllocDescSets: device, pool, count, then per set its layout and the client's name. */ +void vkb_sv_vkbAllocDescSets(vkb_srv_call *c) +{ + VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d); + VkDescriptorPool pool; + vkb_dec_bytes(&c->d, &pool, sizeof(pool)); + uint32_t n = vkb_dec_u32(&c->d); + if (c->d.err || !c->table || !c->table->dsmap || n == 0 || n > 4096) { + vkb_srv_bad_message(c); + return; + } + vkb_dsmap *m = c->table->dsmap; + VkDescriptorSetLayout layouts_local[DS_LOCAL], *layouts = n <= DS_LOCAL ? layouts_local : malloc(n * sizeof(*layouts)); + uint64_t ids_local[DS_LOCAL], *ids = n <= DS_LOCAL ? ids_local : malloc(n * sizeof(*ids)); + VkDescriptorSet sets_local[DS_LOCAL], *sets = n <= DS_LOCAL ? sets_local : malloc(n * sizeof(*sets)); + if (!layouts || !ids || !sets) goto out; + for (uint32_t i = 0; i < n; i++) { + vkb_dec_bytes(&c->d, &layouts[i], sizeof(layouts[i])); + ids[i] = vkb_dec_u64(&c->d); + } + if (c->d.err) { + vkb_srv_bad_message(c); + goto out; + } + VkDescriptorSetAllocateInfo ai = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, pool, n, layouts}; + VkResult r = m->allocate(dev, &ai, sets); + if (r != VK_SUCCESS) { + VKB_ERR("allocating %u descriptor sets the client named ahead failed: %d (the client's pool books disagree " + "with the driver)", n, r); + goto out; + } + pthread_mutex_lock(&m->lock); + ds_pool *p = pool_get(m, pool, 1); + for (uint32_t i = 0; i < n; i++) { + ds_ent *e = malloc(sizeof(*e)); + if (!e || !p) { + free(e); + break; + } + e->id = ids[i]; + e->set = sets[i]; + unsigned b = bucket(e->id); + e->next = m->buckets[b]; + m->buckets[b] = e; + e->pool_next = p->sets; + p->sets = e; + } + pthread_mutex_unlock(&m->lock); +out: + if (layouts != layouts_local) free(layouts); + if (ids != ids_local) free(ids); + if (sets != sets_local) free(sets); +} + +/* ------------------------------------------------------------------ wrappers */ + +static void VKAPI_CALL ds_UpdateDescriptorSets(VkDevice device, uint32_t nw, const VkWriteDescriptorSet *w, uint32_t nc, + const VkCopyDescriptorSet *cp) +{ + vkb_dsmap *m = cur(); + int any = 0; + for (uint32_t i = 0; i < nw && !any; i++) any = tagged(w[i].dstSet); + for (uint32_t i = 0; i < nc && !any; i++) any = tagged(cp[i].srcSet) || tagged(cp[i].dstSet); + if (!any) { + m->update(device, nw, w, nc, cp); + return; + } + VkWriteDescriptorSet w_local[DS_LOCAL], *w2 = nw <= DS_LOCAL ? w_local : malloc(nw * sizeof(*w2)); + VkCopyDescriptorSet c_local[DS_LOCAL], *c2 = nc <= DS_LOCAL ? c_local : malloc(nc * sizeof(*c2)); + if ((nw && !w2) || (nc && !c2)) goto out; + uint32_t kw = 0, kc = 0; + for (uint32_t i = 0; i < nw; i++) { + w2[kw] = w[i]; + w2[kw].dstSet = lookup(m, w[i].dstSet); + if (w2[kw].dstSet) kw++; + else missing(m, "vkUpdateDescriptorSets"); + } + for (uint32_t i = 0; i < nc; i++) { + c2[kc] = cp[i]; + c2[kc].srcSet = lookup(m, cp[i].srcSet); + c2[kc].dstSet = lookup(m, cp[i].dstSet); + if (c2[kc].srcSet && c2[kc].dstSet) kc++; + else missing(m, "vkUpdateDescriptorSets (copy)"); + } + if (kw || kc) m->update(device, kw, w2, kc, c2); +out: + if (w2 != w_local) free(w2); + if (c2 != c_local) free(c2); +} + +static void VKAPI_CALL ds_UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet set, VkDescriptorUpdateTemplate tmpl, + const void *data) +{ + vkb_dsmap *m = cur(); + VkDescriptorSet s = lookup(m, set); + if (!s) { + missing(m, "vkUpdateDescriptorSetWithTemplate"); + return; + } + m->update_template(device, s, tmpl, data); +} + +/* Translates n sets into out; 0 when one of them does not exist. */ +static int translate(vkb_dsmap *m, uint32_t n, const VkDescriptorSet *in, VkDescriptorSet *out) +{ + for (uint32_t i = 0; i < n; i++) { + /* VK_NULL_HANDLE is allowed in binds (graphicsPipelineLibrary) and stays so. */ + out[i] = in[i] ? lookup(m, in[i]) : VK_NULL_HANDLE; + if (in[i] && !out[i]) return 0; + } + return 1; +} + +static void VKAPI_CALL ds_CmdBindDescriptorSets(VkCommandBuffer cb, VkPipelineBindPoint bp, VkPipelineLayout layout, uint32_t first, + uint32_t n, const VkDescriptorSet *sets, uint32_t ndyn, const uint32_t *dyn) +{ + vkb_dsmap *m = cur(); + VkDescriptorSet local[DS_LOCAL], *s = n <= DS_LOCAL ? local : malloc(n * sizeof(*s)); + if (!s) return; + if (translate(m, n, sets, s)) m->bind(cb, bp, layout, first, n, s, ndyn, dyn); + else missing(m, "vkCmdBindDescriptorSets"); + if (s != local) free(s); +} + +static void VKAPI_CALL ds_CmdBindDescriptorSets2(VkCommandBuffer cb, const VkBindDescriptorSetsInfo *info) +{ + vkb_dsmap *m = cur(); + uint32_t n = info->descriptorSetCount; + VkDescriptorSet local[DS_LOCAL], *s = n <= DS_LOCAL ? local : malloc(n * sizeof(*s)); + if (!s) return; + VkBindDescriptorSetsInfo i2 = *info; + i2.pDescriptorSets = s; + if (translate(m, n, info->pDescriptorSets, s)) m->bind2(cb, &i2); + else missing(m, "vkCmdBindDescriptorSets2"); + if (s != local) free(s); +} + +static VkResult VKAPI_CALL ds_FreeDescriptorSets(VkDevice device, VkDescriptorPool pool, uint32_t n, const VkDescriptorSet *sets) +{ + vkb_dsmap *m = cur(); + VkDescriptorSet local[DS_LOCAL], *s = n <= DS_LOCAL ? local : malloc(n * sizeof(*s)); + if (!s) return VK_ERROR_OUT_OF_HOST_MEMORY; + /* Named sets come only from pools without FREE_DESCRIPTOR_SET (the client keeps no books on + * those), so this is an app error at worst: what does not exist is left out. */ + uint32_t k = 0; + for (uint32_t i = 0; i < n; i++) { + VkDescriptorSet t = sets[i] ? lookup(m, sets[i]) : VK_NULL_HANDLE; + if (t || !sets[i]) s[k++] = t; + } + VkResult r = k ? m->free_sets(device, pool, k, s) : VK_SUCCESS; + if (s != local) free(s); + return r; +} + +static VkResult VKAPI_CALL ds_ResetDescriptorPool(VkDevice device, VkDescriptorPool pool, VkDescriptorPoolResetFlags flags) +{ + vkb_dsmap *m = cur(); + pool_forget(m, pool, 0); + return m->reset_pool(device, pool, flags); +} + +static void VKAPI_CALL ds_DestroyDescriptorPool(VkDevice device, VkDescriptorPool pool, const VkAllocationCallbacks *a) +{ + vkb_dsmap *m = cur(); + if (pool) pool_forget(m, pool, 1); + m->destroy_pool(device, pool, a); +} + +/* ------------------------------------------------------------------ device hooks */ + +void vkb_dsmap_device_init(vkb_srv_table *t) +{ + vkb_dispatch *dt = &t->dt; + if (!dt->vkAllocateDescriptorSets || !dt->vkUpdateDescriptorSets || !dt->vkCmdBindDescriptorSets || + !dt->vkResetDescriptorPool || !dt->vkDestroyDescriptorPool || !dt->vkFreeDescriptorSets) + return; + vkb_dsmap *m = calloc(1, sizeof(*m)); + if (!m) return; + pthread_mutex_init(&m->lock, NULL); + m->allocate = dt->vkAllocateDescriptorSets; + m->update = dt->vkUpdateDescriptorSets; + m->update_template = dt->vkUpdateDescriptorSetWithTemplate; + m->bind = dt->vkCmdBindDescriptorSets; + m->bind2 = dt->vkCmdBindDescriptorSets2; + m->free_sets = dt->vkFreeDescriptorSets; + m->reset_pool = dt->vkResetDescriptorPool; + m->destroy_pool = dt->vkDestroyDescriptorPool; + dt->vkUpdateDescriptorSets = ds_UpdateDescriptorSets; + if (m->update_template) dt->vkUpdateDescriptorSetWithTemplate = ds_UpdateDescriptorSetWithTemplate; + dt->vkCmdBindDescriptorSets = ds_CmdBindDescriptorSets; + if (m->bind2) dt->vkCmdBindDescriptorSets2 = ds_CmdBindDescriptorSets2; + dt->vkFreeDescriptorSets = ds_FreeDescriptorSets; + dt->vkResetDescriptorPool = ds_ResetDescriptorPool; + dt->vkDestroyDescriptorPool = ds_DestroyDescriptorPool; + t->dsmap = m; +} + +void vkb_dsmap_device_destroy(vkb_srv_table *t) +{ + vkb_dsmap *m = t->dsmap; + if (!m) return; + vkb_dispatch *dt = &t->dt; + dt->vkUpdateDescriptorSets = m->update; + if (m->update_template) dt->vkUpdateDescriptorSetWithTemplate = m->update_template; + dt->vkCmdBindDescriptorSets = m->bind; + if (m->bind2) dt->vkCmdBindDescriptorSets2 = m->bind2; + dt->vkFreeDescriptorSets = m->free_sets; + dt->vkResetDescriptorPool = m->reset_pool; + dt->vkDestroyDescriptorPool = m->destroy_pool; + while (m->pools) pool_forget(m, m->pools->pool, 1); + pthread_mutex_destroy(&m->lock); + free(m); + t->dsmap = NULL; +} diff --git a/app/src/main/cpp/vkbridge/server_instance.c b/app/src/main/cpp/vkbridge/server_instance.c index 7f175dab3..7233c6c97 100644 --- a/app/src/main/cpp/vkbridge/server_instance.c +++ b/app/src/main/cpp/vkbridge/server_instance.c @@ -295,6 +295,7 @@ void vkb_sv_vkCreateDevice(vkb_srv_call *c) } else { vkb_emu_device_init(t, emu); vkb_pcache_device_init(t); + vkb_dsmap_device_init(t); VKB_INFO("device %u created on %s (%u extensions, memory sharing %s)", id, k ? k->name : "?", n, vkb_mem_strategy_name(strategy)); for (uint32_t i = 0; i < n; i++) VKB_DBG(" device extension %s", exts[i]); @@ -317,6 +318,7 @@ void vkb_sv_vkDestroyDevice(vkb_srv_call *c) return; } vkb_table_unregister(t); + vkb_dsmap_device_destroy(t); vkb_pcache_device_destroy(t); vkb_emu_device_destroy(t); vkb_mem_free_all(t); diff --git a/app/src/main/cpp/vkbridge/vkb_server.h b/app/src/main/cpp/vkbridge/vkb_server.h index 1a1fcc052..0321c6e47 100644 --- a/app/src/main/cpp/vkbridge/vkb_server.h +++ b/app/src/main/cpp/vkbridge/vkb_server.h @@ -86,6 +86,7 @@ typedef struct vkb_srv_table { vkb_srv_mem *mems[256]; /* hash by handle */ struct vkb_emu_device *emu; struct vkb_pcache *pcache; /* server_pcache.c */ + struct vkb_dsmap *dsmap; /* server_dsmap.c */ } vkb_srv_table; /* server_main.c */ @@ -93,6 +94,10 @@ extern PFN_vkGetInstanceProcAddr vkb_gipa; extern vkb_dispatch vkb_global_dt; extern int vkb_verbose; +/* server_dsmap.c */ +void vkb_dsmap_device_init(vkb_srv_table *t); +void vkb_dsmap_device_destroy(vkb_srv_table *t); + /* server_pcache.c */ void vkb_pcache_set_dir(const char *dir); void vkb_pcache_device_init(vkb_srv_table *t); diff --git a/tools/vkbridge/client/descriptor.c b/tools/vkbridge/client/descriptor.c index 2a18f5246..1431ad851 100644 --- a/tools/vkbridge/client/descriptor.c +++ b/tools/vkbridge/client/descriptor.c @@ -528,6 +528,49 @@ static VkResult ds_refill(VkDevice device, ds_pool *p, const ds_layout *l, ds_ca return r; } +/* + * Sets the client names itself: with the pool's books kept and every layout known, whether the + * allocation fits is known here, so the sets get names (VKB_DS_TAG | n) at once and the server + * allocates the driver's sets without a reply (server_dsmap.c). All or nothing, as the spec has + * it. VK_ERROR_UNKNOWN: not for this path (a layout the books cannot follow). + */ +#define VKB_DS_TAG (1ull << 63) +#define DS_NAMED_MAX 1024 + +static VkResult ds_alloc_named(VkDevice device, ds_pool *p, const VkDescriptorSetAllocateInfo *ai, VkDescriptorSet *out) +{ + static uint64_t next_name; + uint32_t n = ai->descriptorSetCount; + if (!n || n > DS_NAMED_MAX) return VK_ERROR_UNKNOWN; + uint64_t need[DS_TYPES] = {0}; + for (uint32_t i = 0; i < n; i++) { + const ds_layout *l = layout_find(ai->pSetLayouts[i]); + if (!l || !l->known) return VK_ERROR_UNKNOWN; + for (int t = 0; t < DS_TYPES; t++) need[t] += l->count[t]; + } + if (n > p->sets_left) return VK_ERROR_OUT_OF_POOL_MEMORY; + for (int t = 0; t < DS_TYPES; t++) + if (need[t] > p->left[t]) return VK_ERROR_OUT_OF_POOL_MEMORY; + vkb_device *dev = vkb_dev(device); + vkb_call c; + vkb_call_begin(&c, VKB_CMD_vkbAllocDescSets, dev->obj.table); + vkb_enc_u64(&c.e, dev->obj.remote); + vkb_enc_bytes(&c.e, &ai->descriptorPool, sizeof(ai->descriptorPool)); + vkb_enc_u32(&c.e, n); + for (uint32_t i = 0; i < n; i++) { + out[i] = (VkDescriptorSet)(VKB_DS_TAG | __atomic_add_fetch(&next_name, 1, __ATOMIC_RELAXED)); + vkb_enc_bytes(&c.e, &ai->pSetLayouts[i], sizeof(ai->pSetLayouts[i])); + vkb_enc_u64(&c.e, (uint64_t)out[i]); + } + if (!vkb_call_exec_async(&c)) { + for (uint32_t i = 0; i < n; i++) out[i] = VK_NULL_HANDLE; + return VK_ERROR_DEVICE_LOST; + } + p->sets_left -= n; + for (int t = 0; t < DS_TYPES; t++) p->left[t] -= (uint32_t)need[t]; + return VK_SUCCESS; +} + VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *ai, VkDescriptorSet *out) { /* Variable descriptor counts and the like are per allocation: those go straight through. */ @@ -538,6 +581,13 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, pthread_mutex_unlock(&ds_lock); return vkb_wire_vkAllocateDescriptorSets(device, ai, out); } + if (p->books) { + VkResult nr = ds_alloc_named(device, p, ai, out); + if (nr != VK_ERROR_UNKNOWN) { + pthread_mutex_unlock(&ds_lock); + return nr; + } + } VkResult r = VK_SUCCESS; uint32_t done = 0; for (; done < ai->descriptorSetCount; done++) { diff --git a/tools/vkbridge/codegen/gen_vkbridge.py b/tools/vkbridge/codegen/gen_vkbridge.py index cb6592ba7..614f0eac6 100644 --- a/tools/vkbridge/codegen/gen_vkbridge.py +++ b/tools/vkbridge/codegen/gen_vkbridge.py @@ -383,7 +383,7 @@ SERVER_DISPATCH_EXTRA = ['vkMapMemory', 'vkUnmapMemory', 'vkGetMemoryHostPointer 'vkUpdateDescriptorSetWithTemplate', 'vkCmdPushDescriptorSetWithTemplateKHR'] dispatch_cmds = sorted(set(wire_cmds) | {reg.canon_cmd(c) for c in SERVER_DISPATCH_EXTRA}) # Wire-only helpers that are not Vulkan commands (handled by hand on both sides). -EXTRA_WIRE = ['vkbHello', 'vkbQueryServer', 'vkbDescUpdateRaw', 'vkbPushDescRaw'] +EXTRA_WIRE = ['vkbHello', 'vkbQueryServer', 'vkbDescUpdateRaw', 'vkbPushDescRaw', 'vkbAllocDescSets'] # -------------------------------------------------------------------------------------------- # Struct closure: every struct reachable from wire commands (params, members, pNext extenders). diff --git a/tools/vkbridge/common/gen/vkb_gen.h b/tools/vkbridge/common/gen/vkb_gen.h index 422fb53fa..65fddcad8 100644 --- a/tools/vkbridge/common/gen/vkb_gen.h +++ b/tools/vkbridge/common/gen/vkb_gen.h @@ -12,299 +12,300 @@ #include typedef struct vkb_enc vkb_enc; typedef struct vkb_dec vkb_dec; -#define VKB_PROTOCOL_HASH 0x8573c85f1e3900bdULL +#define VKB_PROTOCOL_HASH 0xa9af75dc848727baULL enum vkb_cmd_id { VKB_CMD_vkbHello = 0, VKB_CMD_vkbQueryServer = 1, VKB_CMD_vkbDescUpdateRaw = 2, VKB_CMD_vkbPushDescRaw = 3, - VKB_CMD_vkAllocateCommandBuffers = 4, - VKB_CMD_vkAllocateDescriptorSets = 5, - VKB_CMD_vkAllocateMemory = 6, - VKB_CMD_vkBeginCommandBuffer = 7, - VKB_CMD_vkBindBufferMemory = 8, - VKB_CMD_vkBindBufferMemory2 = 9, - VKB_CMD_vkBindImageMemory = 10, - VKB_CMD_vkBindImageMemory2 = 11, - VKB_CMD_vkBindTensorMemoryARM = 12, - VKB_CMD_vkCmdBeginConditionalRenderingEXT = 13, - VKB_CMD_vkCmdBeginCustomResolveEXT = 14, - VKB_CMD_vkCmdBeginQuery = 15, - VKB_CMD_vkCmdBeginQueryIndexedEXT = 16, - VKB_CMD_vkCmdBeginRenderPass = 17, - VKB_CMD_vkCmdBeginRenderPass2 = 18, - VKB_CMD_vkCmdBeginRendering = 19, - VKB_CMD_vkCmdBeginTransformFeedbackEXT = 20, - VKB_CMD_vkCmdBindDescriptorSets = 21, - VKB_CMD_vkCmdBindDescriptorSets2 = 22, - VKB_CMD_vkCmdBindIndexBuffer = 23, - VKB_CMD_vkCmdBindIndexBuffer2 = 24, - VKB_CMD_vkCmdBindPipeline = 25, - VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT = 26, - VKB_CMD_vkCmdBindVertexBuffers = 27, - VKB_CMD_vkCmdBindVertexBuffers2 = 28, - VKB_CMD_vkCmdBlitImage = 29, - VKB_CMD_vkCmdBlitImage2 = 30, - VKB_CMD_vkCmdClearAttachments = 31, - VKB_CMD_vkCmdClearColorImage = 32, - VKB_CMD_vkCmdClearDepthStencilImage = 33, - VKB_CMD_vkCmdCopyBuffer = 34, - VKB_CMD_vkCmdCopyBuffer2 = 35, - VKB_CMD_vkCmdCopyBufferToImage = 36, - VKB_CMD_vkCmdCopyBufferToImage2 = 37, - VKB_CMD_vkCmdCopyImage = 38, - VKB_CMD_vkCmdCopyImage2 = 39, - VKB_CMD_vkCmdCopyImageToBuffer = 40, - VKB_CMD_vkCmdCopyImageToBuffer2 = 41, - VKB_CMD_vkCmdCopyQueryPoolResults = 42, - VKB_CMD_vkCmdCopyTensorARM = 43, - VKB_CMD_vkCmdDispatch = 44, - VKB_CMD_vkCmdDispatchBase = 45, - VKB_CMD_vkCmdDispatchIndirect = 46, - VKB_CMD_vkCmdDraw = 47, - VKB_CMD_vkCmdDrawIndexed = 48, - VKB_CMD_vkCmdDrawIndexedIndirect = 49, - VKB_CMD_vkCmdDrawIndexedIndirectCount = 50, - VKB_CMD_vkCmdDrawIndirect = 51, - VKB_CMD_vkCmdDrawIndirectByteCountEXT = 52, - VKB_CMD_vkCmdDrawIndirectCount = 53, - VKB_CMD_vkCmdDrawMultiEXT = 54, - VKB_CMD_vkCmdDrawMultiIndexedEXT = 55, - VKB_CMD_vkCmdEndConditionalRenderingEXT = 56, - VKB_CMD_vkCmdEndQuery = 57, - VKB_CMD_vkCmdEndQueryIndexedEXT = 58, - VKB_CMD_vkCmdEndRenderPass = 59, - VKB_CMD_vkCmdEndRenderPass2 = 60, - VKB_CMD_vkCmdEndRendering = 61, - VKB_CMD_vkCmdEndRendering2KHR = 62, - VKB_CMD_vkCmdEndTransformFeedbackEXT = 63, - VKB_CMD_vkCmdExecuteCommands = 64, - VKB_CMD_vkCmdFillBuffer = 65, - VKB_CMD_vkCmdNextSubpass = 66, - VKB_CMD_vkCmdNextSubpass2 = 67, - VKB_CMD_vkCmdPipelineBarrier = 68, - VKB_CMD_vkCmdPipelineBarrier2 = 69, - VKB_CMD_vkCmdPushConstants = 70, - VKB_CMD_vkCmdPushConstants2 = 71, - VKB_CMD_vkCmdPushDescriptorSet = 72, - VKB_CMD_vkCmdPushDescriptorSet2 = 73, - VKB_CMD_vkCmdResetEvent = 74, - VKB_CMD_vkCmdResetEvent2 = 75, - VKB_CMD_vkCmdResetQueryPool = 76, - VKB_CMD_vkCmdResolveImage = 77, - VKB_CMD_vkCmdResolveImage2 = 78, - VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT = 79, - VKB_CMD_vkCmdSetAlphaToOneEnableEXT = 80, - VKB_CMD_vkCmdSetAttachmentFeedbackLoopEnableEXT = 81, - VKB_CMD_vkCmdSetBlendConstants = 82, - VKB_CMD_vkCmdSetColorBlendAdvancedEXT = 83, - VKB_CMD_vkCmdSetColorBlendEnableEXT = 84, - VKB_CMD_vkCmdSetColorBlendEquationEXT = 85, - VKB_CMD_vkCmdSetColorWriteEnableEXT = 86, - VKB_CMD_vkCmdSetColorWriteMaskEXT = 87, - VKB_CMD_vkCmdSetConservativeRasterizationModeEXT = 88, - VKB_CMD_vkCmdSetCullMode = 89, - VKB_CMD_vkCmdSetDepthBias = 90, - VKB_CMD_vkCmdSetDepthBias2EXT = 91, - VKB_CMD_vkCmdSetDepthBiasEnable = 92, - VKB_CMD_vkCmdSetDepthBounds = 93, - VKB_CMD_vkCmdSetDepthBoundsTestEnable = 94, - VKB_CMD_vkCmdSetDepthClampEnableEXT = 95, - VKB_CMD_vkCmdSetDepthClampRangeEXT = 96, - VKB_CMD_vkCmdSetDepthClipEnableEXT = 97, - VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT = 98, - VKB_CMD_vkCmdSetDepthCompareOp = 99, - VKB_CMD_vkCmdSetDepthTestEnable = 100, - VKB_CMD_vkCmdSetDepthWriteEnable = 101, - VKB_CMD_vkCmdSetDeviceMask = 102, - VKB_CMD_vkCmdSetDiscardRectangleEXT = 103, - VKB_CMD_vkCmdSetDiscardRectangleEnableEXT = 104, - VKB_CMD_vkCmdSetDiscardRectangleModeEXT = 105, - VKB_CMD_vkCmdSetEvent = 106, - VKB_CMD_vkCmdSetEvent2 = 107, - VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT = 108, - VKB_CMD_vkCmdSetFragmentShadingRateKHR = 109, - VKB_CMD_vkCmdSetFrontFace = 110, - VKB_CMD_vkCmdSetLineRasterizationModeEXT = 111, - VKB_CMD_vkCmdSetLineStipple = 112, - VKB_CMD_vkCmdSetLineStippleEnableEXT = 113, - VKB_CMD_vkCmdSetLineWidth = 114, - VKB_CMD_vkCmdSetLogicOpEXT = 115, - VKB_CMD_vkCmdSetLogicOpEnableEXT = 116, - VKB_CMD_vkCmdSetPatchControlPointsEXT = 117, - VKB_CMD_vkCmdSetPolygonModeEXT = 118, - VKB_CMD_vkCmdSetPrimitiveRestartEnable = 119, - VKB_CMD_vkCmdSetPrimitiveTopology = 120, - VKB_CMD_vkCmdSetProvokingVertexModeEXT = 121, - VKB_CMD_vkCmdSetRasterizationSamplesEXT = 122, - VKB_CMD_vkCmdSetRasterizationStreamEXT = 123, - VKB_CMD_vkCmdSetRasterizerDiscardEnable = 124, - VKB_CMD_vkCmdSetRenderingAttachmentLocations = 125, - VKB_CMD_vkCmdSetRenderingInputAttachmentIndices = 126, - VKB_CMD_vkCmdSetSampleLocationsEXT = 127, - VKB_CMD_vkCmdSetSampleLocationsEnableEXT = 128, - VKB_CMD_vkCmdSetSampleMaskEXT = 129, - VKB_CMD_vkCmdSetScissor = 130, - VKB_CMD_vkCmdSetScissorWithCount = 131, - VKB_CMD_vkCmdSetStencilCompareMask = 132, - VKB_CMD_vkCmdSetStencilOp = 133, - VKB_CMD_vkCmdSetStencilReference = 134, - VKB_CMD_vkCmdSetStencilTestEnable = 135, - VKB_CMD_vkCmdSetStencilWriteMask = 136, - VKB_CMD_vkCmdSetTessellationDomainOriginEXT = 137, - VKB_CMD_vkCmdSetVertexInputEXT = 138, - VKB_CMD_vkCmdSetViewport = 139, - VKB_CMD_vkCmdSetViewportWithCount = 140, - VKB_CMD_vkCmdUpdateBuffer = 141, - VKB_CMD_vkCmdWaitEvents = 142, - VKB_CMD_vkCmdWaitEvents2 = 143, - VKB_CMD_vkCmdWriteTimestamp = 144, - VKB_CMD_vkCmdWriteTimestamp2 = 145, - VKB_CMD_vkCreateBuffer = 146, - VKB_CMD_vkCreateBufferView = 147, - VKB_CMD_vkCreateCommandPool = 148, - VKB_CMD_vkCreateComputePipelines = 149, - VKB_CMD_vkCreateDescriptorPool = 150, - VKB_CMD_vkCreateDescriptorSetLayout = 151, - VKB_CMD_vkCreateDescriptorUpdateTemplate = 152, - VKB_CMD_vkCreateDevice = 153, - VKB_CMD_vkCreateEvent = 154, - VKB_CMD_vkCreateFence = 155, - VKB_CMD_vkCreateFramebuffer = 156, - VKB_CMD_vkCreateGraphicsPipelines = 157, - VKB_CMD_vkCreateImage = 158, - VKB_CMD_vkCreateImageView = 159, - VKB_CMD_vkCreateInstance = 160, - VKB_CMD_vkCreatePipelineCache = 161, - VKB_CMD_vkCreatePipelineLayout = 162, - VKB_CMD_vkCreateQueryPool = 163, - VKB_CMD_vkCreateRenderPass = 164, - VKB_CMD_vkCreateRenderPass2 = 165, - VKB_CMD_vkCreateSampler = 166, - VKB_CMD_vkCreateSamplerYcbcrConversion = 167, - VKB_CMD_vkCreateSemaphore = 168, - VKB_CMD_vkCreateShaderModule = 169, - VKB_CMD_vkCreateTensorARM = 170, - VKB_CMD_vkCreateTensorViewARM = 171, - VKB_CMD_vkDestroyBuffer = 172, - VKB_CMD_vkDestroyBufferView = 173, - VKB_CMD_vkDestroyCommandPool = 174, - VKB_CMD_vkDestroyDescriptorPool = 175, - VKB_CMD_vkDestroyDescriptorSetLayout = 176, - VKB_CMD_vkDestroyDescriptorUpdateTemplate = 177, - VKB_CMD_vkDestroyDevice = 178, - VKB_CMD_vkDestroyEvent = 179, - VKB_CMD_vkDestroyFence = 180, - VKB_CMD_vkDestroyFramebuffer = 181, - VKB_CMD_vkDestroyImage = 182, - VKB_CMD_vkDestroyImageView = 183, - VKB_CMD_vkDestroyInstance = 184, - VKB_CMD_vkDestroyPipeline = 185, - VKB_CMD_vkDestroyPipelineCache = 186, - VKB_CMD_vkDestroyPipelineLayout = 187, - VKB_CMD_vkDestroyQueryPool = 188, - VKB_CMD_vkDestroyRenderPass = 189, - VKB_CMD_vkDestroySampler = 190, - VKB_CMD_vkDestroySamplerYcbcrConversion = 191, - VKB_CMD_vkDestroySemaphore = 192, - VKB_CMD_vkDestroyShaderModule = 193, - VKB_CMD_vkDestroyTensorARM = 194, - VKB_CMD_vkDestroyTensorViewARM = 195, - VKB_CMD_vkDeviceWaitIdle = 196, - VKB_CMD_vkEndCommandBuffer = 197, - VKB_CMD_vkEnumerateDeviceExtensionProperties = 198, - VKB_CMD_vkEnumerateInstanceExtensionProperties = 199, - VKB_CMD_vkEnumerateInstanceLayerProperties = 200, - VKB_CMD_vkEnumerateInstanceVersion = 201, - VKB_CMD_vkEnumeratePhysicalDeviceGroups = 202, - VKB_CMD_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 203, - VKB_CMD_vkEnumeratePhysicalDevices = 204, - VKB_CMD_vkFlushMappedMemoryRanges = 205, - VKB_CMD_vkFreeCommandBuffers = 206, - VKB_CMD_vkFreeDescriptorSets = 207, - VKB_CMD_vkFreeMemory = 208, - VKB_CMD_vkGetBufferDeviceAddress = 209, - VKB_CMD_vkGetBufferMemoryRequirements = 210, - VKB_CMD_vkGetBufferMemoryRequirements2 = 211, - VKB_CMD_vkGetBufferOpaqueCaptureAddress = 212, - VKB_CMD_vkGetCalibratedTimestampsKHR = 213, - VKB_CMD_vkGetDescriptorSetLayoutSupport = 214, - VKB_CMD_vkGetDeviceBufferMemoryRequirements = 215, - VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures = 216, - VKB_CMD_vkGetDeviceImageMemoryRequirements = 217, - VKB_CMD_vkGetDeviceImageSparseMemoryRequirements = 218, - VKB_CMD_vkGetDeviceImageSubresourceLayout = 219, - VKB_CMD_vkGetDeviceMemoryCommitment = 220, - VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress = 221, - VKB_CMD_vkGetDeviceQueue = 222, - VKB_CMD_vkGetDeviceQueue2 = 223, - VKB_CMD_vkGetDeviceTensorMemoryRequirementsARM = 224, - VKB_CMD_vkGetEventStatus = 225, - VKB_CMD_vkGetFenceFdKHR = 226, - VKB_CMD_vkGetFenceStatus = 227, - VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT = 228, - VKB_CMD_vkGetImageMemoryRequirements = 229, - VKB_CMD_vkGetImageMemoryRequirements2 = 230, - VKB_CMD_vkGetImageSparseMemoryRequirements = 231, - VKB_CMD_vkGetImageSparseMemoryRequirements2 = 232, - VKB_CMD_vkGetImageSubresourceLayout = 233, - VKB_CMD_vkGetImageSubresourceLayout2 = 234, - VKB_CMD_vkGetMemoryFdKHR = 235, - VKB_CMD_vkGetMemoryFdPropertiesKHR = 236, - VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 237, - VKB_CMD_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 238, - VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties = 239, - VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties = 240, - VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties = 241, - VKB_CMD_vkGetPhysicalDeviceExternalTensorPropertiesARM = 242, - VKB_CMD_vkGetPhysicalDeviceFeatures = 243, - VKB_CMD_vkGetPhysicalDeviceFeatures2 = 244, - VKB_CMD_vkGetPhysicalDeviceFormatProperties = 245, - VKB_CMD_vkGetPhysicalDeviceFormatProperties2 = 246, - VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR = 247, - VKB_CMD_vkGetPhysicalDeviceImageFormatProperties = 248, - VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2 = 249, - VKB_CMD_vkGetPhysicalDeviceMemoryProperties = 250, - VKB_CMD_vkGetPhysicalDeviceMemoryProperties2 = 251, - VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT = 252, - VKB_CMD_vkGetPhysicalDeviceProperties = 253, - VKB_CMD_vkGetPhysicalDeviceProperties2 = 254, - VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties = 255, - VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2 = 256, - VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties = 257, - VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2 = 258, - VKB_CMD_vkGetPhysicalDeviceToolProperties = 259, - VKB_CMD_vkGetPipelineCacheData = 260, - VKB_CMD_vkGetQueryPoolResults = 261, - VKB_CMD_vkGetRenderAreaGranularity = 262, - VKB_CMD_vkGetRenderingAreaGranularity = 263, - VKB_CMD_vkGetSemaphoreCounterValue = 264, - VKB_CMD_vkGetSemaphoreFdKHR = 265, - VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT = 266, - VKB_CMD_vkGetShaderModuleIdentifierEXT = 267, - VKB_CMD_vkGetTensorMemoryRequirementsARM = 268, - VKB_CMD_vkImportFenceFdKHR = 269, - VKB_CMD_vkImportSemaphoreFdKHR = 270, - VKB_CMD_vkInvalidateMappedMemoryRanges = 271, - VKB_CMD_vkMergePipelineCaches = 272, - VKB_CMD_vkQueueBindSparse = 273, - VKB_CMD_vkQueueSubmit = 274, - VKB_CMD_vkQueueSubmit2 = 275, - VKB_CMD_vkQueueWaitIdle = 276, - VKB_CMD_vkResetCommandBuffer = 277, - VKB_CMD_vkResetCommandPool = 278, - VKB_CMD_vkResetDescriptorPool = 279, - VKB_CMD_vkResetEvent = 280, - VKB_CMD_vkResetFences = 281, - VKB_CMD_vkResetQueryPool = 282, - VKB_CMD_vkSetDeviceMemoryPriorityEXT = 283, - VKB_CMD_vkSetEvent = 284, - VKB_CMD_vkSignalSemaphore = 285, - VKB_CMD_vkTrimCommandPool = 286, - VKB_CMD_vkUpdateDescriptorSets = 287, - VKB_CMD_vkWaitForFences = 288, - VKB_CMD_vkWaitSemaphores = 289, - VKB_CMD_COUNT = 290 + VKB_CMD_vkbAllocDescSets = 4, + VKB_CMD_vkAllocateCommandBuffers = 5, + VKB_CMD_vkAllocateDescriptorSets = 6, + VKB_CMD_vkAllocateMemory = 7, + VKB_CMD_vkBeginCommandBuffer = 8, + VKB_CMD_vkBindBufferMemory = 9, + VKB_CMD_vkBindBufferMemory2 = 10, + VKB_CMD_vkBindImageMemory = 11, + VKB_CMD_vkBindImageMemory2 = 12, + VKB_CMD_vkBindTensorMemoryARM = 13, + VKB_CMD_vkCmdBeginConditionalRenderingEXT = 14, + VKB_CMD_vkCmdBeginCustomResolveEXT = 15, + VKB_CMD_vkCmdBeginQuery = 16, + VKB_CMD_vkCmdBeginQueryIndexedEXT = 17, + VKB_CMD_vkCmdBeginRenderPass = 18, + VKB_CMD_vkCmdBeginRenderPass2 = 19, + VKB_CMD_vkCmdBeginRendering = 20, + VKB_CMD_vkCmdBeginTransformFeedbackEXT = 21, + VKB_CMD_vkCmdBindDescriptorSets = 22, + VKB_CMD_vkCmdBindDescriptorSets2 = 23, + VKB_CMD_vkCmdBindIndexBuffer = 24, + VKB_CMD_vkCmdBindIndexBuffer2 = 25, + VKB_CMD_vkCmdBindPipeline = 26, + VKB_CMD_vkCmdBindTransformFeedbackBuffersEXT = 27, + VKB_CMD_vkCmdBindVertexBuffers = 28, + VKB_CMD_vkCmdBindVertexBuffers2 = 29, + VKB_CMD_vkCmdBlitImage = 30, + VKB_CMD_vkCmdBlitImage2 = 31, + VKB_CMD_vkCmdClearAttachments = 32, + VKB_CMD_vkCmdClearColorImage = 33, + VKB_CMD_vkCmdClearDepthStencilImage = 34, + VKB_CMD_vkCmdCopyBuffer = 35, + VKB_CMD_vkCmdCopyBuffer2 = 36, + VKB_CMD_vkCmdCopyBufferToImage = 37, + VKB_CMD_vkCmdCopyBufferToImage2 = 38, + VKB_CMD_vkCmdCopyImage = 39, + VKB_CMD_vkCmdCopyImage2 = 40, + VKB_CMD_vkCmdCopyImageToBuffer = 41, + VKB_CMD_vkCmdCopyImageToBuffer2 = 42, + VKB_CMD_vkCmdCopyQueryPoolResults = 43, + VKB_CMD_vkCmdCopyTensorARM = 44, + VKB_CMD_vkCmdDispatch = 45, + VKB_CMD_vkCmdDispatchBase = 46, + VKB_CMD_vkCmdDispatchIndirect = 47, + VKB_CMD_vkCmdDraw = 48, + VKB_CMD_vkCmdDrawIndexed = 49, + VKB_CMD_vkCmdDrawIndexedIndirect = 50, + VKB_CMD_vkCmdDrawIndexedIndirectCount = 51, + VKB_CMD_vkCmdDrawIndirect = 52, + VKB_CMD_vkCmdDrawIndirectByteCountEXT = 53, + VKB_CMD_vkCmdDrawIndirectCount = 54, + VKB_CMD_vkCmdDrawMultiEXT = 55, + VKB_CMD_vkCmdDrawMultiIndexedEXT = 56, + VKB_CMD_vkCmdEndConditionalRenderingEXT = 57, + VKB_CMD_vkCmdEndQuery = 58, + VKB_CMD_vkCmdEndQueryIndexedEXT = 59, + VKB_CMD_vkCmdEndRenderPass = 60, + VKB_CMD_vkCmdEndRenderPass2 = 61, + VKB_CMD_vkCmdEndRendering = 62, + VKB_CMD_vkCmdEndRendering2KHR = 63, + VKB_CMD_vkCmdEndTransformFeedbackEXT = 64, + VKB_CMD_vkCmdExecuteCommands = 65, + VKB_CMD_vkCmdFillBuffer = 66, + VKB_CMD_vkCmdNextSubpass = 67, + VKB_CMD_vkCmdNextSubpass2 = 68, + VKB_CMD_vkCmdPipelineBarrier = 69, + VKB_CMD_vkCmdPipelineBarrier2 = 70, + VKB_CMD_vkCmdPushConstants = 71, + VKB_CMD_vkCmdPushConstants2 = 72, + VKB_CMD_vkCmdPushDescriptorSet = 73, + VKB_CMD_vkCmdPushDescriptorSet2 = 74, + VKB_CMD_vkCmdResetEvent = 75, + VKB_CMD_vkCmdResetEvent2 = 76, + VKB_CMD_vkCmdResetQueryPool = 77, + VKB_CMD_vkCmdResolveImage = 78, + VKB_CMD_vkCmdResolveImage2 = 79, + VKB_CMD_vkCmdSetAlphaToCoverageEnableEXT = 80, + VKB_CMD_vkCmdSetAlphaToOneEnableEXT = 81, + VKB_CMD_vkCmdSetAttachmentFeedbackLoopEnableEXT = 82, + VKB_CMD_vkCmdSetBlendConstants = 83, + VKB_CMD_vkCmdSetColorBlendAdvancedEXT = 84, + VKB_CMD_vkCmdSetColorBlendEnableEXT = 85, + VKB_CMD_vkCmdSetColorBlendEquationEXT = 86, + VKB_CMD_vkCmdSetColorWriteEnableEXT = 87, + VKB_CMD_vkCmdSetColorWriteMaskEXT = 88, + VKB_CMD_vkCmdSetConservativeRasterizationModeEXT = 89, + VKB_CMD_vkCmdSetCullMode = 90, + VKB_CMD_vkCmdSetDepthBias = 91, + VKB_CMD_vkCmdSetDepthBias2EXT = 92, + VKB_CMD_vkCmdSetDepthBiasEnable = 93, + VKB_CMD_vkCmdSetDepthBounds = 94, + VKB_CMD_vkCmdSetDepthBoundsTestEnable = 95, + VKB_CMD_vkCmdSetDepthClampEnableEXT = 96, + VKB_CMD_vkCmdSetDepthClampRangeEXT = 97, + VKB_CMD_vkCmdSetDepthClipEnableEXT = 98, + VKB_CMD_vkCmdSetDepthClipNegativeOneToOneEXT = 99, + VKB_CMD_vkCmdSetDepthCompareOp = 100, + VKB_CMD_vkCmdSetDepthTestEnable = 101, + VKB_CMD_vkCmdSetDepthWriteEnable = 102, + VKB_CMD_vkCmdSetDeviceMask = 103, + VKB_CMD_vkCmdSetDiscardRectangleEXT = 104, + VKB_CMD_vkCmdSetDiscardRectangleEnableEXT = 105, + VKB_CMD_vkCmdSetDiscardRectangleModeEXT = 106, + VKB_CMD_vkCmdSetEvent = 107, + VKB_CMD_vkCmdSetEvent2 = 108, + VKB_CMD_vkCmdSetExtraPrimitiveOverestimationSizeEXT = 109, + VKB_CMD_vkCmdSetFragmentShadingRateKHR = 110, + VKB_CMD_vkCmdSetFrontFace = 111, + VKB_CMD_vkCmdSetLineRasterizationModeEXT = 112, + VKB_CMD_vkCmdSetLineStipple = 113, + VKB_CMD_vkCmdSetLineStippleEnableEXT = 114, + VKB_CMD_vkCmdSetLineWidth = 115, + VKB_CMD_vkCmdSetLogicOpEXT = 116, + VKB_CMD_vkCmdSetLogicOpEnableEXT = 117, + VKB_CMD_vkCmdSetPatchControlPointsEXT = 118, + VKB_CMD_vkCmdSetPolygonModeEXT = 119, + VKB_CMD_vkCmdSetPrimitiveRestartEnable = 120, + VKB_CMD_vkCmdSetPrimitiveTopology = 121, + VKB_CMD_vkCmdSetProvokingVertexModeEXT = 122, + VKB_CMD_vkCmdSetRasterizationSamplesEXT = 123, + VKB_CMD_vkCmdSetRasterizationStreamEXT = 124, + VKB_CMD_vkCmdSetRasterizerDiscardEnable = 125, + VKB_CMD_vkCmdSetRenderingAttachmentLocations = 126, + VKB_CMD_vkCmdSetRenderingInputAttachmentIndices = 127, + VKB_CMD_vkCmdSetSampleLocationsEXT = 128, + VKB_CMD_vkCmdSetSampleLocationsEnableEXT = 129, + VKB_CMD_vkCmdSetSampleMaskEXT = 130, + VKB_CMD_vkCmdSetScissor = 131, + VKB_CMD_vkCmdSetScissorWithCount = 132, + VKB_CMD_vkCmdSetStencilCompareMask = 133, + VKB_CMD_vkCmdSetStencilOp = 134, + VKB_CMD_vkCmdSetStencilReference = 135, + VKB_CMD_vkCmdSetStencilTestEnable = 136, + VKB_CMD_vkCmdSetStencilWriteMask = 137, + VKB_CMD_vkCmdSetTessellationDomainOriginEXT = 138, + VKB_CMD_vkCmdSetVertexInputEXT = 139, + VKB_CMD_vkCmdSetViewport = 140, + VKB_CMD_vkCmdSetViewportWithCount = 141, + VKB_CMD_vkCmdUpdateBuffer = 142, + VKB_CMD_vkCmdWaitEvents = 143, + VKB_CMD_vkCmdWaitEvents2 = 144, + VKB_CMD_vkCmdWriteTimestamp = 145, + VKB_CMD_vkCmdWriteTimestamp2 = 146, + VKB_CMD_vkCreateBuffer = 147, + VKB_CMD_vkCreateBufferView = 148, + VKB_CMD_vkCreateCommandPool = 149, + VKB_CMD_vkCreateComputePipelines = 150, + VKB_CMD_vkCreateDescriptorPool = 151, + VKB_CMD_vkCreateDescriptorSetLayout = 152, + VKB_CMD_vkCreateDescriptorUpdateTemplate = 153, + VKB_CMD_vkCreateDevice = 154, + VKB_CMD_vkCreateEvent = 155, + VKB_CMD_vkCreateFence = 156, + VKB_CMD_vkCreateFramebuffer = 157, + VKB_CMD_vkCreateGraphicsPipelines = 158, + VKB_CMD_vkCreateImage = 159, + VKB_CMD_vkCreateImageView = 160, + VKB_CMD_vkCreateInstance = 161, + VKB_CMD_vkCreatePipelineCache = 162, + VKB_CMD_vkCreatePipelineLayout = 163, + VKB_CMD_vkCreateQueryPool = 164, + VKB_CMD_vkCreateRenderPass = 165, + VKB_CMD_vkCreateRenderPass2 = 166, + VKB_CMD_vkCreateSampler = 167, + VKB_CMD_vkCreateSamplerYcbcrConversion = 168, + VKB_CMD_vkCreateSemaphore = 169, + VKB_CMD_vkCreateShaderModule = 170, + VKB_CMD_vkCreateTensorARM = 171, + VKB_CMD_vkCreateTensorViewARM = 172, + VKB_CMD_vkDestroyBuffer = 173, + VKB_CMD_vkDestroyBufferView = 174, + VKB_CMD_vkDestroyCommandPool = 175, + VKB_CMD_vkDestroyDescriptorPool = 176, + VKB_CMD_vkDestroyDescriptorSetLayout = 177, + VKB_CMD_vkDestroyDescriptorUpdateTemplate = 178, + VKB_CMD_vkDestroyDevice = 179, + VKB_CMD_vkDestroyEvent = 180, + VKB_CMD_vkDestroyFence = 181, + VKB_CMD_vkDestroyFramebuffer = 182, + VKB_CMD_vkDestroyImage = 183, + VKB_CMD_vkDestroyImageView = 184, + VKB_CMD_vkDestroyInstance = 185, + VKB_CMD_vkDestroyPipeline = 186, + VKB_CMD_vkDestroyPipelineCache = 187, + VKB_CMD_vkDestroyPipelineLayout = 188, + VKB_CMD_vkDestroyQueryPool = 189, + VKB_CMD_vkDestroyRenderPass = 190, + VKB_CMD_vkDestroySampler = 191, + VKB_CMD_vkDestroySamplerYcbcrConversion = 192, + VKB_CMD_vkDestroySemaphore = 193, + VKB_CMD_vkDestroyShaderModule = 194, + VKB_CMD_vkDestroyTensorARM = 195, + VKB_CMD_vkDestroyTensorViewARM = 196, + VKB_CMD_vkDeviceWaitIdle = 197, + VKB_CMD_vkEndCommandBuffer = 198, + VKB_CMD_vkEnumerateDeviceExtensionProperties = 199, + VKB_CMD_vkEnumerateInstanceExtensionProperties = 200, + VKB_CMD_vkEnumerateInstanceLayerProperties = 201, + VKB_CMD_vkEnumerateInstanceVersion = 202, + VKB_CMD_vkEnumeratePhysicalDeviceGroups = 203, + VKB_CMD_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 204, + VKB_CMD_vkEnumeratePhysicalDevices = 205, + VKB_CMD_vkFlushMappedMemoryRanges = 206, + VKB_CMD_vkFreeCommandBuffers = 207, + VKB_CMD_vkFreeDescriptorSets = 208, + VKB_CMD_vkFreeMemory = 209, + VKB_CMD_vkGetBufferDeviceAddress = 210, + VKB_CMD_vkGetBufferMemoryRequirements = 211, + VKB_CMD_vkGetBufferMemoryRequirements2 = 212, + VKB_CMD_vkGetBufferOpaqueCaptureAddress = 213, + VKB_CMD_vkGetCalibratedTimestampsKHR = 214, + VKB_CMD_vkGetDescriptorSetLayoutSupport = 215, + VKB_CMD_vkGetDeviceBufferMemoryRequirements = 216, + VKB_CMD_vkGetDeviceGroupPeerMemoryFeatures = 217, + VKB_CMD_vkGetDeviceImageMemoryRequirements = 218, + VKB_CMD_vkGetDeviceImageSparseMemoryRequirements = 219, + VKB_CMD_vkGetDeviceImageSubresourceLayout = 220, + VKB_CMD_vkGetDeviceMemoryCommitment = 221, + VKB_CMD_vkGetDeviceMemoryOpaqueCaptureAddress = 222, + VKB_CMD_vkGetDeviceQueue = 223, + VKB_CMD_vkGetDeviceQueue2 = 224, + VKB_CMD_vkGetDeviceTensorMemoryRequirementsARM = 225, + VKB_CMD_vkGetEventStatus = 226, + VKB_CMD_vkGetFenceFdKHR = 227, + VKB_CMD_vkGetFenceStatus = 228, + VKB_CMD_vkGetImageDrmFormatModifierPropertiesEXT = 229, + VKB_CMD_vkGetImageMemoryRequirements = 230, + VKB_CMD_vkGetImageMemoryRequirements2 = 231, + VKB_CMD_vkGetImageSparseMemoryRequirements = 232, + VKB_CMD_vkGetImageSparseMemoryRequirements2 = 233, + VKB_CMD_vkGetImageSubresourceLayout = 234, + VKB_CMD_vkGetImageSubresourceLayout2 = 235, + VKB_CMD_vkGetMemoryFdKHR = 236, + VKB_CMD_vkGetMemoryFdPropertiesKHR = 237, + VKB_CMD_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 238, + VKB_CMD_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 239, + VKB_CMD_vkGetPhysicalDeviceExternalBufferProperties = 240, + VKB_CMD_vkGetPhysicalDeviceExternalFenceProperties = 241, + VKB_CMD_vkGetPhysicalDeviceExternalSemaphoreProperties = 242, + VKB_CMD_vkGetPhysicalDeviceExternalTensorPropertiesARM = 243, + VKB_CMD_vkGetPhysicalDeviceFeatures = 244, + VKB_CMD_vkGetPhysicalDeviceFeatures2 = 245, + VKB_CMD_vkGetPhysicalDeviceFormatProperties = 246, + VKB_CMD_vkGetPhysicalDeviceFormatProperties2 = 247, + VKB_CMD_vkGetPhysicalDeviceFragmentShadingRatesKHR = 248, + VKB_CMD_vkGetPhysicalDeviceImageFormatProperties = 249, + VKB_CMD_vkGetPhysicalDeviceImageFormatProperties2 = 250, + VKB_CMD_vkGetPhysicalDeviceMemoryProperties = 251, + VKB_CMD_vkGetPhysicalDeviceMemoryProperties2 = 252, + VKB_CMD_vkGetPhysicalDeviceMultisamplePropertiesEXT = 253, + VKB_CMD_vkGetPhysicalDeviceProperties = 254, + VKB_CMD_vkGetPhysicalDeviceProperties2 = 255, + VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties = 256, + VKB_CMD_vkGetPhysicalDeviceQueueFamilyProperties2 = 257, + VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties = 258, + VKB_CMD_vkGetPhysicalDeviceSparseImageFormatProperties2 = 259, + VKB_CMD_vkGetPhysicalDeviceToolProperties = 260, + VKB_CMD_vkGetPipelineCacheData = 261, + VKB_CMD_vkGetQueryPoolResults = 262, + VKB_CMD_vkGetRenderAreaGranularity = 263, + VKB_CMD_vkGetRenderingAreaGranularity = 264, + VKB_CMD_vkGetSemaphoreCounterValue = 265, + VKB_CMD_vkGetSemaphoreFdKHR = 266, + VKB_CMD_vkGetShaderModuleCreateInfoIdentifierEXT = 267, + VKB_CMD_vkGetShaderModuleIdentifierEXT = 268, + VKB_CMD_vkGetTensorMemoryRequirementsARM = 269, + VKB_CMD_vkImportFenceFdKHR = 270, + VKB_CMD_vkImportSemaphoreFdKHR = 271, + VKB_CMD_vkInvalidateMappedMemoryRanges = 272, + VKB_CMD_vkMergePipelineCaches = 273, + VKB_CMD_vkQueueBindSparse = 274, + VKB_CMD_vkQueueSubmit = 275, + VKB_CMD_vkQueueSubmit2 = 276, + VKB_CMD_vkQueueWaitIdle = 277, + VKB_CMD_vkResetCommandBuffer = 278, + VKB_CMD_vkResetCommandPool = 279, + VKB_CMD_vkResetDescriptorPool = 280, + VKB_CMD_vkResetEvent = 281, + VKB_CMD_vkResetFences = 282, + VKB_CMD_vkResetQueryPool = 283, + VKB_CMD_vkSetDeviceMemoryPriorityEXT = 284, + VKB_CMD_vkSetEvent = 285, + VKB_CMD_vkSignalSemaphore = 286, + VKB_CMD_vkTrimCommandPool = 287, + VKB_CMD_vkUpdateDescriptorSets = 288, + VKB_CMD_vkWaitForFences = 289, + VKB_CMD_vkWaitSemaphores = 290, + VKB_CMD_COUNT = 291 }; extern const char *const vkb_cmd_names[VKB_CMD_COUNT]; extern const unsigned char vkb_cmd_result[VKB_CMD_COUNT]; /* returns VkResult (first in the reply) */ diff --git a/tools/vkbridge/common/gen/vkb_gen_server.c b/tools/vkbridge/common/gen/vkb_gen_server.c index e1d2627c0..a03a15dca 100644 --- a/tools/vkbridge/common/gen/vkb_gen_server.c +++ b/tools/vkbridge/common/gen/vkb_gen_server.c @@ -7428,6 +7428,7 @@ const vkb_srv_handler vkb_srv_handlers[VKB_CMD_COUNT] = { [VKB_CMD_vkbQueryServer] = vkb_sv_vkbQueryServer, [VKB_CMD_vkbDescUpdateRaw] = vkb_sv_vkbDescUpdateRaw, [VKB_CMD_vkbPushDescRaw] = vkb_sv_vkbPushDescRaw, + [VKB_CMD_vkbAllocDescSets] = vkb_sv_vkbAllocDescSets, [VKB_CMD_vkAllocateCommandBuffers] = vkb_sv_vkAllocateCommandBuffers, [VKB_CMD_vkAllocateDescriptorSets] = vkb_sv_vkAllocateDescriptorSets, [VKB_CMD_vkAllocateMemory] = vkb_sv_vkAllocateMemory, diff --git a/tools/vkbridge/common/gen/vkb_gen_structs.c b/tools/vkbridge/common/gen/vkb_gen_structs.c index ea3d988e8..bede111a4 100644 --- a/tools/vkbridge/common/gen/vkb_gen_structs.c +++ b/tools/vkbridge/common/gen/vkb_gen_structs.c @@ -15650,6 +15650,7 @@ const char *const vkb_cmd_names[VKB_CMD_COUNT] = { "vkbQueryServer", "vkbDescUpdateRaw", "vkbPushDescRaw", + "vkbAllocDescSets", "vkAllocateCommandBuffers", "vkAllocateDescriptorSets", "vkAllocateMemory", @@ -15942,6 +15943,7 @@ const unsigned char vkb_cmd_result[VKB_CMD_COUNT] = { 0, 0, 0, + 0, 1, 1, 1, diff --git a/tools/vkbridge/common/gen/vkb_server_gen.h b/tools/vkbridge/common/gen/vkb_server_gen.h index d34f04f6f..c7a44fac3 100644 --- a/tools/vkbridge/common/gen/vkb_server_gen.h +++ b/tools/vkbridge/common/gen/vkb_server_gen.h @@ -296,4 +296,5 @@ void vkb_sv_vkbHello(vkb_srv_call *c); void vkb_sv_vkbQueryServer(vkb_srv_call *c); void vkb_sv_vkbDescUpdateRaw(vkb_srv_call *c); void vkb_sv_vkbPushDescRaw(vkb_srv_call *c); +void vkb_sv_vkbAllocDescSets(vkb_srv_call *c); #endif