perf(vkbridge): async requests with ordering, batched descriptor sets, buffered server reads

- Ordered async protocol: vkb_msg_hdr seq/barrier, per-process ordering gate on
  the server; void commands and VkResult commands without outputs (submits,
  resets, binds, vkEndCommandBuffer replay) no longer wait for a reply.
  VKBRIDGE_SYNC=1 restores synchronous calls for debugging.
- Client async queue batched across threads with a ~100us background flusher.
- Descriptor sets allocated in batches per (pool, layout); the client keeps the
  pool's books (layout descriptor counts vs pool sizes) so batches ask only for
  what fits and a full pool answers OUT_OF_POOL_MEMORY without a round trip.
  Caches for a destroyed layout are dropped (its handle may be reused).
- Server parses requests out of one receive buffer (descriptor FIFO for
  SCM_RIGHTS) instead of two reads per message.
- Server logs async VkResult failures (generated vkb_cmd_result table) and
  per-command timing with VKBRIDGE_STATS=<s>.
- tests/d3d11_bench.c: game-like D3D11 frame (1000 draws, Map DISCARD, rebinds).

d3d11_bench 1000 draws on RADV: native 0.30 ms/frame; bridge 26.3 ms (sync)
-> 1.43 ms. Host suite 14/14 in plain and Mali-imitation modes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ahmad Sayed Alsayed EbrahimandClaude Opus 5.5 committed 2026-10-10 14:28:13 +03:00
1 parent 308b200350
commit a4bd2eb271
14 files changed
+1247 -314

No files matched your search

