perf(vkbridge): client-named descriptor sets, allocated without a round trip

Where the client keeps a pool's books and knows every layout, it names the
sets itself (top bit set) and sends vkbAllocDescSets asynchronously; the
server allocates the driver's sets and translates the names in dispatch
wrappers (updates, template updates, binds, frees) and forgets them on pool
reset/destroy. All-or-nothing; a full pool still answers OUT_OF_POOL_MEMORY.

d3d11_bench 1000 draws: 1.43 -> 1.12 ms/frame (native 0.30); the only
synchronous call left per frame is vkWaitSemaphores. Host suite 14/14.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01S1U9H1evGNjHRQ3wRUdv5V
This commit is contained in:
Ahmad Sayed Alsayed EbrahimandClaude Opus 5.5 committed 2026-10-10 14:52:59 +03:00
1 parent 850c929967
commit 0e7f8e7170
10 files changed
+689 -289

No files matched your search

+1
View File
@@ -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);
+337
View File
@@ -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 <stdlib.h>
#include <string.h>
#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;
}
@@ -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);
+5
View File
@@ -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);
+50
View File
@@ -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++) {
+1 -1
View File
@@ -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).
+289 -288
View File
@@ -12,299 +12,300 @@
#include <stdint.h>
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) */
@@ -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,
@@ -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,
@@ -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