+4 -1
View File
@@ -192,7 +192,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkEndCommandBuffer(VkCommandBuffer command
vkb_enc_u64(&c.e, cb->obj.remote);
vkb_enc_blob(&c.e, cb->stream.buf ? cb->stream.buf : (const void *)"", cb->stream.len);
VkResult r = VK_ERROR_DEVICE_LOST;
if (vkb_call_exec(&c)) {
if (vkb_async_results()) {
/* Replayed on the server while the app goes on; ordered before its submit. */
r = vkb_call_exec_async(&c) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
} else if (vkb_call_exec(&c)) {
r = (VkResult)vkb_dec_u32(&c.d);
vkb_call_end(&c);
}
+215 -3
View File
@@ -79,6 +79,8 @@ typedef struct vkb_conn {
} vkb_conn;
static uint64_t process_token;
/* The last asynchronous request's sequence number in this process (see vkb_msg_hdr). */
static uint64_t async_seq;
static uint32_t fork_epoch;
static pthread_key_t conn_key;
static pthread_once_t conn_once = PTHREAD_ONCE_INIT;
@@ -99,11 +101,102 @@ static void conn_thread_exit(void *p)
conn_free(p);
}
/* Asynchronous requests of the whole process wait here and are written out in one go, ahead of
* the next synchronous request any thread makes (or when the queue grows large). They carry their
* sequence numbers, so whichever connection carries them, the server runs them in order. */
static pthread_mutex_t aq_lock = PTHREAD_MUTEX_INITIALIZER;
static uint8_t *aq_buf;
static size_t aq_len, aq_cap;
#define AQ_FLUSH (256u << 10)
static int write_all(int sock, const void *p, size_t n)
{
const uint8_t *b = p;
while (n) {
ssize_t r = send(sock, b, n, MSG_NOSIGNAL);
if (r < 0) {
if (errno == EINTR) continue;
return -1;
}
b += r;
n -= (size_t)r;
}
return 0;
}
static int aq_flush_locked(vkb_conn *conn)
{
if (!aq_len) return 0;
int r = write_all(conn->sock, aq_buf, aq_len);
aq_len = 0;
if (aq_cap > (4u << 20)) {
free(aq_buf);
aq_buf = NULL;
aq_cap = 0;
}
return r;
}
/* The flusher: asynchronous requests do not wait for the next synchronous one forever - another
* thread may be blocked in the server on work they would start (a submit that signals what it is
* waiting for). It sends what is queued ~100 us after it was queued, batching what follows. */
static pthread_cond_t aq_cond = PTHREAD_COND_INITIALIZER;
static int aq_flusher_started;
static uint64_t aq_first_ns;
static uint64_t now_ns(void)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
}
static vkb_conn *get_conn(void);
static void *aq_flusher(void *arg)
{
(void)arg;
vkb_conn *conn = get_conn();
if (!conn) return NULL;
pthread_mutex_lock(&aq_lock);
for (;;) {
while (!aq_len) pthread_cond_wait(&aq_cond, &aq_lock);
uint64_t due = aq_first_ns + 100000, now = now_ns();
if (now < due && aq_len < AQ_FLUSH / 4) {
pthread_mutex_unlock(&aq_lock);
struct timespec ts = {0, (long)(due - now)};
nanosleep(&ts, NULL);
pthread_mutex_lock(&aq_lock);
continue;
}
if (aq_flush_locked(conn) < 0) {
conn->dead = 1;
break;
}
}
pthread_mutex_unlock(&aq_lock);
return NULL;
}
static void aq_exit_flush(void)
{
vkb_conn *c = tls_conn;
if (!c || c->dead) return;
pthread_mutex_lock(&aq_lock);
aq_flush_locked(c);
pthread_mutex_unlock(&aq_lock);
}
static void atfork_child(void)
{
aq_len = 0;
aq_flusher_started = 0;
pthread_cond_init(&aq_cond, NULL);
pthread_mutex_init(&aq_lock, NULL);
/* The child must not talk on the parent's sockets: new token, new connections. */
fork_epoch++;
process_token = 0;
async_seq = 0;
tls_conn = NULL; /* the old one is leaked deliberately: its socket belongs to the parent too */
}
@@ -111,6 +204,7 @@ static void conn_init_once(void)
{
pthread_key_create(&conn_key, conn_thread_exit);
pthread_atfork(NULL, NULL, atfork_child);
atexit(aq_exit_flush);
}
void vkb_conn_after_fork(void) { atfork_child(); }
@@ -172,7 +266,7 @@ static int do_connect(vkb_conn *c)
fclose(f);
}
vkb_enc_str(&e, comm);
vkb_msg_hdr h = {VKB_MAGIC, (uint32_t)e.len, VKB_CMD_vkbHello, 0, 0, 0};
vkb_msg_hdr h = {VKB_MAGIC, (uint32_t)e.len, VKB_CMD_vkbHello, 0, 0, 0, 0, 0};
int ok = vkb_send_msg(s, &h, e.buf, NULL, 0) == 0;
vkb_enc_free(&e);
int fds[VKB_MAX_FDS], nfds = 0;
@@ -279,8 +373,62 @@ int vkb_call_exec(vkb_call *c)
c->conn = NULL;
return 0;
}
vkb_msg_hdr h = {VKB_MAGIC, (uint32_t)c->e.len, c->cmd, c->table, (uint32_t)c->e.nfds, c->flags & VKB_F_NOREPLY};
if (vkb_send_msg(conn->sock, &h, c->e.buf, c->e.fds, c->e.nfds) < 0) {
vkb_msg_hdr h = {VKB_MAGIC, (uint32_t)c->e.len, c->cmd, c->table, (uint32_t)c->e.nfds, c->flags & VKB_F_NOREPLY, 0, 0};
vkb_stats_count(c->cmd, (c->flags & VKB_F_NOREPLY) != 0, c->e.len);
pthread_mutex_lock(&aq_lock);
if ((c->flags & VKB_F_NOREPLY) && !c->e.nfds) {
/* Queued: header and payload appended under the lock that also orders the seqs. */
h.seq = ++async_seq;
h.barrier = h.seq - 1;
size_t need = aq_len + sizeof(h) + c->e.len;
if (need > aq_cap) {
size_t nc = aq_cap ? aq_cap : 65536;
while (nc < need) nc *= 2;
uint8_t *nb = realloc(aq_buf, nc);
if (!nb) {
pthread_mutex_unlock(&aq_lock);
release_enc(c);
c->conn = NULL;
return 0;
}
aq_buf = nb;
aq_cap = nc;
}
if (!aq_len) aq_first_ns = now_ns();
memcpy(aq_buf + aq_len, &h, sizeof(h));
memcpy(aq_buf + aq_len + sizeof(h), c->e.buf, c->e.len);
aq_len = need;
if (!aq_flusher_started) {
aq_flusher_started = 1;
pthread_t t;
pthread_attr_t a;
pthread_attr_init(&a);
pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
if (pthread_create(&t, &a, aq_flusher, NULL) != 0) aq_flusher_started = 0;
pthread_attr_destroy(&a);
}
pthread_cond_signal(&aq_cond);
int r = aq_len >= AQ_FLUSH ? aq_flush_locked(conn) : 0;
pthread_mutex_unlock(&aq_lock);
release_enc(c);
c->conn = NULL;
if (r < 0) {
VKB_ERR("lost the bridge server (%s)", strerror(errno));
conn->dead = 1;
return 0;
}
return 1;
}
/* Everything queued goes first, on this connection. */
int qr = aq_flush_locked(conn);
if (c->flags & VKB_F_NOREPLY) {
h.seq = ++async_seq;
h.barrier = h.seq - 1;
} else {
h.barrier = async_seq;
}
pthread_mutex_unlock(&aq_lock);
if (qr < 0 || vkb_send_msg(conn->sock, &h, c->e.buf, c->e.fds, c->e.nfds) < 0) {
VKB_ERR("%s: lost the bridge server (%s)", vkb_cmd_names[c->cmd], strerror(errno));
conn->dead = 1;
release_enc(c);
@@ -323,6 +471,70 @@ void vkb_call_end(vkb_call *c)
c->conn = NULL;
}
/* VkResult commands treated as asynchronous (ASYNC_RESULT in the generator): on unless
* VKBRIDGE_SYNC is set. */
int vkb_async_results(void)
{
static int v = -1;
if (v < 0) v = getenv("VKBRIDGE_SYNC") == NULL;
return v;
}
/* Asynchronous variant: no reply is awaited (void commands without outputs). */
int vkb_call_exec_async(vkb_call *c)
{
if (getenv("VKBRIDGE_SYNC")) return vkb_call_exec(c) ? (vkb_call_end(c), 1) : 0;
c->flags |= VKB_F_NOREPLY;
return vkb_call_exec(c);
}
/* VKBRIDGE_STATS=<seconds>: per-command counts of round trips and async sends, logged. */
static uint32_t stat_sync[VKB_CMD_COUNT], stat_async[VKB_CMD_COUNT];
static uint64_t stat_bytes;
static uint64_t stat_last;
void vkb_stats_count(uint32_t cmd, int async, size_t bytes)
{
static int period = -1;
if (period < 0) {
const char *v = getenv("VKBRIDGE_STATS");
period = v ? atoi(v) : 0;
}
if (!period) return;
__atomic_add_fetch(async ? &stat_async[cmd] : &stat_sync[cmd], 1, __ATOMIC_RELAXED);
__atomic_add_fetch(&stat_bytes, bytes, __ATOMIC_RELAXED);
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
uint64_t now = (uint64_t)ts.tv_sec;
uint64_t last = __atomic_load_n(&stat_last, __ATOMIC_RELAXED);
if (!last) {
__atomic_store_n(&stat_last, now, __ATOMIC_RELAXED);
return;
}
if (now - last < (uint64_t)period || !__atomic_compare_exchange_n(&stat_last, &last, now, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED))
return;
uint32_t tot_s = 0, tot_a = 0;
for (uint32_t i = 0; i < VKB_CMD_COUNT; i++) {
tot_s += stat_sync[i];
tot_a += stat_async[i];
}
vkb_log(VKB_LOG_ERROR, "stats over %us: %u round trips, %u async, %llu KB sent", period, tot_s, tot_a,
(unsigned long long)(stat_bytes >> 10));
for (int k = 0; k < 8; k++) {
uint32_t best = 0, bi = 0;
for (uint32_t i = 0; i < VKB_CMD_COUNT; i++)
if (stat_sync[i] + stat_async[i] > best) {
best = stat_sync[i] + stat_async[i];
bi = i;
}
if (!best) break;
vkb_log(VKB_LOG_ERROR, " %-40s %6u sync %6u async", vkb_cmd_names[bi], stat_sync[bi], stat_async[bi]);
stat_sync[bi] = stat_async[bi] = 0;
}
memset(stat_sync, 0, sizeof(stat_sync));
memset(stat_async, 0, sizeof(stat_async));
stat_bytes = 0;
}
uint32_t vkb_table_of(const void *h)
{
return h ? ((const vkb_object *)h)->table : 0;
+295 -1
View File
@@ -134,7 +134,7 @@ VKAPI_ATTR void VKAPI_CALL vkb_ep_vkUpdateDescriptorSetWithTemplate(VkDevice dev
vkb_enc_u64(&c.e, t->size);
size_t at = vkb_enc_raw(&c.e, NULL, t->size);
if (!c.e.oom) pack(t, pData, c.e.buf + at);
if (vkb_call_exec(&c)) vkb_call_end(&c);
vkb_call_exec_async(&c);
}
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkCmdPushDescriptorSetWithTemplate(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate tmpl,
@@ -306,3 +306,297 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkTransitionImageLayout(VkDevice device, u
(void)pTransitions;
return VK_ERROR_FEATURE_NOT_PRESENT;
}
/* ------------------------------------------------------------------ descriptor set batching */
/*
* DXVK allocates a descriptor set (or two) per draw; one round trip each was most of a frame's
* time. Sets are allocated from the server in batches per (pool, layout) and handed out here. A
* pool's reset or destruction drops what was cached for it (the reset freed those sets anyway).
*
* Where it can, the client keeps the pool's books: what each layout takes of every descriptor
* type, and what the pool has left. A batch then asks for no more than fits, and a pool that is
* full answers VK_ERROR_OUT_OF_POOL_MEMORY here, without a round trip (DXVK fills a pool every few
* hundred draws). Pools and layouts the books cannot follow (sets freed one by one, inline uniform
* blocks, mutable or variable-count descriptors) go by the driver's answers: a batch that does not
* fit falls back to what the app asked for, so the app sees the out-of-pool error when it would.
*/
#define DS_BATCH 256
#define DS_TYPES 12 /* VK_DESCRIPTOR_TYPE_SAMPLER..INPUT_ATTACHMENT, then ACCELERATION_STRUCTURE_KHR */
static int ds_type_index(VkDescriptorType t)
{
if ((uint32_t)t <= VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) return (int)t;
if (t == VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR) return 11;
return -1;
}
typedef struct ds_cache {
VkDescriptorPool pool;
VkDescriptorSetLayout layout;
VkDescriptorSet sets[DS_BATCH];
uint32_t n;
uint32_t batch; /* grows from 4 to the pool's max_batch while the pool keeps up */
struct ds_cache *next;
} ds_cache;
static pthread_mutex_t ds_lock = PTHREAD_MUTEX_INITIALIZER;
static ds_cache *ds_head;
/* Pools the app made, with the batch they allow: a pool sized for exactly what the app will
* allocate (DXVK's sampler pool) must not lose capacity to prefetching. */
typedef struct ds_pool {
VkDescriptorPool pool;
uint32_t max_batch;
int books; /* capacity below is kept */
uint32_t max_sets, sets_left;
uint32_t size[DS_TYPES], left[DS_TYPES];
struct ds_pool *next;
} ds_pool;
static ds_pool *ds_pools;
/* Layouts with what one set of them takes; known = 0 when the books cannot follow it. */
typedef struct ds_layout {
VkDescriptorSetLayout layout;
int known;
uint32_t count[DS_TYPES];
struct ds_layout *next;
} ds_layout;
static ds_layout *ds_layouts;
static ds_pool *pool_find(VkDescriptorPool pool)
{
for (ds_pool *p = ds_pools; p; p = p->next)
if (p->pool == pool) return p;
return NULL;
}
static ds_layout *layout_find(VkDescriptorSetLayout layout)
{
for (ds_layout *l = ds_layouts; l; l = l->next)
if (l->layout == layout) return l;
return NULL;
}
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *ci,
const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pLayout)
{
VkResult r = vkb_wire_vkCreateDescriptorSetLayout(device, ci, pAllocator, pLayout);
if (r != VK_SUCCESS) return r;
ds_layout *l = calloc(1, sizeof(*l));
if (!l) return r;
l->layout = *pLayout;
/* Binding flags only matter for variable counts; anything else in the chain is left alone. */
l->known = 1;
for (const VkBaseInStructure *n = ci->pNext; n; n = n->pNext) {
if (n->sType != VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO) {
l->known = 0;
continue;
}
const VkDescriptorSetLayoutBindingFlagsCreateInfo *bf = (const void *)n;
for (uint32_t i = 0; i < bf->bindingCount; i++)
if (bf->pBindingFlags[i] & VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT) l->known = 0;
}
for (uint32_t i = 0; i < ci->bindingCount && l->known; i++) {
int t = ds_type_index(ci->pBindings[i].descriptorType);
if (t < 0) l->known = 0;
else l->count[t] += ci->pBindings[i].descriptorCount;
}
pthread_mutex_lock(&ds_lock);
l->next = ds_layouts;
ds_layouts = l;
pthread_mutex_unlock(&ds_lock);
return r;
}
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout layout,
const VkAllocationCallbacks *pAllocator)
{
if (!layout) return;
pthread_mutex_lock(&ds_lock);
for (ds_layout **pp = &ds_layouts; *pp; pp = &(*pp)->next) {
if ((*pp)->layout == layout) {
ds_layout *l = *pp;
*pp = l->next;
free(l);
break;
}
}
/* Sets cached for it stay allocated in their pools, but a new layout may get its handle. */
for (ds_cache **pp = &ds_head; *pp;) {
if ((*pp)->layout == layout) {
ds_cache *c = *pp;
*pp = c->next;
free(c);
} else {
pp = &(*pp)->next;
}
}
pthread_mutex_unlock(&ds_lock);
vkb_wire_vkDestroyDescriptorSetLayout(device, layout, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *ci,
const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pPool)
{
VkResult r = vkb_wire_vkCreateDescriptorPool(device, ci, pAllocator, pPool);
if (r != VK_SUCCESS) return r;
ds_pool *p = calloc(1, sizeof(*p));
if (!p) return r;
p->pool = *pPool;
p->max_batch = ci->maxSets >= 256 ? ci->maxSets / 8 : 1;
if (p->max_batch > DS_BATCH) p->max_batch = DS_BATCH;
p->books = !ci->pNext && !(ci->flags & VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT);
p->max_sets = p->sets_left = ci->maxSets;
for (uint32_t i = 0; i < ci->poolSizeCount && p->books; i++) {
int t = ds_type_index(ci->pPoolSizes[i].type);
if (t < 0) p->books = 0;
else p->size[t] += ci->pPoolSizes[i].descriptorCount;
}
memcpy(p->left, p->size, sizeof(p->left));
VKB_DBG("descriptor pool: maxSets %u, %u pool sizes, prefetch up to %u%s", ci->maxSets, ci->poolSizeCount,
p->max_batch, p->books ? ", capacity tracked" : "");
pthread_mutex_lock(&ds_lock);
p->next = ds_pools;
ds_pools = p;
pthread_mutex_unlock(&ds_lock);
return r;
}
static ds_cache *ds_find(VkDescriptorPool pool, VkDescriptorSetLayout layout, int create)
{
for (ds_cache *c = ds_head; c; c = c->next)
if (c->pool == pool && c->layout == layout) return c;
if (!create) return NULL;
ds_cache *c = calloc(1, sizeof(*c));
if (!c) return NULL;
c->pool = pool;
c->layout = layout;
c->batch = 4;
c->next = ds_head;
ds_head = c;
return c;
}
/* A reset frees the pool's sets, cached ones included; destruction also forgets the pool. The
* learned batch size survives a reset (pools are reset every frame). */
static void ds_drop_pool(VkDescriptorPool pool, int destroy)
{
pthread_mutex_lock(&ds_lock);
ds_cache **pp = &ds_head;
while (*pp) {
if ((*pp)->pool == pool && destroy) {
ds_cache *c = *pp;
*pp = c->next;
free(c);
} else {
if ((*pp)->pool == pool) (*pp)->n = 0;
pp = &(*pp)->next;
}
}
ds_pool *p = pool_find(pool);
if (p && !destroy) {
p->sets_left = p->max_sets;
memcpy(p->left, p->size, sizeof(p->left));
}
pthread_mutex_unlock(&ds_lock);
}
/* How many sets of layout l still fit in pool p by the books; UINT32_MAX when not kept. */
static uint32_t ds_fits(const ds_pool *p, const ds_layout *l)
{
if (!p->books || !l || !l->known) return UINT32_MAX;
uint32_t n = p->sets_left;
for (int t = 0; t < DS_TYPES; t++)
if (l->count[t] && p->left[t] / l->count[t] < n) n = p->left[t] / l->count[t];
return n;
}
/* Fills the cache for (pool, layout) with `want` sets; returns the driver's result. */
static VkResult ds_refill(VkDevice device, ds_pool *p, const ds_layout *l, ds_cache *c, uint32_t want)
{
VkDescriptorSetLayout layouts[DS_BATCH];
for (uint32_t i = 0; i < want; i++) layouts[i] = c->layout;
VkDescriptorSetAllocateInfo ai = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, c->pool, want, layouts};
VkResult r = vkb_wire_vkAllocateDescriptorSets(device, &ai, c->sets + c->n);
if (r != VK_SUCCESS) return r;
c->n += want;
if (ds_fits(p, l) != UINT32_MAX) {
p->sets_left -= want;
for (int t = 0; t < DS_TYPES; t++) p->left[t] -= want * l->count[t];
}
return r;
}
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. */
if (ai->pNext || getenv("VKBRIDGE_SYNC")) return vkb_wire_vkAllocateDescriptorSets(device, ai, out);
pthread_mutex_lock(&ds_lock);
ds_pool *p = pool_find(ai->descriptorPool);
if (!p || p->max_batch <= 1) {
pthread_mutex_unlock(&ds_lock);
return vkb_wire_vkAllocateDescriptorSets(device, ai, out);
}
VkResult r = VK_SUCCESS;
uint32_t done = 0;
for (; done < ai->descriptorSetCount; done++) {
ds_cache *c = ds_find(ai->descriptorPool, ai->pSetLayouts[done], 1);
if (!c) {
r = VK_ERROR_OUT_OF_HOST_MEMORY;
break;
}
if (c->batch > p->max_batch) c->batch = p->max_batch;
if (!c->n) {
const ds_layout *l = layout_find(c->layout);
uint32_t fits = ds_fits(p, l), want = c->batch < fits ? c->batch : fits;
if (!want) {
r = VK_ERROR_OUT_OF_POOL_MEMORY;
break;
}
r = ds_refill(device, p, l, c, want);
if ((r == VK_ERROR_OUT_OF_POOL_MEMORY || r == VK_ERROR_FRAGMENTED_POOL) && want > 1) {
/* The driver disagrees with the batch (or the books): just what was asked for. */
c->batch = want / 2 > 4 ? want / 2 : 4;
r = ds_refill(device, p, l, c, 1);
} else if (r == VK_SUCCESS && c->batch < p->max_batch && want == c->batch) {
c->batch = c->batch * 2 > p->max_batch ? p->max_batch : c->batch * 2;
}
if (r != VK_SUCCESS) break;
}
out[done] = c->sets[--c->n];
}
if (r != VK_SUCCESS) {
/* None allocated, as the spec has it: what was taken goes back to the cache. */
for (uint32_t i = 0; i < done; i++) {
ds_cache *c = ds_find(ai->descriptorPool, ai->pSetLayouts[i], 0);
if (c && c->n < DS_BATCH) c->sets[c->n++] = out[i];
}
for (uint32_t i = 0; i < ai->descriptorSetCount; i++) out[i] = VK_NULL_HANDLE;
}
pthread_mutex_unlock(&ds_lock);
return r;
}
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetDescriptorPool(VkDevice device, VkDescriptorPool pool, VkDescriptorPoolResetFlags flags)
{
ds_drop_pool(pool, 0);
return vkb_wire_vkResetDescriptorPool(device, pool, flags);
}
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool pool, const VkAllocationCallbacks *pAllocator)
{
if (!pool) return;
ds_drop_pool(pool, 1);
pthread_mutex_lock(&ds_lock);
for (ds_pool **pp = &ds_pools; *pp; pp = &(*pp)->next) {
if ((*pp)->pool == pool) {
ds_pool *p = *pp;
*pp = p->next;
free(p);
break;
}
}
pthread_mutex_unlock(&ds_lock);
vkb_wire_vkDestroyDescriptorPool(device, pool, pAllocator);
}
+1 -1
View File
@@ -370,7 +370,7 @@ VKAPI_ATTR void VKAPI_CALL vkb_ep_vkFreeMemory(VkDevice device, VkDeviceMemory m
vkb_call_begin(&c, VKB_CMD_vkFreeMemory, dev->obj.table);
vkb_enc_u64(&c.e, dev->obj.remote);
vkb_enc_u64(&c.e, (uint64_t)memory);
if (vkb_call_exec(&c)) vkb_call_end(&c);
vkb_call_exec_async(&c);
if (m) vkb_memory_unmap_free(m);
}
+4
View File
@@ -145,6 +145,10 @@ void vkb_call_begin(vkb_call *c, uint32_t cmd, uint32_t table);
/* Sends the request and waits for the reply. 0 = failed (the call is already released). */
int vkb_call_exec(vkb_call *c);
void vkb_call_end(vkb_call *c);
/* Sends without waiting for a reply (void commands without outputs); ordered by vkb_msg_hdr.seq. */
int vkb_call_exec_async(vkb_call *c);
int vkb_async_results(void);
void vkb_stats_count(uint32_t cmd, int async, size_t bytes);
uint32_t vkb_table_of(const void *dispatchable);
int vkb_connected(void);
/* Per-thread transport cleanup for fork children. */
+26
View File
@@ -77,6 +77,8 @@ LOCAL_COMMANDS_PREFIX = ('vkCreateDebugUtilsMessengerEXT', 'vkDestroyDebugUtilsM
# Commands whose client entry point is hand-written (the generated wire stub may still be used).
CLIENT_CUSTOM = {
'vkAllocateDescriptorSets', 'vkResetDescriptorPool', 'vkDestroyDescriptorPool', 'vkCreateDescriptorPool',
'vkCreateDescriptorSetLayout', 'vkDestroyDescriptorSetLayout',
'vkCreateInstance', 'vkDestroyInstance', 'vkEnumerateInstanceExtensionProperties',
'vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceVersion', 'vkGetInstanceProcAddr',
'vkGetDeviceProcAddr', 'vkEnumeratePhysicalDevices', 'vkEnumeratePhysicalDeviceGroups',
@@ -119,6 +121,12 @@ SERVER_CUSTOM = {
'vkFlushMappedMemoryRanges', 'vkInvalidateMappedMemoryRanges', 'vkEndCommandBuffer',
}
# VkResult commands sent without waiting (VK_SUCCESS returned at once; a failure is logged by the
# server). What an app does next with their objects is ordered after them by the protocol.
ASYNC_RESULT = {'vkQueueSubmit', 'vkQueueSubmit2', 'vkResetDescriptorPool', 'vkResetCommandPool',
'vkResetCommandBuffer', 'vkResetFences', 'vkResetEvent', 'vkSetEvent', 'vkFreeDescriptorSets',
'vkBindBufferMemory', 'vkBindBufferMemory2', 'vkBindImageMemory', 'vkBindImageMemory2'}
# File descriptors: (struct, member) and (command, param).
FD_MEMBERS = {('VkImportMemoryFdInfoKHR', 'fd'), ('VkImportSemaphoreFdInfoKHR', 'fd'),
('VkImportFenceFdInfoKHR', 'fd')}
@@ -871,6 +879,7 @@ for i, c in enumerate(cmd_ids):
hw(f'VKB_CMD_COUNT = {len(cmd_ids)}')
hw('};')
hw('extern const char *const vkb_cmd_names[VKB_CMD_COUNT];')
hw('extern const unsigned char vkb_cmd_result[VKB_CMD_COUNT]; /* returns VkResult (first in the reply) */')
hw()
hw('/* Every bridged command, by its canonical name (aliases resolve to these). */')
hw('typedef struct vkb_dispatch {')
@@ -907,6 +916,10 @@ names('const char *const vkb_cmd_names[VKB_CMD_COUNT] = {')
for c in cmd_ids:
names(f'"{c}",')
names('};')
names('const unsigned char vkb_cmd_result[VKB_CMD_COUNT] = {')
for c in cmd_ids:
names(f'{1 if c in reg.commands and reg.commands[c]["ret"] == "VkResult" else 0},')
names('};')
names('const vkb_ext_desc vkb_exts[VKB_EXT_COUNT] = {')
for e in bridged_exts:
names(f'{{"{e}", {1 if ext_info[e][0] == "device" else 0}, {1 if e in CLIENT_EXTENSIONS else 0}}},')
@@ -1085,6 +1098,19 @@ for c in wire_cmds:
cw(f'vkb_cmd_record_end({first});')
cw('}')
cw()
elif ret == 'void' and not outs and not any((c, p.name) in FD_PARAMS for p in params):
# Nothing comes back: sent without waiting (ordered by the protocol's sequence numbers).
cw('vkb_call_exec_async(&call_);')
cw('}')
cw()
elif c in ASYNC_RESULT and not outs:
cw('if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;')
cw('if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;')
cw('VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);')
cw('vkb_call_end(&call_);')
cw('return r_;')
cw('}')
cw()
else:
cw('if (!vkb_call_exec(&call_)) {')
if ret == 'VkResult':
@@ -292,6 +292,7 @@ VkResult vkb_wire_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* p
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
@@ -309,6 +310,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCopyImageToMemory(VkDevice device, const
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
@@ -322,6 +325,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateXlibSurfaceKHR(VkInstance instance
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
@@ -403,6 +408,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueSubmit2(VkQueue queue, uint32_t sub
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueWaitIdle(VkQueue queue);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data);
+1
View File
@@ -307,6 +307,7 @@ enum vkb_cmd_id {
VKB_CMD_COUNT = 290
};
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) */
/* Every bridged command, by its canonical name (aliases resolve to these). */
typedef struct vkb_dispatch {
+69 -301
View File
@@ -143,13 +143,9 @@ VkResult vkb_wire_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceM
vkb_enc_bytes(e, &buffer, sizeof(buffer));
vkb_enc_bytes(e, &memory, sizeof(memory));
vkb_enc_bytes(e, &memoryOffset, sizeof(memoryOffset));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -168,13 +164,9 @@ VkResult vkb_wire_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, c
} else {
vkb_enc_u8(e, 0);
}
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -188,13 +180,9 @@ VkResult vkb_wire_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemo
vkb_enc_bytes(e, &image, sizeof(image));
vkb_enc_bytes(e, &memory, sizeof(memory));
vkb_enc_bytes(e, &memoryOffset, sizeof(memoryOffset));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -213,13 +201,9 @@ VkResult vkb_wire_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, co
} else {
vkb_enc_u8(e, 0);
}
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -2950,12 +2934,7 @@ void vkb_wire_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocati
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &buffer, sizeof(buffer));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
@@ -2966,12 +2945,7 @@ void vkb_wire_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, cons
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &bufferView, sizeof(bufferView));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
@@ -2982,12 +2956,7 @@ void vkb_wire_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, c
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &commandPool, sizeof(commandPool));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
@@ -2998,12 +2967,7 @@ void vkb_wire_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descript
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &descriptorPool, sizeof(descriptorPool));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
@@ -3014,12 +2978,7 @@ void vkb_wire_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayou
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &descriptorSetLayout, sizeof(descriptorSetLayout));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
@@ -3030,12 +2989,7 @@ void vkb_wire_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpd
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &descriptorUpdateTemplate, sizeof(descriptorUpdateTemplate));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
@@ -3045,12 +2999,7 @@ void vkb_wire_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAll
vkb_enc *e = &call_.e;
vkb_enc_u64(e, vkb_remote((const void *)device));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
@@ -3061,12 +3010,7 @@ void vkb_wire_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationC
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &event, sizeof(event));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
@@ -3077,12 +3021,7 @@ void vkb_wire_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationC
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &fence, sizeof(fence));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
@@ -3093,12 +3032,7 @@ void vkb_wire_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, c
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &framebuffer, sizeof(framebuffer));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
@@ -3109,12 +3043,7 @@ void vkb_wire_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationC
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &image, sizeof(image));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
@@ -3125,12 +3054,7 @@ void vkb_wire_vkDestroyImageView(VkDevice device, VkImageView imageView, const V
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &imageView, sizeof(imageView));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
@@ -3140,12 +3064,7 @@ void vkb_wire_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks
vkb_enc *e = &call_.e;
vkb_enc_u64(e, vkb_remote((const void *)instance));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
@@ -3156,12 +3075,7 @@ void vkb_wire_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAl
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &pipeline, sizeof(pipeline));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
@@ -3172,12 +3086,7 @@ void vkb_wire_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCa
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &pipelineCache, sizeof(pipelineCache));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
@@ -3188,12 +3097,7 @@ void vkb_wire_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipeline
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &pipelineLayout, sizeof(pipelineLayout));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
@@ -3204,12 +3108,7 @@ void vkb_wire_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const V
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &queryPool, sizeof(queryPool));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
@@ -3220,12 +3119,7 @@ void vkb_wire_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, cons
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &renderPass, sizeof(renderPass));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
@@ -3236,12 +3130,7 @@ void vkb_wire_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAlloc
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &sampler, sizeof(sampler));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
@@ -3252,12 +3141,7 @@ void vkb_wire_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrCon
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &ycbcrConversion, sizeof(ycbcrConversion));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
@@ -3268,12 +3152,7 @@ void vkb_wire_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const V
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &semaphore, sizeof(semaphore));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
@@ -3284,12 +3163,7 @@ void vkb_wire_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &shaderModule, sizeof(shaderModule));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator)
@@ -3300,12 +3174,7 @@ void vkb_wire_vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAl
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &tensor, sizeof(tensor));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator)
@@ -3316,12 +3185,7 @@ void vkb_wire_vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &tensorView, sizeof(tensorView));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
VkResult vkb_wire_vkDeviceWaitIdle(VkDevice device)
@@ -3653,12 +3517,7 @@ void vkb_wire_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, u
} else {
vkb_enc_u8(e, 0);
}
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
VkResult vkb_wire_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
@@ -3676,13 +3535,9 @@ VkResult vkb_wire_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descrip
} else {
vkb_enc_u8(e, 0);
}
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -3695,12 +3550,7 @@ void vkb_wire_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAlloc
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &memory, sizeof(memory));
(void)pAllocator;
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
VkDeviceAddress vkb_wire_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
@@ -5408,13 +5258,9 @@ VkResult vkb_wire_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSub
vkb_enc_u8(e, 0);
}
vkb_enc_bytes(e, &fence, sizeof(fence));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5434,13 +5280,9 @@ VkResult vkb_wire_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSu
vkb_enc_u8(e, 0);
}
vkb_enc_bytes(e, &fence, sizeof(fence));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5469,13 +5311,9 @@ VkResult vkb_wire_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandB
vkb_enc *e = &call_.e;
vkb_enc_u64(e, vkb_remote((const void *)commandBuffer));
vkb_enc_bytes(e, &flags, sizeof(flags));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5488,13 +5326,9 @@ VkResult vkb_wire_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &commandPool, sizeof(commandPool));
vkb_enc_bytes(e, &flags, sizeof(flags));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5507,13 +5341,9 @@ VkResult vkb_wire_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descri
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &descriptorPool, sizeof(descriptorPool));
vkb_enc_bytes(e, &flags, sizeof(flags));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5525,13 +5355,9 @@ VkResult vkb_wire_vkResetEvent(VkDevice device, VkEvent event)
vkb_enc *e = &call_.e;
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &event, sizeof(event));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5550,13 +5376,9 @@ VkResult vkb_wire_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFe
} else {
vkb_enc_u8(e, 0);
}
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5570,12 +5392,7 @@ void vkb_wire_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t
vkb_enc_bytes(e, &queryPool, sizeof(queryPool));
vkb_enc_bytes(e, &firstQuery, sizeof(firstQuery));
vkb_enc_bytes(e, &queryCount, sizeof(queryCount));
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
@@ -5586,12 +5403,7 @@ void vkb_wire_vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memor
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &memory, sizeof(memory));
vkb_enc_bytes(e, &priority, sizeof(priority));
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
VkResult vkb_wire_vkSetEvent(VkDevice device, VkEvent event)
@@ -5601,13 +5413,9 @@ VkResult vkb_wire_vkSetEvent(VkDevice device, VkEvent event)
vkb_enc *e = &call_.e;
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &event, sizeof(event));
if (!vkb_call_exec(&call_)) {
return VK_ERROR_DEVICE_LOST;
}
vkb_dec *d = &call_.d;
(void)d;
VkResult r_;
vkb_dec_bytes(d, &r_, sizeof(r_));
if (vkb_async_results()) return vkb_call_exec_async(&call_) ? VK_SUCCESS : VK_ERROR_DEVICE_LOST;
if (!vkb_call_exec(&call_)) return VK_ERROR_DEVICE_LOST;
VkResult r_ = (VkResult)vkb_dec_u32(&call_.d);
vkb_call_end(&call_);
return r_;
}
@@ -5644,12 +5452,7 @@ void vkb_wire_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCo
vkb_enc_u64(e, vkb_remote((const void *)device));
vkb_enc_bytes(e, &commandPool, sizeof(commandPool));
vkb_enc_bytes(e, &flags, sizeof(flags));
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
void vkb_wire_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
@@ -5674,12 +5477,7 @@ void vkb_wire_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCo
} else {
vkb_enc_u8(e, 0);
}
if (!vkb_call_exec(&call_)) {
return;
}
vkb_dec *d = &call_.d;
(void)d;
vkb_call_end(&call_);
vkb_call_exec_async(&call_);
}
VkResult vkb_wire_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
@@ -5735,11 +5533,6 @@ VkResult vkb_wire_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* p
}
/* Default entry points. */
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
{
return vkb_wire_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
}
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos)
{
return vkb_wire_vkBindTensorMemoryARM(device, bindInfoCount, pBindInfos);
@@ -6420,16 +6213,6 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateComputePipelines(VkDevice d
return vkb_wire_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
return vkb_wire_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
}
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
return vkb_wire_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
}
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
{
return vkb_wire_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
@@ -6515,16 +6298,6 @@ static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyBufferView(VkDevice device, Vk
vkb_wire_vkDestroyBufferView(device, bufferView, pAllocator);
}
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
{
vkb_wire_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
}
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
{
vkb_wire_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
static VKAPI_ATTR void VKAPI_CALL vkb_ep_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
{
vkb_wire_vkDestroyEvent(device, event, pAllocator);
@@ -6760,11 +6533,6 @@ static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkQueueBindSparse(VkQueue queue, ui
return vkb_wire_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
}
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
{
return vkb_wire_vkResetDescriptorPool(device, descriptorPool, flags);
}
static VKAPI_ATTR VkResult VKAPI_CALL vkb_ep_vkResetEvent(VkDevice device, VkEvent event)
{
return vkb_wire_vkResetEvent(device, event);
+292
View File
@@ -15937,6 +15937,298 @@ const char *const vkb_cmd_names[VKB_CMD_COUNT] = {
"vkWaitForFences",
"vkWaitSemaphores",
};
const unsigned char vkb_cmd_result[VKB_CMD_COUNT] = {
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
1,
1,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
};
const vkb_ext_desc vkb_exts[VKB_EXT_COUNT] = {
{"VK_KHR_surface", 0, 1},
{"VK_KHR_swapchain", 1, 1},
+6 -1
View File
@@ -100,8 +100,13 @@ typedef struct vkb_msg_hdr {
uint32_t table; /* request: server dispatch table id */
uint32_t nfds;
uint32_t flags;
/* Ordering of asynchronous requests across a process's connections: an async request has
* seq > 0; every request carries barrier = the highest async seq its process had issued
* before it, and is not executed until all of those have been. */
uint64_t seq;
uint64_t barrier;
} vkb_msg_hdr;
#define VKB_MAGIC 0x31424b56u /* "VKB1" */
#define VKB_MAGIC 0x32424b56u /* "VKB2" */
#define VKB_F_NOREPLY 1u
/* Reply status codes (vkb_msg_hdr.cmd in replies). */
+116
View File
@@ -0,0 +1,116 @@
/* SPDX-License-Identifier: GPL-3.0-or-later
*
* d3d11_bench.exe [draws] [frames]: a game-like D3D11 frame - many small draws, each with a
* Map(WRITE_DISCARD) constant buffer update and its own texture/sampler binding - rendered
* offscreen and flushed every frame (with a readback every 30th, so the GPU cannot fall behind).
* Prints milliseconds per frame: the bridge's overhead shows as the difference to native.
*/
#define COBJMACROS
#include <windows.h>
#include <d3d11.h>
#include <d3dcompiler.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv)
{
int draws = argc > 1 ? atoi(argv[1]) : 1000;
int frames = argc > 2 ? atoi(argv[2]) : 300;
ID3D11Device *dev;
ID3D11DeviceContext *ctx;
D3D_FEATURE_LEVEL fl = D3D_FEATURE_LEVEL_11_0;
if (FAILED(D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &fl, 1, D3D11_SDK_VERSION, &dev, NULL, &ctx))) {
printf("no device\n");
return 1;
}
const char *vs = "cbuffer C : register(b0) { float4 pos; float4 col; };"
"struct O { float4 p : SV_Position; float4 c : COLOR; float2 uv : TEXCOORD; };"
"O main(uint id : SV_VertexID) { O o; float2 t = float2((id << 1) & 2, id & 2) * 0.05;"
"o.p = float4(pos.xy + t, 0, 1); o.c = col; o.uv = t * 20; return o; }";
const char *ps = "Texture2D t : register(t0); SamplerState s : register(s0);"
"float4 main(float4 p : SV_Position, float4 c : COLOR, float2 uv : TEXCOORD) : SV_Target { return c * t.Sample(s, uv); }";
ID3DBlob *vb, *pb;
D3DCompile(vs, strlen(vs), NULL, NULL, NULL, "main", "vs_5_0", 0, 0, &vb, NULL);
D3DCompile(ps, strlen(ps), NULL, NULL, NULL, "main", "ps_5_0", 0, 0, &pb, NULL);
ID3D11VertexShader *vsh;
ID3D11PixelShader *psh;
ID3D11Device_CreateVertexShader(dev, ID3D10Blob_GetBufferPointer(vb), ID3D10Blob_GetBufferSize(vb), NULL, &vsh);
ID3D11Device_CreatePixelShader(dev, ID3D10Blob_GetBufferPointer(pb), ID3D10Blob_GetBufferSize(pb), NULL, &psh);
D3D11_BUFFER_DESC bd = {32, D3D11_USAGE_DYNAMIC, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE, 0, 0};
ID3D11Buffer *cb;
ID3D11Device_CreateBuffer(dev, &bd, NULL, &cb);
/* 8 small BC1 textures (block-compressed like a game's) */
ID3D11ShaderResourceView *srv[8];
uint8_t blocks[16 * 8];
for (int i = 0; i < (int)sizeof(blocks); i++) blocks[i] = (uint8_t)(i * 37 + 11);
for (int i = 0; i < 8; i++) {
D3D11_TEXTURE2D_DESC td = {16, 16, 1, 1, DXGI_FORMAT_BC1_UNORM, {1, 0}, D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0};
D3D11_SUBRESOURCE_DATA init = {blocks, 32, 0};
ID3D11Texture2D *t;
ID3D11Device_CreateTexture2D(dev, &td, &init, &t);
ID3D11Device_CreateShaderResourceView(dev, (ID3D11Resource *)t, NULL, &srv[i]);
}
D3D11_SAMPLER_DESC sd = {D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_TEXTURE_ADDRESS_WRAP, D3D11_TEXTURE_ADDRESS_WRAP, D3D11_TEXTURE_ADDRESS_WRAP,
0, 1, D3D11_COMPARISON_NEVER, {0}, 0, D3D11_FLOAT32_MAX};
ID3D11SamplerState *smp;
ID3D11Device_CreateSamplerState(dev, &sd, &smp);
D3D11_TEXTURE2D_DESC rd = {1280, 720, 1, 1, DXGI_FORMAT_R8G8B8A8_UNORM, {1, 0}, D3D11_USAGE_DEFAULT, D3D11_BIND_RENDER_TARGET, 0, 0};
ID3D11Texture2D *rt, *st;
ID3D11Device_CreateTexture2D(dev, &rd, NULL, &rt);
rd.Usage = D3D11_USAGE_STAGING;
rd.BindFlags = 0;
rd.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
rd.Width = rd.Height = 16;
ID3D11Device_CreateTexture2D(dev, &rd, NULL, &st);
ID3D11RenderTargetView *rtv;
ID3D11Device_CreateRenderTargetView(dev, (ID3D11Resource *)rt, NULL, &rtv);
D3D11_VIEWPORT vp = {0, 0, 1280, 720, 0, 1};
LARGE_INTEGER f, t0, t1;
QueryPerformanceFrequency(&f);
double total = 0, worst = 0;
for (int fr = 0; fr < frames + 10; fr++) {
QueryPerformanceCounter(&t0);
float clear[4] = {0.1f, 0.1f, 0.1f, 1};
ID3D11DeviceContext_OMSetRenderTargets(ctx, 1, &rtv, NULL);
ID3D11DeviceContext_RSSetViewports(ctx, 1, &vp);
ID3D11DeviceContext_ClearRenderTargetView(ctx, rtv, clear);
ID3D11DeviceContext_IASetPrimitiveTopology(ctx, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ID3D11DeviceContext_VSSetShader(ctx, vsh, NULL, 0);
ID3D11DeviceContext_PSSetShader(ctx, psh, NULL, 0);
ID3D11DeviceContext_VSSetConstantBuffers(ctx, 0, 1, &cb);
ID3D11DeviceContext_PSSetSamplers(ctx, 0, 1, &smp);
for (int d = 0; d < draws; d++) {
D3D11_MAPPED_SUBRESOURCE m;
ID3D11DeviceContext_Map(ctx, (ID3D11Resource *)cb, 0, D3D11_MAP_WRITE_DISCARD, 0, &m);
float *p = m.pData;
p[0] = -1 + 2.0f * (d % 40) / 40;
p[1] = -1 + 2.0f * ((d / 40) % 40) / 40;
p[4] = (d & 1) ? 1.0f : 0.5f;
p[5] = (d & 2) ? 1.0f : 0.5f;
p[6] = (d & 4) ? 1.0f : 0.5f;
p[7] = 1;
ID3D11DeviceContext_Unmap(ctx, (ID3D11Resource *)cb, 0);
ID3D11DeviceContext_PSSetShaderResources(ctx, 0, 1, &srv[d & 7]);
ID3D11DeviceContext_Draw(ctx, 3, 0);
}
if (fr % 30 == 29) {
D3D11_BOX box = {0, 0, 0, 16, 16, 1};
ID3D11DeviceContext_CopySubresourceRegion(ctx, (ID3D11Resource *)st, 0, 0, 0, 0, (ID3D11Resource *)rt, 0, &box);
D3D11_MAPPED_SUBRESOURCE m;
ID3D11DeviceContext_Map(ctx, (ID3D11Resource *)st, 0, D3D11_MAP_READ, 0, &m);
ID3D11DeviceContext_Unmap(ctx, (ID3D11Resource *)st, 0);
} else {
ID3D11DeviceContext_Flush(ctx);
}
QueryPerformanceCounter(&t1);
double ms = (double)(t1.QuadPart - t0.QuadPart) * 1000.0 / (double)f.QuadPart;
if (fr >= 10) {
total += ms;
if (ms > worst) worst = ms;
}
}
printf("%d draws/frame: %.2f ms/frame average (%.0f fps), worst %.2f ms\n", draws, total / frames, 1000.0 * frames / total, worst);
return 0;
}