mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
Mali bridge (#517, by ASEbrahim) on the non-Adreno test branch
Squash of Droid-Deck/DroidDeck#517 (ASEbrahim/DroidDeck mali-bridge @ 6b823341): the Vulkan
bridge (tools/vkbridge) that runs the guest's Vulkan on the phone's own driver, with BC1-BC7,
clip/cull distance, vertex-divisor and depth-clip emulation and dma-heap memory sharing for Mali.
All of the bridge is ASEbrahim's work; squashed only to carry it on this test branch.
Combined with #570 on this branch, a device draws through exactly one path:
- Adreno: Turnip, unchanged (checked first; the bridge setting is ignored there).
- PowerVR / Xclipse with the system HAL and a render node: the system-Vulkan path (#570).
- Anything else with the Setup toggle on (Mali): the bridge.
This commit is contained in:
1 parent
cf06f89c11
commit
ee0fb08268
125 files changed
+119982
-12
No files matched your search
@@ -149,6 +149,9 @@ android {
|
||||
release {
|
||||
minifyEnabled false
|
||||
signingConfig signingConfigs.testkey
|
||||
// Mali bridge development fork: debuggable so `adb shell run-as` reaches the session
|
||||
// logs and VkBridgeNative's development override (-Pdroiddeck.notDebuggable to drop).
|
||||
debuggable !project.hasProperty('droiddeck.notDebuggable')
|
||||
}
|
||||
}
|
||||
|
||||
@@ -276,6 +279,24 @@ def buildRustStores = tasks.register('buildRustStores', Exec) {
|
||||
if (!skipRust) android.sourceSets.main.jniLibs.srcDir(rustJniLibsDir)
|
||||
tasks.named('preBuild').configure { dependsOn(buildRustStores) }
|
||||
|
||||
// The Mali bridge's server (tools/vkbridge, app/src/main/cpp/vkbridge) is a program, not a library:
|
||||
// it runs beside the session as the app's child, so a driver crash ends that process and not the
|
||||
// app. AGP's CMake integration packages only shared libraries, so the NDK's clang builds it here
|
||||
// into one more jniLibs source, named libvkbridge_server.so so Android extracts it (the native
|
||||
// library directory is the one place the app may exec from).
|
||||
def vkbridgeJniLibsDir = layout.buildDirectory.dir('vkbridgeJniLibs')
|
||||
def buildVkBridgeServer = tasks.register('buildVkBridgeServer', Exec) {
|
||||
description = 'Builds the Vulkan bridge server (libvkbridge_server.so) with the NDK.'
|
||||
inputs.dir(rootProject.file('tools/vkbridge/common'))
|
||||
inputs.dir(layout.projectDirectory.dir('src/main/cpp/vkbridge'))
|
||||
inputs.file(rootProject.file('tools/vkbridge/build-server-android.sh'))
|
||||
outputs.dir(vkbridgeJniLibsDir)
|
||||
commandLine 'bash', rootProject.file('tools/vkbridge/build-server-android.sh').absolutePath,
|
||||
android.ndkDirectory.absolutePath, vkbridgeJniLibsDir.get().asFile.absolutePath
|
||||
}
|
||||
android.sourceSets.main.jniLibs.srcDir(vkbridgeJniLibsDir)
|
||||
tasks.named('preBuild').configure { dependsOn(buildVkBridgeServer) }
|
||||
|
||||
dependencies {
|
||||
// The runtime tarball is a zstd-compressed tar.
|
||||
implementation 'com.github.luben:zstd-jni:1.5.2-3@aar'
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,535 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Connections: one thread per client thread, requests executed in order, replies sent back.
|
||||
* A command buffer's recorded commands arrive in one message at vkEndCommandBuffer and are
|
||||
* replayed here.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/socket.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static pthread_mutex_t tables_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static vkb_srv_table *tables[VKB_MAX_TABLES];
|
||||
static uint32_t next_table_id = 1;
|
||||
|
||||
static pthread_mutex_t procs_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static vkb_srv_proc *procs;
|
||||
|
||||
static __thread vkb_srv_table *tls_table;
|
||||
__thread const char *vkb_srv_current_cmd;
|
||||
|
||||
vkb_srv_table *vkb_srv_current_table(void) { return tls_table; }
|
||||
void vkb_srv_set_current_table(vkb_srv_table *t) { tls_table = t; }
|
||||
|
||||
/* Server side of the generated encoders' helpers: handles are already the server's values. */
|
||||
uint64_t vkb_remote(const void *h) { return (uint64_t)(uintptr_t)h; }
|
||||
int vkb_cb_begin_is_secondary(const VkCommandBufferBeginInfo *s) { (void)s; return 1; }
|
||||
|
||||
uint32_t vkb_table_register(vkb_srv_table *t)
|
||||
{
|
||||
pthread_mutex_lock(&tables_lock);
|
||||
uint32_t id = 0;
|
||||
for (uint32_t tries = 0; tries < VKB_MAX_TABLES; tries++) {
|
||||
uint32_t cand = next_table_id++;
|
||||
if (next_table_id >= VKB_MAX_TABLES) next_table_id = 1;
|
||||
if (!tables[cand]) {
|
||||
id = cand;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (id) {
|
||||
t->id = id;
|
||||
tables[id] = t;
|
||||
}
|
||||
pthread_mutex_unlock(&tables_lock);
|
||||
return id;
|
||||
}
|
||||
|
||||
void vkb_table_unregister(vkb_srv_table *t)
|
||||
{
|
||||
pthread_mutex_lock(&tables_lock);
|
||||
if (t->id && t->id < VKB_MAX_TABLES && tables[t->id] == t) tables[t->id] = NULL;
|
||||
pthread_mutex_unlock(&tables_lock);
|
||||
}
|
||||
|
||||
vkb_srv_table *vkb_table_get(uint32_t id)
|
||||
{
|
||||
if (!id || id >= VKB_MAX_TABLES) return NULL;
|
||||
pthread_mutex_lock(&tables_lock);
|
||||
vkb_srv_table *t = tables[id];
|
||||
pthread_mutex_unlock(&tables_lock);
|
||||
return t;
|
||||
}
|
||||
|
||||
void vkb_srv_reply_status(vkb_srv_call *c, uint32_t status)
|
||||
{
|
||||
c->status = status;
|
||||
}
|
||||
|
||||
void vkb_srv_bad_message(vkb_srv_call *c)
|
||||
{
|
||||
VKB_ERR("malformed request");
|
||||
c->status = VKB_ST_BAD_MESSAGE;
|
||||
}
|
||||
|
||||
void vkb_srv_missing(vkb_srv_call *c, const char *name)
|
||||
{
|
||||
VKB_ERR("the driver has no %s", name);
|
||||
c->status = VKB_ST_MISSING;
|
||||
}
|
||||
|
||||
void vkb_srv_close_after_send(vkb_srv_call *c, int fd)
|
||||
{
|
||||
if (c->nclose < VKB_MAX_FDS) c->close_after[c->nclose++] = fd;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ process cleanup */
|
||||
|
||||
void vkb_proc_cleanup(vkb_srv_proc *p)
|
||||
{
|
||||
/* Devices first, then their instances. */
|
||||
for (int pass = 0; pass < 2; pass++) {
|
||||
for (uint32_t i = 1; i < VKB_MAX_TABLES; i++) {
|
||||
pthread_mutex_lock(&tables_lock);
|
||||
vkb_srv_table *t = tables[i];
|
||||
int mine = t && t->proc == p && t->is_device == (pass == 0);
|
||||
if (mine) tables[i] = NULL;
|
||||
pthread_mutex_unlock(&tables_lock);
|
||||
if (!mine) continue;
|
||||
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_spvfix_device_destroy(t);
|
||||
vkb_dsmap_device_destroy(t);
|
||||
vkb_pcache_device_destroy(t);
|
||||
vkb_emu_device_destroy(t);
|
||||
vkb_mem_free_all(t);
|
||||
t->real.vkDestroyDevice(t->device, NULL);
|
||||
} else {
|
||||
VKB_INFO("process %d exited without destroying instance %u; cleaning up", p->pid, t->id);
|
||||
t->real.vkDestroyInstance(t->instance, NULL);
|
||||
}
|
||||
pthread_mutex_destroy(&t->lock);
|
||||
free(t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static vkb_srv_proc *proc_join(uint64_t token, int pid)
|
||||
{
|
||||
pthread_mutex_lock(&procs_lock);
|
||||
vkb_srv_proc *p = procs;
|
||||
while (p && p->token != token) p = p->next;
|
||||
if (!p) {
|
||||
p = calloc(1, sizeof(*p));
|
||||
p->token = token;
|
||||
p->pid = pid;
|
||||
pthread_mutex_init(&p->olock, NULL);
|
||||
pthread_cond_init(&p->ocond, NULL);
|
||||
p->next = procs;
|
||||
procs = p;
|
||||
VKB_INFO("client process %d connected", pid);
|
||||
}
|
||||
p->conns++;
|
||||
pthread_mutex_unlock(&procs_lock);
|
||||
return p;
|
||||
}
|
||||
|
||||
static void proc_leave(vkb_srv_proc *p)
|
||||
{
|
||||
pthread_mutex_lock(&procs_lock);
|
||||
int last = --p->conns == 0;
|
||||
if (last) {
|
||||
vkb_srv_proc **pp = &procs;
|
||||
while (*pp && *pp != p) pp = &(*pp)->next;
|
||||
if (*pp) *pp = p->next;
|
||||
}
|
||||
pthread_mutex_unlock(&procs_lock);
|
||||
if (last) {
|
||||
vkb_proc_cleanup(p);
|
||||
VKB_INFO("client process %d gone", p->pid);
|
||||
pthread_mutex_destroy(&p->olock);
|
||||
pthread_cond_destroy(&p->ocond);
|
||||
free(p);
|
||||
} else {
|
||||
pthread_mutex_lock(&p->olock);
|
||||
p->conn_closed = 1;
|
||||
pthread_cond_broadcast(&p->ocond);
|
||||
pthread_mutex_unlock(&p->olock);
|
||||
}
|
||||
}
|
||||
|
||||
/* Waits until every async request of the process up to `barrier` has run. */
|
||||
static void order_wait(vkb_srv_proc *p, uint64_t barrier)
|
||||
{
|
||||
if (!p || !barrier) return;
|
||||
pthread_mutex_lock(&p->olock);
|
||||
int waited = 0;
|
||||
while (p->watermark < barrier) {
|
||||
struct timespec ts;
|
||||
clock_gettime(CLOCK_REALTIME, &ts);
|
||||
ts.tv_sec += 1;
|
||||
if (pthread_cond_timedwait(&p->ocond, &p->olock, &ts) != 0 && ++waited >= 3 && p->conn_closed) {
|
||||
/* A connection of this process is gone with requests it never sent: go on. */
|
||||
VKB_WARN("process %d: async request %llu never arrived; continuing", p->pid, (unsigned long long)(p->watermark + 1));
|
||||
p->watermark = barrier;
|
||||
memset(p->done, 0, sizeof(p->done));
|
||||
break;
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&p->olock);
|
||||
}
|
||||
|
||||
static void order_done(vkb_srv_proc *p, uint64_t seq)
|
||||
{
|
||||
if (!p || !seq) return;
|
||||
pthread_mutex_lock(&p->olock);
|
||||
if (seq > p->watermark) {
|
||||
p->done[seq % VKB_SEQ_RING] = 1;
|
||||
while (p->done[(p->watermark + 1) % VKB_SEQ_RING]) {
|
||||
p->done[(p->watermark + 1) % VKB_SEQ_RING] = 0;
|
||||
p->watermark++;
|
||||
}
|
||||
pthread_cond_broadcast(&p->ocond);
|
||||
}
|
||||
pthread_mutex_unlock(&p->olock);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ command buffer replay */
|
||||
|
||||
static int is_stream_cmd(uint32_t id)
|
||||
{
|
||||
const char *n = vkb_cmd_names[id];
|
||||
return !strncmp(n, "vkCmd", 5) || id == VKB_CMD_vkBeginCommandBuffer || id == VKB_CMD_vkbPushDescRaw;
|
||||
}
|
||||
|
||||
void vkb_sv_vkEndCommandBuffer(vkb_srv_call *c)
|
||||
{
|
||||
VkCommandBuffer cb = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
size_t len = 0;
|
||||
const uint8_t *s = vkb_dec_blob(&c->d, &len);
|
||||
if (c->d.err) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
VkResult begin_r = VK_SUCCESS;
|
||||
size_t pos = 0;
|
||||
vkb_enc scratch;
|
||||
vkb_enc_init(&scratch);
|
||||
uint32_t ncmds = 0;
|
||||
while (s && pos + 8 <= len) {
|
||||
uint32_t id, n;
|
||||
memcpy(&id, s + pos, 4);
|
||||
memcpy(&n, s + pos + 4, 4);
|
||||
pos += 8;
|
||||
if (id >= VKB_CMD_COUNT || !is_stream_cmd(id) || n > len - pos) {
|
||||
VKB_ERR("command stream: bad entry (id %u, %u bytes) after %u commands", id, n, ncmds);
|
||||
c->status = VKB_ST_BAD_MESSAGE;
|
||||
vkb_enc_free(&scratch);
|
||||
return;
|
||||
}
|
||||
vkb_srv_call sub;
|
||||
memset(&sub, 0, sizeof(sub));
|
||||
vkb_dec_init(&sub.d, s + pos, n, c->d.arena, NULL, 0);
|
||||
sub.r = scratch;
|
||||
vkb_enc_reset(&sub.r);
|
||||
sub.dt = c->dt;
|
||||
sub.table = c->table;
|
||||
sub.conn = c->conn;
|
||||
sub.in_stream = 1;
|
||||
vkb_srv_current_cmd = vkb_cmd_names[id];
|
||||
vkb_srv_handlers[id](&sub);
|
||||
vkb_srv_current_cmd = vkb_cmd_names[VKB_CMD_vkEndCommandBuffer];
|
||||
scratch = sub.r;
|
||||
if (sub.status != VKB_ST_OK) {
|
||||
VKB_ERR("command stream: %s failed (status %u)", vkb_cmd_names[id], sub.status);
|
||||
}
|
||||
if (id == VKB_CMD_vkBeginCommandBuffer && scratch.len >= 4) memcpy(&begin_r, scratch.buf, 4);
|
||||
pos += (n + 7) & ~(size_t)7;
|
||||
ncmds++;
|
||||
}
|
||||
vkb_enc_free(&scratch);
|
||||
VkResult r = c->dt->vkEndCommandBuffer(cb);
|
||||
if (begin_r != VK_SUCCESS) r = begin_r;
|
||||
if (vkb_verbose) VKB_DBG("command buffer %p: %u commands, %zu bytes -> %d", (void *)cb, ncmds, len, r);
|
||||
vkb_enc_u32(&c->r, (uint32_t)r);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ hello */
|
||||
|
||||
void vkb_sv_vkbHello(vkb_srv_call *c)
|
||||
{
|
||||
uint64_t hash = vkb_dec_u64(&c->d);
|
||||
uint64_t token = vkb_dec_u64(&c->d);
|
||||
uint32_t pid = vkb_dec_u32(&c->d);
|
||||
const char *comm = vkb_dec_str(&c->d);
|
||||
if (c->d.err) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
vkb_enc_u64(&c->r, VKB_PROTOCOL_HASH);
|
||||
if (hash != VKB_PROTOCOL_HASH) {
|
||||
VKB_ERR("client %d (%s) speaks protocol %016llx, this server %016llx: refusing", pid,
|
||||
comm ? comm : "?", (unsigned long long)hash, (unsigned long long)VKB_PROTOCOL_HASH);
|
||||
vkb_enc_u32(&c->r, 0);
|
||||
return;
|
||||
}
|
||||
if (!c->conn->proc) {
|
||||
c->conn->proc = proc_join(token, (int)pid);
|
||||
if (c->conn->proc->conns == 1) VKB_INFO("process %u is %s", pid, comm ? comm : "?");
|
||||
}
|
||||
vkb_enc_u32(&c->r, 1);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ statistics */
|
||||
|
||||
/* VKBRIDGE_STATS=<seconds> on the server: time spent per command, waiting for order, idle. */
|
||||
static uint64_t st_ns[VKB_CMD_COUNT], st_n[VKB_CMD_COUNT], st_wait_ns, st_last;
|
||||
static int st_period = -1;
|
||||
|
||||
static uint64_t mono_ns(void)
|
||||
{
|
||||
struct timespec ts;
|
||||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
return (uint64_t)ts.tv_sec * 1000000000ull + (uint64_t)ts.tv_nsec;
|
||||
}
|
||||
|
||||
static void stats_add(uint32_t cmd, uint64_t ns, uint64_t wait_ns)
|
||||
{
|
||||
if (st_period < 0) {
|
||||
const char *v = getenv("VKBRIDGE_STATS");
|
||||
st_period = v ? atoi(v) : 0;
|
||||
}
|
||||
if (!st_period) return;
|
||||
__atomic_add_fetch(&st_ns[cmd], ns, __ATOMIC_RELAXED);
|
||||
__atomic_add_fetch(&st_n[cmd], 1, __ATOMIC_RELAXED);
|
||||
__atomic_add_fetch(&st_wait_ns, wait_ns, __ATOMIC_RELAXED);
|
||||
uint64_t now = mono_ns(), last = __atomic_load_n(&st_last, __ATOMIC_RELAXED);
|
||||
if (!last) {
|
||||
__atomic_store_n(&st_last, now, __ATOMIC_RELAXED);
|
||||
return;
|
||||
}
|
||||
if (now - last < (uint64_t)st_period * 1000000000ull || !__atomic_compare_exchange_n(&st_last, &last, now, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED))
|
||||
return;
|
||||
uint64_t total = 0;
|
||||
for (uint32_t i = 0; i < VKB_CMD_COUNT; i++) total += st_ns[i];
|
||||
VKB_INFO("stats over %ds: %.1f ms in handlers, %.1f ms waiting for order", st_period, total / 1e6, st_wait_ns / 1e6);
|
||||
for (int k = 0; k < 8; k++) {
|
||||
uint64_t best = 0;
|
||||
uint32_t bi = 0;
|
||||
for (uint32_t i = 0; i < VKB_CMD_COUNT; i++)
|
||||
if (st_ns[i] > best) {
|
||||
best = st_ns[i];
|
||||
bi = i;
|
||||
}
|
||||
if (!best) break;
|
||||
VKB_INFO(" %-40s %8llu calls %9.2f ms (%.2f us each)", vkb_cmd_names[bi], (unsigned long long)st_n[bi], best / 1e6,
|
||||
best / 1e3 / (double)st_n[bi]);
|
||||
st_ns[bi] = 0;
|
||||
}
|
||||
memset(st_ns, 0, sizeof(st_ns));
|
||||
memset(st_n, 0, sizeof(st_n));
|
||||
st_wait_ns = 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ connection loop */
|
||||
|
||||
/* Reads the next request. Buffered: a burst of small asynchronous requests costs one recvmsg, not
|
||||
* two reads each. Descriptors arrive with the first bytes of their message, so they queue up in
|
||||
* order and each header takes its nfds from the front. The payload points into the buffer and
|
||||
* stays valid until the next call. */
|
||||
static int srv_recv(vkb_srv_conn *conn, vkb_msg_hdr *h, uint8_t **payload, int *fds, int *nfds)
|
||||
{
|
||||
*nfds = 0;
|
||||
if (conn->rpos == conn->rlen && conn->rcap > (16u << 20)) {
|
||||
free(conn->rb);
|
||||
conn->rb = NULL;
|
||||
conn->rcap = conn->rpos = conn->rlen = 0;
|
||||
}
|
||||
for (;;) {
|
||||
size_t avail = conn->rlen - conn->rpos;
|
||||
size_t need = sizeof(*h);
|
||||
if (avail >= sizeof(*h)) {
|
||||
memcpy(h, conn->rb + conn->rpos, sizeof(*h));
|
||||
if (h->magic != VKB_MAGIC) {
|
||||
VKB_ERR("transport: bad message magic 0x%08x", h->magic);
|
||||
return -1;
|
||||
}
|
||||
if (h->size > (1u << 30) || h->nfds > VKB_MAX_FDS) {
|
||||
VKB_ERR("transport: bad message (%u bytes, %u descriptors)", h->size, h->nfds);
|
||||
return -1;
|
||||
}
|
||||
need += h->size;
|
||||
if (avail >= need) {
|
||||
if ((int)h->nfds > conn->fdn) {
|
||||
VKB_ERR("transport: message arrived without its %u descriptors", h->nfds);
|
||||
return -1;
|
||||
}
|
||||
*nfds = (int)h->nfds;
|
||||
memcpy(fds, conn->fdq, sizeof(int) * h->nfds);
|
||||
conn->fdn -= (int)h->nfds;
|
||||
memmove(conn->fdq, conn->fdq + h->nfds, sizeof(int) * conn->fdn);
|
||||
*payload = conn->rb + conn->rpos + sizeof(*h);
|
||||
conn->rpos += need;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
if (conn->rpos) {
|
||||
memmove(conn->rb, conn->rb + conn->rpos, avail);
|
||||
conn->rpos = 0;
|
||||
conn->rlen = avail;
|
||||
}
|
||||
if (need < (256u << 10)) need = 256u << 10;
|
||||
if (need > conn->rcap) {
|
||||
size_t nc = conn->rcap ? conn->rcap : (256u << 10);
|
||||
while (nc < need) nc *= 2;
|
||||
uint8_t *nb = realloc(conn->rb, nc);
|
||||
if (!nb) return -1;
|
||||
conn->rb = nb;
|
||||
conn->rcap = nc;
|
||||
}
|
||||
union {
|
||||
char buf[CMSG_SPACE(sizeof(int) * VKB_MAX_FDS)];
|
||||
struct cmsghdr align;
|
||||
} cm;
|
||||
struct iovec iov = {conn->rb + conn->rlen, conn->rcap - conn->rlen};
|
||||
struct msghdr msg;
|
||||
memset(&msg, 0, sizeof(msg));
|
||||
msg.msg_iov = &iov;
|
||||
msg.msg_iovlen = 1;
|
||||
msg.msg_control = cm.buf;
|
||||
msg.msg_controllen = sizeof(cm.buf);
|
||||
ssize_t r;
|
||||
do {
|
||||
r = recvmsg(conn->sock, &msg, MSG_CMSG_CLOEXEC);
|
||||
} while (r < 0 && errno == EINTR);
|
||||
if (r <= 0) return -1;
|
||||
for (struct cmsghdr *cmh = CMSG_FIRSTHDR(&msg); cmh; cmh = CMSG_NXTHDR(&msg, cmh)) {
|
||||
if (cmh->cmsg_level != SOL_SOCKET || cmh->cmsg_type != SCM_RIGHTS) continue;
|
||||
int n = (int)((cmh->cmsg_len - CMSG_LEN(0)) / sizeof(int));
|
||||
for (int i = 0; i < n; i++) {
|
||||
int fd;
|
||||
memcpy(&fd, CMSG_DATA(cmh) + i * sizeof(int), sizeof(int));
|
||||
if (conn->fdn < (int)(sizeof(conn->fdq) / sizeof(conn->fdq[0]))) conn->fdq[conn->fdn++] = fd;
|
||||
else close(fd);
|
||||
}
|
||||
}
|
||||
if (msg.msg_flags & MSG_CTRUNC) VKB_WARN("transport: descriptors truncated");
|
||||
conn->rlen += (size_t)r;
|
||||
}
|
||||
}
|
||||
|
||||
static void *conn_main(void *arg)
|
||||
{
|
||||
vkb_srv_conn *conn = arg;
|
||||
vkb_srv_call c;
|
||||
vkb_enc_init(&c.r);
|
||||
int fds[VKB_MAX_FDS];
|
||||
for (;;) {
|
||||
vkb_msg_hdr h;
|
||||
int nfds = 0;
|
||||
uint8_t *payload;
|
||||
if (srv_recv(conn, &h, &payload, fds, &nfds) < 0) break;
|
||||
vkb_enc_reset(&c.r);
|
||||
vkb_dec_init(&c.d, payload, h.size, &conn->arena, fds, nfds);
|
||||
c.conn = conn;
|
||||
c.status = VKB_ST_OK;
|
||||
c.nclose = 0;
|
||||
c.in_stream = 0;
|
||||
c.table = NULL;
|
||||
c.dt = &vkb_global_dt;
|
||||
if (h.cmd >= VKB_CMD_COUNT) {
|
||||
VKB_ERR("unknown command id %u", h.cmd);
|
||||
c.status = VKB_ST_BAD_MESSAGE;
|
||||
} else if (!conn->proc && h.cmd != VKB_CMD_vkbHello) {
|
||||
VKB_ERR("%s before hello", vkb_cmd_names[h.cmd]);
|
||||
c.status = VKB_ST_BAD_MESSAGE;
|
||||
} else {
|
||||
if (h.table) {
|
||||
c.table = vkb_table_get(h.table);
|
||||
if (!c.table || c.table->proc != conn->proc) {
|
||||
VKB_ERR("%s: unknown dispatch table %u", vkb_cmd_names[h.cmd], h.table);
|
||||
c.status = VKB_ST_BAD_TABLE;
|
||||
} else {
|
||||
c.dt = &c.table->dt;
|
||||
}
|
||||
}
|
||||
if (c.status == VKB_ST_OK) {
|
||||
uint64_t t0 = st_period ? mono_ns() : 0;
|
||||
order_wait(conn->proc, h.barrier);
|
||||
uint64_t t1 = st_period ? mono_ns() : 0;
|
||||
vkb_srv_set_current_table(c.table);
|
||||
if (vkb_verbose) VKB_DBG("-> %s", vkb_cmd_names[h.cmd]);
|
||||
vkb_srv_current_cmd = vkb_cmd_names[h.cmd];
|
||||
vkb_srv_handlers[h.cmd](&c);
|
||||
vkb_srv_current_cmd = NULL;
|
||||
vkb_srv_set_current_table(NULL);
|
||||
if (st_period) stats_add(h.cmd, mono_ns() - t1, t1 - t0);
|
||||
}
|
||||
}
|
||||
vkb_dec_close_untaken(&c.d);
|
||||
order_done(conn->proc, h.seq);
|
||||
if (!(h.flags & VKB_F_NOREPLY)) {
|
||||
vkb_msg_hdr rh = {VKB_MAGIC, c.status == VKB_ST_OK ? (uint32_t)c.r.len : 0, c.status, 0,
|
||||
c.status == VKB_ST_OK ? (uint32_t)c.r.nfds : 0, 0, 0, 0};
|
||||
if (c.r.oom) {
|
||||
rh.cmd = VKB_ST_BAD_MESSAGE;
|
||||
rh.size = 0;
|
||||
rh.nfds = 0;
|
||||
}
|
||||
if (vkb_send_msg(conn->sock, &rh, c.r.buf, c.r.fds, (int)rh.nfds) < 0) {
|
||||
for (int i = 0; i < c.nclose; i++) close(c.close_after[i]);
|
||||
break;
|
||||
}
|
||||
} else if (c.status != VKB_ST_OK) {
|
||||
VKB_ERR("asynchronous %s failed (status %u)", vkb_cmd_names[h.cmd], c.status);
|
||||
} else if (vkb_cmd_result[h.cmd] && c.r.len >= sizeof(int32_t)) {
|
||||
/* The client already told the app VK_SUCCESS; a failure can only be reported here. */
|
||||
int32_t vr;
|
||||
memcpy(&vr, c.r.buf, sizeof(vr));
|
||||
if (vr < 0) VKB_ERR("asynchronous %s returned %d", vkb_cmd_names[h.cmd], vr);
|
||||
}
|
||||
for (int i = 0; i < c.nclose; i++) close(c.close_after[i]);
|
||||
vkb_arena_reset(&conn->arena);
|
||||
}
|
||||
close(conn->sock);
|
||||
vkb_enc_free(&c.r);
|
||||
free(conn->rb);
|
||||
for (int i = 0; i < conn->fdn; i++) close(conn->fdq[i]);
|
||||
vkb_arena_free(&conn->arena);
|
||||
if (conn->proc) proc_leave(conn->proc);
|
||||
free(conn);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void vkb_srv_serve(int lfd)
|
||||
{
|
||||
stats_add(0, 0, 0);
|
||||
for (;;) {
|
||||
int s = accept4(lfd, NULL, NULL, SOCK_CLOEXEC);
|
||||
if (s < 0) {
|
||||
if (errno == EINTR || errno == ECONNABORTED) continue;
|
||||
VKB_ERR("accept: %s", strerror(errno));
|
||||
continue;
|
||||
}
|
||||
vkb_srv_conn *conn = calloc(1, sizeof(*conn));
|
||||
conn->sock = s;
|
||||
pthread_attr_t attr;
|
||||
pthread_attr_init(&attr);
|
||||
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
||||
/* Driver calls (pipeline compiles) can use a lot of stack. */
|
||||
pthread_attr_setstacksize(&attr, 4u << 20);
|
||||
if (pthread_create(&conn->thread, &attr, conn_main, conn) != 0) {
|
||||
VKB_ERR("cannot start a connection thread");
|
||||
close(s);
|
||||
free(conn);
|
||||
}
|
||||
pthread_attr_destroy(&attr);
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Feature emulation: entry point. What the GPU lacks and the bridge can make up for is decided
|
||||
* here per physical device; the client reports those features as present, the server strips
|
||||
* them from vkCreateDevice and installs wrappers in the device's dispatch table.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
#include "server_emu.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static int token(const char *list, const char *t)
|
||||
{
|
||||
size_t n = strlen(t);
|
||||
for (const char *p = list; p && (p = strstr(p, t)); p += n)
|
||||
if ((p == list || p[-1] == ',') && (p[n] == ',' || p[n] == 0)) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int env_off(const char *name)
|
||||
{
|
||||
const char *v = getenv(name);
|
||||
return v && !strcmp(v, "0");
|
||||
}
|
||||
|
||||
uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd, uint32_t *missing)
|
||||
{
|
||||
VkPhysicalDeviceFeatures f;
|
||||
idt->vkGetPhysicalDeviceFeatures(pd, &f);
|
||||
uint32_t n = 0;
|
||||
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL);
|
||||
VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e));
|
||||
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e);
|
||||
int divisor = 0, depth_clip = 0, maint5 = 0, robust2 = 0;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
if (!strcmp(e[i].extensionName, "VK_EXT_vertex_attribute_divisor") ||
|
||||
!strcmp(e[i].extensionName, "VK_KHR_vertex_attribute_divisor"))
|
||||
divisor = 1;
|
||||
if (!strcmp(e[i].extensionName, "VK_EXT_depth_clip_enable")) depth_clip = 1;
|
||||
if (!strcmp(e[i].extensionName, "VK_KHR_maintenance5")) maint5 = 1;
|
||||
if (!strcmp(e[i].extensionName, "VK_EXT_robustness2") || !strcmp(e[i].extensionName, "VK_KHR_robustness2")) robust2 = 1;
|
||||
}
|
||||
free(e);
|
||||
/* VKBRIDGE_FAKE_MISSING=bc,divisor,clip,cull,depthclip pretends the GPU lacks them (host tests). */
|
||||
const char *fake = getenv("VKBRIDGE_FAKE_MISSING");
|
||||
if (fake) {
|
||||
if (token(fake, "bc")) f.textureCompressionBC = VK_FALSE;
|
||||
if (token(fake, "divisor")) divisor = 0;
|
||||
if (token(fake, "clip")) f.shaderClipDistance = VK_FALSE;
|
||||
if (token(fake, "cull")) f.shaderCullDistance = VK_FALSE;
|
||||
if (token(fake, "depthclip")) depth_clip = 0;
|
||||
if (token(fake, "maint5")) maint5 = 0;
|
||||
if (token(fake, "robustness2")) robust2 = 0;
|
||||
}
|
||||
uint32_t emu = 0;
|
||||
VkPhysicalDeviceProperties props;
|
||||
idt->vkGetPhysicalDeviceProperties(pd, &props);
|
||||
/* Vulkan 1.4 has maintenance5 in core. */
|
||||
if (!maint5 && (props.apiVersion < VK_API_VERSION_1_4 || (fake && token(fake, "maint5"))) && !env_off("VKBRIDGE_EMU_MAINT5"))
|
||||
emu |= VKB_EMU_MAINT5;
|
||||
if (!f.textureCompressionBC && vkb_emu_bcn_supported(idt, pd) && !env_off("VKBRIDGE_EMU_BCN")) emu |= VKB_EMU_BCN;
|
||||
if (!divisor && !env_off("VKBRIDGE_EMU_DIVISOR")) emu |= VKB_EMU_DIVISOR;
|
||||
if (!f.shaderClipDistance && !env_off("VKBRIDGE_EMU_CLIP")) emu |= VKB_EMU_CLIP_DISTANCE;
|
||||
if (!f.shaderCullDistance && !env_off("VKBRIDGE_EMU_CULL")) emu |= VKB_EMU_CULL_DISTANCE;
|
||||
if (!depth_clip && f.depthClamp && !env_off("VKBRIDGE_EMU_DEPTHCLIP")) emu |= VKB_EMU_DEPTH_CLIP;
|
||||
/* DXVK will not start without robustness2. Mali r44 lacks it; GameNative's wrapper reports it
|
||||
* (robustBufferAccess2, robustImageAccess2, nullDescriptor) without enforcing it, and DXVK
|
||||
* games run - out-of-bounds reads and null descriptors are then up to the driver. */
|
||||
if (!robust2 && f.robustBufferAccess && !env_off("VKBRIDGE_EMU_ROBUSTNESS2")) emu |= VKB_EMU_ROBUSTNESS2;
|
||||
/* PointSize in geometry/tessellation stages: stripped when the feature is missing. */
|
||||
if (!f.shaderTessellationAndGeometryPointSize && (f.geometryShader || f.tessellationShader)) emu |= VKB_EMU_POINT_SIZE;
|
||||
uint32_t miss = 0;
|
||||
if (!f.textureCompressionBC) miss |= VKB_EMU_BCN;
|
||||
if (!divisor) miss |= VKB_EMU_DIVISOR;
|
||||
if (!f.shaderClipDistance) miss |= VKB_EMU_CLIP_DISTANCE;
|
||||
if (!f.shaderCullDistance) miss |= VKB_EMU_CULL_DISTANCE;
|
||||
if (!depth_clip) miss |= VKB_EMU_DEPTH_CLIP;
|
||||
if (emu & VKB_EMU_MAINT5) miss |= VKB_EMU_MAINT5;
|
||||
if (!robust2) miss |= VKB_EMU_ROBUSTNESS2;
|
||||
*missing = miss;
|
||||
return emu & VKB_EMU_IMPLEMENTED;
|
||||
}
|
||||
|
||||
/* Remove a structure from a pNext chain (the chain lives in the request's arena). */
|
||||
static void chain_remove(VkDeviceCreateInfo *ci, VkStructureType t)
|
||||
{
|
||||
VkBaseOutStructure *prev = (VkBaseOutStructure *)ci;
|
||||
while (prev->pNext) {
|
||||
if (prev->pNext->sType == t) prev->pNext = prev->pNext->pNext;
|
||||
else prev = prev->pNext;
|
||||
}
|
||||
}
|
||||
|
||||
static VkPhysicalDeviceFeatures *find_features(VkDeviceCreateInfo *ci)
|
||||
{
|
||||
if (ci->pEnabledFeatures) return (VkPhysicalDeviceFeatures *)ci->pEnabledFeatures;
|
||||
for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci->pNext; b; b = b->pNext)
|
||||
if (b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2) return &((VkPhysicalDeviceFeatures2 *)b)->features;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32_t emu, VkDeviceCreateInfo *ci, vkb_arena *a)
|
||||
{
|
||||
VkPhysicalDeviceFeatures real;
|
||||
inst->real.vkGetPhysicalDeviceFeatures(pd, &real);
|
||||
VkPhysicalDeviceFeatures *f = find_features(ci);
|
||||
if ((emu & (VKB_EMU_BCN | VKB_EMU_DEPTH_CLIP)) && !f) {
|
||||
/* The BC decoder writes R8/RG8 storage images: it needs this feature on, so the request
|
||||
* gets a features structure if it had none. */
|
||||
f = vkb_arena_alloc(a, sizeof(*f));
|
||||
ci->pEnabledFeatures = f;
|
||||
}
|
||||
if (f) {
|
||||
/* pEnabledFeatures came from the request: it is ours to change. Anything the client asked
|
||||
* for that the GPU does not have is either emulated or would fail the call. */
|
||||
VkBool32 *want = (VkBool32 *)f;
|
||||
const VkBool32 *have = (const VkBool32 *)ℜ
|
||||
for (size_t i = 0; i < sizeof(*f) / sizeof(VkBool32); i++) {
|
||||
if (want[i] && !have[i]) want[i] = VK_FALSE;
|
||||
}
|
||||
if (emu & VKB_EMU_BCN) f->shaderStorageImageExtendedFormats = VK_TRUE;
|
||||
if (emu & VKB_EMU_DEPTH_CLIP) f->depthClamp = VK_TRUE;
|
||||
}
|
||||
if (emu & VKB_EMU_DIVISOR) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT);
|
||||
if (emu & VKB_EMU_DEPTH_CLIP) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT);
|
||||
if (emu & VKB_EMU_MAINT5) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES);
|
||||
if (emu & VKB_EMU_ROBUSTNESS2) {
|
||||
chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT);
|
||||
/* What robustness the GPU has stays on; robustBufferAccess2 asks for at least that. */
|
||||
VkPhysicalDeviceFeatures *rf = find_features(ci);
|
||||
if (rf) rf->robustBufferAccess = VK_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_emu_device_init(vkb_srv_table *dev, uint32_t emu)
|
||||
{
|
||||
if (!emu) return;
|
||||
vkb_emu_device *e = calloc(1, sizeof(*e));
|
||||
e->flags = emu;
|
||||
e->dev = dev;
|
||||
pthread_mutex_init(&e->lock, NULL);
|
||||
dev->emu = e;
|
||||
vkb_emu_install(dev);
|
||||
}
|
||||
|
||||
void vkb_emu_device_destroy(vkb_srv_table *dev)
|
||||
{
|
||||
if (!dev->emu) return;
|
||||
vkb_emu_uninstall(dev);
|
||||
pthread_mutex_destroy(&dev->emu->lock);
|
||||
free(dev->emu);
|
||||
dev->emu = NULL;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later */
|
||||
#ifndef VKB_SERVER_EMU_H
|
||||
#define VKB_SERVER_EMU_H
|
||||
|
||||
#include "vkb_server.h"
|
||||
|
||||
/* Emulations that are implemented (the rest are never offered to the client). */
|
||||
#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5 | VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE | VKB_EMU_BCN | \
|
||||
VKB_EMU_DIVISOR | VKB_EMU_DEPTH_CLIP | VKB_EMU_ROBUSTNESS2)
|
||||
|
||||
#define VKB_EMU_BUCKETS 1024
|
||||
|
||||
typedef struct vkb_emu_image {
|
||||
VkImage image;
|
||||
VkImageType type;
|
||||
VkFormat format; /* what the driver holds */
|
||||
VkFormat client_format; /* what the app asked for (differs for emulated formats) */
|
||||
VkExtent3D extent;
|
||||
uint32_t mips, layers;
|
||||
void *emu; /* per-emulation state (BCn: decode resources) */
|
||||
struct vkb_emu_image *next;
|
||||
} vkb_emu_image;
|
||||
|
||||
typedef struct vkb_emu_buffer {
|
||||
VkBuffer buffer;
|
||||
VkDeviceSize size;
|
||||
struct vkb_emu_buffer *next;
|
||||
} vkb_emu_buffer;
|
||||
|
||||
typedef struct vkb_emu_device {
|
||||
uint32_t flags;
|
||||
vkb_srv_table *dev;
|
||||
pthread_mutex_t lock;
|
||||
vkb_emu_image *images[VKB_EMU_BUCKETS];
|
||||
vkb_emu_buffer *buffers[VKB_EMU_BUCKETS];
|
||||
void *bcn; /* server_emu_bcn.c */
|
||||
void *cmdstate; /* server_emu_cmdstate.c */
|
||||
void *divisor; /* server_emu_divisor.c */
|
||||
void *shaders; /* server_emu_shader.c */
|
||||
} vkb_emu_device;
|
||||
|
||||
/* command buffer state (server_emu_cmdstate.c) */
|
||||
void vkb_emu_cmdstate_install(vkb_srv_table *dev);
|
||||
void vkb_emu_cmdstate_uninstall(vkb_srv_table *dev);
|
||||
void vkb_emu_restore_compute(vkb_emu_device *e, VkCommandBuffer cb);
|
||||
void *vkb_emu_cb_gfx(vkb_emu_device *e, VkCommandBuffer cb, size_t size);
|
||||
VkDescriptorSet vkb_emu_cb_scratch_set(vkb_emu_device *e, VkCommandBuffer cb, VkDescriptorSetLayout dsl);
|
||||
/* vertex attribute divisor (server_emu_divisor.c) */
|
||||
typedef struct div_info div_info;
|
||||
size_t vkb_emu_divisor_info_size(void);
|
||||
void vkb_emu_divisor_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, div_info *out);
|
||||
void vkb_emu_divisor_created(vkb_emu_device *e, VkDevice device, VkPipelineCache cache, const VkGraphicsPipelineCreateInfo *ci,
|
||||
VkPipeline p, div_info *info);
|
||||
void vkb_emu_divisor_install(vkb_srv_table *dev);
|
||||
void vkb_emu_divisor_uninstall(vkb_srv_table *dev);
|
||||
void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p);
|
||||
void vkb_emu_gfx_reset(void *gfx);
|
||||
void vkb_emu_gfx_free(void *gfx);
|
||||
/* BCn (server_emu_bcn.c) */
|
||||
void vkb_emu_bcn_install(vkb_srv_table *dev);
|
||||
void vkb_emu_bcn_uninstall(vkb_srv_table *dev);
|
||||
VkFormat vkb_emu_bcn_view_format(vkb_emu_device *e, VkImage image, VkFormat requested);
|
||||
void vkb_emu_bcn_buffer_usage(vkb_emu_device *e, VkBufferCreateInfo *ci);
|
||||
int vkb_emu_bcn_blocks_readback(vkb_emu_device *e, VkImage img);
|
||||
|
||||
/* layer (server_emu_layer.c) */
|
||||
void vkb_emu_depth_clip_pipeline(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci);
|
||||
void vkb_emu_depth_clip_install(vkb_srv_table *dev);
|
||||
vkb_emu_device *vkb_emu_cur(void);
|
||||
const vkb_dispatch *vkb_emu_real(void);
|
||||
void *vkb_emu_chain_take(const void *head, VkStructureType t);
|
||||
vkb_emu_image *vkb_emu_find_image(vkb_emu_device *e, VkImage img);
|
||||
void vkb_emu_track_image(vkb_emu_device *e, VkImage img, const VkImageCreateInfo *ci, VkFormat client_format);
|
||||
|
||||
/* feature hooks (server_emu_features.c and friends) */
|
||||
int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd);
|
||||
void vkb_emu_install(vkb_srv_table *dev);
|
||||
void vkb_emu_uninstall(vkb_srv_table *dev);
|
||||
void vkb_emu_install_features(vkb_srv_table *dev);
|
||||
void vkb_emu_uninstall_features(vkb_srv_table *dev);
|
||||
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci);
|
||||
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img);
|
||||
/* Rewrites a graphics pipeline's shaders; temporary modules are appended to mods. */
|
||||
void vkb_emu_shader_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, VkShaderModule *mods,
|
||||
uint32_t *nmods, uint32_t cap);
|
||||
void vkb_emu_shader_install(vkb_srv_table *dev);
|
||||
VkShaderModule vkb_emu_shader_zero_base_instance(vkb_emu_device *e, VkDevice device, const VkPipelineShaderStageCreateInfo *vs);
|
||||
void vkb_emu_shader_uninstall(vkb_srv_table *dev);
|
||||
/* 1 = handled (the emulation recorded its own commands instead). */
|
||||
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
|
||||
uint32_t n, const VkImageCopy *regions);
|
||||
int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info);
|
||||
int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
|
||||
const VkBufferImageCopy *regions);
|
||||
int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,432 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* BC1-BC7 textures on a GPU without them (textureCompressionBC missing; DXVK and vkd3d-proton
|
||||
* refuse such a device). The image the app creates in a BC format is created decoded instead
|
||||
* (RGBA8 / R8 / RG8 / RGBA16F, see vkb_emu_formats.h), mutable so sRGB/SNORM views work, and
|
||||
* every upload - vkCmdCopyBufferToImage(2), how all BC data arrives - becomes a compute dispatch
|
||||
* that decodes the blocks from the source buffer straight into it (shaders/bc_decode.comp). The
|
||||
* app's compute bindings are restored afterwards (server_emu_cmdstate.c).
|
||||
*
|
||||
* Not emulated (logged once): reading a BC image back to a buffer, and copies between BC and
|
||||
* uncompressed images (they would need an encoder).
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
#include "vkb_emu_formats.h"
|
||||
#include "bc_spv.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
enum { FAM_BC1, FAM_BC2, FAM_BC3, FAM_BC4, FAM_BC5, FAM_BC6H, FAM_BC7, FAM_COUNT };
|
||||
|
||||
typedef struct bcn_state {
|
||||
VkDescriptorSetLayout dsl;
|
||||
VkPipelineLayout layout;
|
||||
VkPipeline pipes[FAM_COUNT];
|
||||
VkDeviceSize ssbo_align;
|
||||
int push; /* VK_KHR_push_descriptor; else per-command-buffer sets */
|
||||
pthread_mutex_t lock;
|
||||
} bcn_state;
|
||||
|
||||
typedef struct bcn_image {
|
||||
VkImageView views[16]; /* per mip: 2D array storage view of every layer */
|
||||
} bcn_image;
|
||||
|
||||
typedef struct pc_t {
|
||||
uint32_t src_word, row_blocks, layer_blocks, flags;
|
||||
int32_t dst_off[2];
|
||||
uint32_t extent[2];
|
||||
} pc_t;
|
||||
|
||||
static int family(VkFormat f)
|
||||
{
|
||||
switch (f) {
|
||||
case VK_FORMAT_BC1_RGB_UNORM_BLOCK: case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
|
||||
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return FAM_BC1;
|
||||
case VK_FORMAT_BC2_UNORM_BLOCK: case VK_FORMAT_BC2_SRGB_BLOCK: return FAM_BC2;
|
||||
case VK_FORMAT_BC3_UNORM_BLOCK: case VK_FORMAT_BC3_SRGB_BLOCK: return FAM_BC3;
|
||||
case VK_FORMAT_BC4_UNORM_BLOCK: case VK_FORMAT_BC4_SNORM_BLOCK: return FAM_BC4;
|
||||
case VK_FORMAT_BC5_UNORM_BLOCK: case VK_FORMAT_BC5_SNORM_BLOCK: return FAM_BC5;
|
||||
case VK_FORMAT_BC6H_UFLOAT_BLOCK: case VK_FORMAT_BC6H_SFLOAT_BLOCK: return FAM_BC6H;
|
||||
default: return FAM_BC7;
|
||||
}
|
||||
}
|
||||
|
||||
static uint32_t family_flags(VkFormat f)
|
||||
{
|
||||
uint32_t fl = 0;
|
||||
if (f == VK_FORMAT_BC1_RGB_UNORM_BLOCK || f == VK_FORMAT_BC1_RGB_SRGB_BLOCK) fl |= 1;
|
||||
if (f == VK_FORMAT_BC4_SNORM_BLOCK || f == VK_FORMAT_BC5_SNORM_BLOCK || f == VK_FORMAT_BC6H_SFLOAT_BLOCK) fl |= 2;
|
||||
return fl;
|
||||
}
|
||||
|
||||
int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd)
|
||||
{
|
||||
VkPhysicalDeviceFeatures f;
|
||||
idt->vkGetPhysicalDeviceFeatures(pd, &f);
|
||||
if (!f.shaderStorageImageExtendedFormats) {
|
||||
VKB_WARN("BC emulation: the GPU lacks shaderStorageImageExtendedFormats");
|
||||
return 0;
|
||||
}
|
||||
static const VkFormat need[] = {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R16G16B16A16_SFLOAT};
|
||||
for (size_t i = 0; i < sizeof(need) / sizeof(need[0]); i++) {
|
||||
VkFormatProperties fp;
|
||||
idt->vkGetPhysicalDeviceFormatProperties(pd, need[i], &fp);
|
||||
if (!(fp.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
|
||||
VKB_WARN("BC emulation: format %d cannot be a storage image", need[i]);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
VkPhysicalDeviceProperties p;
|
||||
idt->vkGetPhysicalDeviceProperties(pd, &p);
|
||||
if (p.apiVersion >= VK_API_VERSION_1_4) return 1;
|
||||
uint32_t n = 0;
|
||||
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL);
|
||||
VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e));
|
||||
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e);
|
||||
free(e);
|
||||
/* Without VK_KHR_push_descriptor (Mali-G720 on driver 44.1) the decoder binds ordinary sets. */
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Push descriptors for the decoder; without them, sets from the command buffer's scratch pools.
|
||||
* VKBRIDGE_FAKE_MISSING=...,push takes the second way on a GPU that has them (host tests). */
|
||||
static int has_push(vkb_srv_table *dev)
|
||||
{
|
||||
const char *fake = getenv("VKBRIDGE_FAKE_MISSING");
|
||||
if (fake && strstr(fake, "push")) return 0;
|
||||
VkPhysicalDeviceProperties p;
|
||||
dev->real.vkGetPhysicalDeviceProperties(dev->physical, &p);
|
||||
if (p.apiVersion >= VK_API_VERSION_1_4 && dev->api_version >= VK_API_VERSION_1_4) return dev->real.vkCmdPushDescriptorSet != NULL;
|
||||
uint32_t n = 0;
|
||||
dev->real.vkEnumerateDeviceExtensionProperties(dev->physical, NULL, &n, NULL);
|
||||
VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e));
|
||||
dev->real.vkEnumerateDeviceExtensionProperties(dev->physical, NULL, &n, e);
|
||||
int ok = 0;
|
||||
for (uint32_t i = 0; i < n; i++) ok |= !strcmp(e[i].extensionName, "VK_KHR_push_descriptor");
|
||||
free(e);
|
||||
return ok && dev->real.vkCmdPushDescriptorSet != NULL;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ images */
|
||||
|
||||
void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci)
|
||||
{
|
||||
if (!(e->flags & VKB_EMU_BCN) || !vkb_is_bc(ci->format)) return;
|
||||
/* The image keeps the meaning of the app's format (sRGB, SNORM) so blits and copies convert as
|
||||
* they would; the decoder writes it through a view in the storage format (EXTENDED_USAGE lets
|
||||
* the image carry STORAGE although sRGB/SNORM formats cannot be stored to). */
|
||||
static __thread VkFormat list[2];
|
||||
VkFormat view = vkb_bc_view_format(ci->format), st = vkb_bc_storage_format(ci->format);
|
||||
list[0] = view;
|
||||
list[1] = st;
|
||||
ci->format = view;
|
||||
ci->flags &= ~(VkImageCreateFlags)VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
|
||||
ci->flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
|
||||
ci->usage |= VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
for (VkBaseOutStructure *b = (VkBaseOutStructure *)ci->pNext; b; b = b->pNext) {
|
||||
if (b->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO) {
|
||||
VkImageFormatListCreateInfo *fl = (VkImageFormatListCreateInfo *)b;
|
||||
fl->viewFormatCount = view == st ? 1 : 2;
|
||||
fl->pViewFormats = list;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img)
|
||||
{
|
||||
bcn_image *bi = img->emu;
|
||||
if (!bi) return;
|
||||
for (int i = 0; i < 16; i++)
|
||||
if (bi->views[i]) e->dev->real.vkDestroyImageView(e->dev->device, bi->views[i], NULL);
|
||||
free(bi);
|
||||
img->emu = NULL;
|
||||
}
|
||||
|
||||
VkFormat vkb_emu_bcn_view_format(vkb_emu_device *e, VkImage image, VkFormat requested)
|
||||
{
|
||||
if (!(e->flags & VKB_EMU_BCN)) return requested;
|
||||
if (vkb_is_bc(requested)) return vkb_bc_view_format(requested);
|
||||
vkb_emu_image *r = vkb_emu_find_image(e, image);
|
||||
if (r && vkb_is_bc(r->client_format)) {
|
||||
VKB_ONCE(VKB_LOG_WARN, "BC emulation: an uncompressed view (format %d) of a BC image shows decoded texels (logged once)", requested);
|
||||
return vkb_bc_view_format(r->client_format);
|
||||
}
|
||||
return requested;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateImageView(VkDevice device, const VkImageViewCreateInfo *ci,
|
||||
const VkAllocationCallbacks *pAllocator, VkImageView *pView)
|
||||
{
|
||||
VkImageViewCreateInfo *v = (VkImageViewCreateInfo *)ci;
|
||||
v->format = vkb_emu_bcn_view_format(vkb_emu_cur(), ci->image, ci->format);
|
||||
return vkb_emu_real()->vkCreateImageView(device, v, pAllocator, pView);
|
||||
}
|
||||
|
||||
void vkb_emu_bcn_buffer_usage(vkb_emu_device *e, VkBufferCreateInfo *ci)
|
||||
{
|
||||
/* The decoder reads uploads as a storage buffer. */
|
||||
if ((e->flags & VKB_EMU_BCN) && (ci->usage & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)) ci->usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ decoder */
|
||||
|
||||
static VkPipeline pipeline(vkb_emu_device *e, int fam)
|
||||
{
|
||||
bcn_state *s = e->bcn;
|
||||
if (s->pipes[fam]) return s->pipes[fam];
|
||||
pthread_mutex_lock(&s->lock);
|
||||
if (!s->pipes[fam]) {
|
||||
static const uint32_t *const code[FAM_COUNT] = {spv_bc1, spv_bc2, spv_bc3, spv_bc4, spv_bc5, spv_bc6h, spv_bc7};
|
||||
static const size_t size[FAM_COUNT] = {sizeof(spv_bc1), sizeof(spv_bc2), sizeof(spv_bc3), sizeof(spv_bc4),
|
||||
sizeof(spv_bc5), sizeof(spv_bc6h), sizeof(spv_bc7)};
|
||||
const vkb_dispatch *r = &e->dev->real;
|
||||
VkDevice d = e->dev->device;
|
||||
VkShaderModuleCreateInfo mci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, size[fam], code[fam]};
|
||||
VkShaderModule m;
|
||||
if (r->vkCreateShaderModule(d, &mci, NULL, &m) == VK_SUCCESS) {
|
||||
VkComputePipelineCreateInfo pci = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
|
||||
pci.stage = (VkPipelineShaderStageCreateInfo){VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0,
|
||||
VK_SHADER_STAGE_COMPUTE_BIT, m, "main", NULL};
|
||||
pci.layout = s->layout;
|
||||
if (r->vkCreateComputePipelines(d, VK_NULL_HANDLE, 1, &pci, NULL, &s->pipes[fam]) != VK_SUCCESS) {
|
||||
VKB_ERR("BC emulation: decoder pipeline %d failed to build", fam);
|
||||
s->pipes[fam] = VK_NULL_HANDLE;
|
||||
}
|
||||
r->vkDestroyShaderModule(d, m, NULL);
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return s->pipes[fam];
|
||||
}
|
||||
|
||||
static VkImageView storage_view(vkb_emu_device *e, vkb_emu_image *img, uint32_t mip)
|
||||
{
|
||||
if (mip >= 16) return VK_NULL_HANDLE;
|
||||
pthread_mutex_lock(&e->lock);
|
||||
if (!img->emu) img->emu = calloc(1, sizeof(bcn_image));
|
||||
bcn_image *bi = img->emu;
|
||||
VkImageView v = bi->views[mip];
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
if (v) return v;
|
||||
VkImageViewUsageCreateInfo usage = {VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, NULL, VK_IMAGE_USAGE_STORAGE_BIT};
|
||||
VkImageViewCreateInfo ci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, &usage, 0, img->image, VK_IMAGE_VIEW_TYPE_2D_ARRAY,
|
||||
vkb_bc_storage_format(img->client_format),
|
||||
{0}, {VK_IMAGE_ASPECT_COLOR_BIT, mip, 1, 0, img->layers}};
|
||||
if (e->dev->real.vkCreateImageView(e->dev->device, &ci, NULL, &v) != VK_SUCCESS) return VK_NULL_HANDLE;
|
||||
pthread_mutex_lock(&e->lock);
|
||||
if (bi->views[mip]) {
|
||||
e->dev->real.vkDestroyImageView(e->dev->device, v, NULL);
|
||||
v = bi->views[mip];
|
||||
} else {
|
||||
bi->views[mip] = v;
|
||||
}
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
return v;
|
||||
}
|
||||
|
||||
typedef struct region {
|
||||
VkDeviceSize offset;
|
||||
uint32_t row_length, image_height;
|
||||
VkImageSubresourceLayers sub;
|
||||
VkOffset3D ioff;
|
||||
VkExtent3D iext;
|
||||
} region;
|
||||
|
||||
static void decode(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, vkb_emu_image *img, VkImageLayout layout,
|
||||
uint32_t n, const region *regs)
|
||||
{
|
||||
bcn_state *s = e->bcn;
|
||||
const vkb_dispatch *r = &e->dev->real;
|
||||
if (img->type != VK_IMAGE_TYPE_2D) {
|
||||
VKB_ONCE(VKB_LOG_WARN, "BC emulation: uploads to 1D/3D BC images are not decoded (logged once)");
|
||||
return;
|
||||
}
|
||||
VkPipeline pipe = pipeline(e, family(img->client_format));
|
||||
if (!pipe) return;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
const region *g = ®s[i];
|
||||
VkImageView view = storage_view(e, img, g->sub.mipLevel);
|
||||
if (!view) continue;
|
||||
VkImageSubresourceRange range = {VK_IMAGE_ASPECT_COLOR_BIT, g->sub.mipLevel, 1, g->sub.baseArrayLayer, g->sub.layerCount};
|
||||
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_MEMORY_WRITE_BIT,
|
||||
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT};
|
||||
VkImageMemoryBarrier ib = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_WRITE_BIT,
|
||||
layout, VK_IMAGE_LAYOUT_GENERAL, VK_QUEUE_FAMILY_IGNORED, VK_QUEUE_FAMILY_IGNORED, img->image, range};
|
||||
r->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
|
||||
0, 1, &mb, 0, NULL, 1, &ib);
|
||||
VkDeviceSize aligned = g->offset & ~(s->ssbo_align - 1);
|
||||
VkDescriptorBufferInfo bi = {src, aligned, VK_WHOLE_SIZE};
|
||||
VkDescriptorImageInfo ii = {VK_NULL_HANDLE, view, VK_IMAGE_LAYOUT_GENERAL};
|
||||
VkWriteDescriptorSet w[2] = {
|
||||
{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, VK_NULL_HANDLE, 0, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, NULL, &bi, NULL},
|
||||
{VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, NULL, VK_NULL_HANDLE, 1, 0, 1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &ii, NULL, NULL}};
|
||||
r->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, pipe);
|
||||
if (s->push) {
|
||||
r->vkCmdPushDescriptorSet(cb, VK_PIPELINE_BIND_POINT_COMPUTE, s->layout, 0, 2, w);
|
||||
} else {
|
||||
VkDescriptorSet set = vkb_emu_cb_scratch_set(e, cb, s->dsl);
|
||||
if (!set) {
|
||||
VKB_ONCE(VKB_LOG_ERROR, "BC emulation: no descriptor set for the decoder (logged once)");
|
||||
continue;
|
||||
}
|
||||
w[0].dstSet = w[1].dstSet = set;
|
||||
r->vkUpdateDescriptorSets(e->dev->device, 2, w, 0, NULL);
|
||||
r->vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_COMPUTE, s->layout, 0, 1, &set, 0, NULL);
|
||||
}
|
||||
uint32_t w_tex = g->row_length ? g->row_length : g->iext.width;
|
||||
uint32_t h_tex = g->image_height ? g->image_height : g->iext.height;
|
||||
pc_t pc;
|
||||
pc.src_word = (uint32_t)((g->offset - aligned) / 4);
|
||||
pc.row_blocks = (w_tex + 3) / 4;
|
||||
pc.layer_blocks = pc.row_blocks * ((h_tex + 3) / 4);
|
||||
pc.flags = family_flags(img->client_format) | (g->sub.baseArrayLayer << 8);
|
||||
pc.dst_off[0] = g->ioff.x;
|
||||
pc.dst_off[1] = g->ioff.y;
|
||||
pc.extent[0] = g->iext.width;
|
||||
pc.extent[1] = g->iext.height;
|
||||
r->vkCmdPushConstants(cb, s->layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc), &pc);
|
||||
uint32_t bw = (g->iext.width + 3) / 4, bh = (g->iext.height + 3) / 4;
|
||||
r->vkCmdDispatch(cb, (bw + 7) / 8, (bh + 7) / 8, g->sub.layerCount);
|
||||
ib.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
|
||||
ib.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT;
|
||||
ib.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
|
||||
ib.newLayout = layout;
|
||||
r->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &ib);
|
||||
}
|
||||
vkb_emu_restore_compute(e, cb);
|
||||
}
|
||||
|
||||
static vkb_emu_image *bc_image(vkb_emu_device *e, VkImage img)
|
||||
{
|
||||
if (!(e->flags & VKB_EMU_BCN)) return NULL;
|
||||
vkb_emu_image *r = vkb_emu_find_image(e, img);
|
||||
return r && vkb_is_bc(r->client_format) ? r : NULL;
|
||||
}
|
||||
|
||||
int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
|
||||
const VkBufferImageCopy *regions)
|
||||
{
|
||||
vkb_emu_image *img = bc_image(e, dst);
|
||||
if (!img) return 0;
|
||||
region *g = malloc((n ? n : 1) * sizeof(*g));
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
g[i] = (region){regions[i].bufferOffset, regions[i].bufferRowLength, regions[i].bufferImageHeight, regions[i].imageSubresource,
|
||||
regions[i].imageOffset, regions[i].imageExtent};
|
||||
decode(e, cb, src, img, dl, n, g);
|
||||
free(g);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info)
|
||||
{
|
||||
vkb_emu_image *img = bc_image(e, info->dstImage);
|
||||
if (!img) return 0;
|
||||
region *g = malloc((info->regionCount ? info->regionCount : 1) * sizeof(*g));
|
||||
for (uint32_t i = 0; i < info->regionCount; i++) {
|
||||
const VkBufferImageCopy2 *r = &info->pRegions[i];
|
||||
g[i] = (region){r->bufferOffset, r->bufferRowLength, r->bufferImageHeight, r->imageSubresource, r->imageOffset, r->imageExtent};
|
||||
}
|
||||
decode(e, cb, info->srcBuffer, img, info->dstImageLayout, info->regionCount, g);
|
||||
free(g);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Copies between BC images copy decoded texels; a region may run past a small mip's edge (whole
|
||||
* blocks), which the decoded image does not have. */
|
||||
static void clamp_region(const vkb_emu_image *s, const vkb_emu_image *d, const VkImageSubresourceLayers *ss,
|
||||
const VkImageSubresourceLayers *ds, const VkOffset3D *so, const VkOffset3D *dof, VkExtent3D *ext)
|
||||
{
|
||||
uint32_t sw = s->extent.width >> ss->mipLevel, sh = s->extent.height >> ss->mipLevel;
|
||||
uint32_t dw = d->extent.width >> ds->mipLevel, dh = d->extent.height >> ds->mipLevel;
|
||||
if (!sw) sw = 1;
|
||||
if (!sh) sh = 1;
|
||||
if (!dw) dw = 1;
|
||||
if (!dh) dh = 1;
|
||||
if ((uint32_t)so->x + ext->width > sw) ext->width = sw > (uint32_t)so->x ? sw - (uint32_t)so->x : 0;
|
||||
if ((uint32_t)so->y + ext->height > sh) ext->height = sh > (uint32_t)so->y ? sh - (uint32_t)so->y : 0;
|
||||
if ((uint32_t)dof->x + ext->width > dw) ext->width = dw > (uint32_t)dof->x ? dw - (uint32_t)dof->x : 0;
|
||||
if ((uint32_t)dof->y + ext->height > dh) ext->height = dh > (uint32_t)dof->y ? dh - (uint32_t)dof->y : 0;
|
||||
}
|
||||
|
||||
int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, uint32_t n,
|
||||
const VkImageCopy *regions)
|
||||
{
|
||||
vkb_emu_image *s = bc_image(e, src), *d = bc_image(e, dst);
|
||||
if (!s && !d) return 0;
|
||||
if (!s || !d || vkb_bc_storage_format(s->client_format) != vkb_bc_storage_format(d->client_format)) {
|
||||
VKB_ONCE(VKB_LOG_WARN, "BC emulation: a copy between a BC image and another format is skipped (logged once)");
|
||||
return 1;
|
||||
}
|
||||
VkImageCopy *c = (VkImageCopy *)regions;
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
clamp_region(s, d, &c[i].srcSubresource, &c[i].dstSubresource, &c[i].srcOffset, &c[i].dstOffset, &c[i].extent);
|
||||
e->dev->real.vkCmdCopyImage(cb, src, sl, dst, dl, n, regions);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info)
|
||||
{
|
||||
vkb_emu_image *s = bc_image(e, info->srcImage), *d = bc_image(e, info->dstImage);
|
||||
if (!s && !d) return 0;
|
||||
if (!s || !d || vkb_bc_storage_format(s->client_format) != vkb_bc_storage_format(d->client_format)) {
|
||||
VKB_ONCE(VKB_LOG_WARN, "BC emulation: a copy between a BC image and another format is skipped (logged once)");
|
||||
return 1;
|
||||
}
|
||||
VkImageCopy2 *c = (VkImageCopy2 *)info->pRegions;
|
||||
for (uint32_t i = 0; i < info->regionCount; i++)
|
||||
clamp_region(s, d, &c[i].srcSubresource, &c[i].dstSubresource, &c[i].srcOffset, &c[i].dstOffset, &c[i].extent);
|
||||
e->dev->real.vkCmdCopyImage2(cb, info);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int vkb_emu_bcn_blocks_readback(vkb_emu_device *e, VkImage img)
|
||||
{
|
||||
if (!bc_image(e, img)) return 0;
|
||||
VKB_ONCE(VKB_LOG_WARN, "BC emulation: reading a BC image back to a buffer is not supported (logged once)");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ install */
|
||||
|
||||
void vkb_emu_bcn_install(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
if (!(e->flags & VKB_EMU_BCN)) return;
|
||||
bcn_state *s = calloc(1, sizeof(*s));
|
||||
pthread_mutex_init(&s->lock, NULL);
|
||||
VkPhysicalDeviceProperties p;
|
||||
dev->real.vkGetPhysicalDeviceProperties(dev->physical, &p);
|
||||
s->ssbo_align = p.limits.minStorageBufferOffsetAlignment ? p.limits.minStorageBufferOffsetAlignment : 4;
|
||||
VkDescriptorSetLayoutBinding b[2] = {{0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL},
|
||||
{1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_COMPUTE_BIT, NULL}};
|
||||
s->push = has_push(dev);
|
||||
VKB_INFO("BC emulation: decoder binds with %s", s->push ? "push descriptors" : "descriptor sets (no VK_KHR_push_descriptor)");
|
||||
VkDescriptorSetLayoutCreateInfo dci = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, NULL,
|
||||
s->push ? VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT : 0, 2, b};
|
||||
VkPushConstantRange pr = {VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(pc_t)};
|
||||
if (dev->real.vkCreateDescriptorSetLayout(dev->device, &dci, NULL, &s->dsl) != VK_SUCCESS) {
|
||||
VKB_ERR("BC emulation: cannot create the decoder's descriptor layout");
|
||||
free(s);
|
||||
e->flags &= ~VKB_EMU_BCN;
|
||||
return;
|
||||
}
|
||||
VkPipelineLayoutCreateInfo plci = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, NULL, 0, 1, &s->dsl, 1, &pr};
|
||||
dev->real.vkCreatePipelineLayout(dev->device, &plci, NULL, &s->layout);
|
||||
e->bcn = s;
|
||||
dev->dt.vkCreateImageView = emu_CreateImageView;
|
||||
}
|
||||
|
||||
void vkb_emu_bcn_uninstall(vkb_srv_table *dev)
|
||||
{
|
||||
bcn_state *s = dev->emu->bcn;
|
||||
if (!s) return;
|
||||
for (int i = 0; i < FAM_COUNT; i++)
|
||||
if (s->pipes[i]) dev->real.vkDestroyPipeline(dev->device, s->pipes[i], NULL);
|
||||
dev->real.vkDestroyPipelineLayout(dev->device, s->layout, NULL);
|
||||
dev->real.vkDestroyDescriptorSetLayout(dev->device, s->dsl, NULL);
|
||||
pthread_mutex_destroy(&s->lock);
|
||||
free(s);
|
||||
dev->emu->bcn = NULL;
|
||||
}
|
||||
@@ -0,0 +1,290 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* What an app has bound in a command buffer, for emulations that record commands of their own
|
||||
* into it (the BCn decoder's dispatches) and must leave the app's state as it was: the compute
|
||||
* pipeline, compute descriptor sets, push constants and push descriptors. Bind calls are kept as
|
||||
* they were made (a later call that covers an earlier one replaces it) and replayed in order.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct bind_sets {
|
||||
VkPipelineLayout layout;
|
||||
uint32_t first, count, ndyn;
|
||||
VkDescriptorSet sets[32];
|
||||
uint32_t dyn[64];
|
||||
} bind_sets;
|
||||
|
||||
typedef struct push_consts {
|
||||
VkPipelineLayout layout;
|
||||
VkShaderStageFlags stages;
|
||||
uint32_t offset, size;
|
||||
uint8_t data[256];
|
||||
} push_consts;
|
||||
|
||||
typedef struct push_tmpl {
|
||||
VkDescriptorUpdateTemplate tmpl;
|
||||
VkPipelineLayout layout;
|
||||
uint32_t set;
|
||||
void *data;
|
||||
size_t size;
|
||||
} push_tmpl;
|
||||
|
||||
typedef struct cb_state {
|
||||
VkCommandBuffer cb;
|
||||
VkPipeline compute_pipeline;
|
||||
bind_sets *sets;
|
||||
uint32_t nsets, capsets;
|
||||
push_consts *pcs;
|
||||
uint32_t npcs, cappcs;
|
||||
push_tmpl *pts;
|
||||
uint32_t npts, cappts;
|
||||
void *gfx; /* graphics-side state (divisor emulation) */
|
||||
/* Descriptor sets emulations record with (no push descriptors), alive until the next begin. */
|
||||
VkDescriptorPool *scratch;
|
||||
uint32_t nscratch, cur_scratch, used_scratch;
|
||||
struct cb_state *next;
|
||||
} cb_state;
|
||||
|
||||
#define CB_BUCKETS 512
|
||||
#define SCRATCH_SETS 64
|
||||
typedef struct cmdstate {
|
||||
pthread_mutex_t lock;
|
||||
cb_state *b[CB_BUCKETS];
|
||||
} cmdstate;
|
||||
|
||||
/* Packed size of the template data being pushed (set by the raw push handler, server_misc.c). */
|
||||
__thread size_t vkb_emu_push_size;
|
||||
|
||||
static cmdstate *g_states_for(vkb_emu_device *e) { return (cmdstate *)e->cmdstate; }
|
||||
|
||||
static unsigned ch(VkCommandBuffer cb)
|
||||
{
|
||||
uint64_t k = (uint64_t)(uintptr_t)cb;
|
||||
k ^= k >> 30;
|
||||
k *= 0xbf58476d1ce4e5b9ull;
|
||||
return (unsigned)(k >> 55) & (CB_BUCKETS - 1);
|
||||
}
|
||||
|
||||
static cb_state *get(vkb_emu_device *e, VkCommandBuffer cb)
|
||||
{
|
||||
cmdstate *s = g_states_for(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
cb_state *c = s->b[ch(cb)];
|
||||
while (c && c->cb != cb) c = c->next;
|
||||
if (!c) {
|
||||
c = calloc(1, sizeof(*c));
|
||||
c->cb = cb;
|
||||
c->next = s->b[ch(cb)];
|
||||
s->b[ch(cb)] = c;
|
||||
}
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return c;
|
||||
}
|
||||
|
||||
/* A descriptor set of layout `dsl` (storage buffers and images only) for a command the emulation
|
||||
* records into cb; it lives until cb is begun again, when the app has seen the work finish. */
|
||||
VkDescriptorSet vkb_emu_cb_scratch_set(vkb_emu_device *e, VkCommandBuffer cb, VkDescriptorSetLayout dsl)
|
||||
{
|
||||
cb_state *c = get(e, cb);
|
||||
const vkb_dispatch *r = &e->dev->real;
|
||||
for (;;) {
|
||||
if (c->cur_scratch >= c->nscratch) {
|
||||
VkDescriptorPoolSize sizes[2] = {{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, SCRATCH_SETS * 2},
|
||||
{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, SCRATCH_SETS * 2}};
|
||||
VkDescriptorPoolCreateInfo pci = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, NULL, 0, SCRATCH_SETS, 2, sizes};
|
||||
VkDescriptorPool pool;
|
||||
VkDescriptorPool *np = realloc(c->scratch, (c->nscratch + 1) * sizeof(*np));
|
||||
if (!np) return VK_NULL_HANDLE;
|
||||
c->scratch = np;
|
||||
if (r->vkCreateDescriptorPool(e->dev->device, &pci, NULL, &pool) != VK_SUCCESS) return VK_NULL_HANDLE;
|
||||
c->scratch[c->nscratch++] = pool;
|
||||
}
|
||||
if (c->used_scratch < SCRATCH_SETS) {
|
||||
VkDescriptorSetAllocateInfo ai = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, NULL, c->scratch[c->cur_scratch], 1, &dsl};
|
||||
VkDescriptorSet set;
|
||||
if (r->vkAllocateDescriptorSets(e->dev->device, &ai, &set) == VK_SUCCESS) {
|
||||
c->used_scratch++;
|
||||
return set;
|
||||
}
|
||||
}
|
||||
c->cur_scratch++;
|
||||
c->used_scratch = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void *vkb_emu_cb_gfx(vkb_emu_device *e, VkCommandBuffer cb, size_t size)
|
||||
{
|
||||
cb_state *c = get(e, cb);
|
||||
if (!c->gfx) c->gfx = calloc(1, size);
|
||||
return c->gfx;
|
||||
}
|
||||
|
||||
static void reset(vkb_emu_device *e, cb_state *c)
|
||||
{
|
||||
for (uint32_t i = 0; i < c->nscratch && i <= c->cur_scratch; i++)
|
||||
e->dev->real.vkResetDescriptorPool(e->dev->device, c->scratch[i], 0);
|
||||
c->cur_scratch = 0;
|
||||
c->used_scratch = 0;
|
||||
c->compute_pipeline = VK_NULL_HANDLE;
|
||||
c->nsets = 0;
|
||||
c->npcs = 0;
|
||||
for (uint32_t i = 0; i < c->npts; i++) free(c->pts[i].data);
|
||||
c->npts = 0;
|
||||
vkb_emu_gfx_reset(c->gfx);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ wrappers */
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_BeginCommandBuffer(VkCommandBuffer cb, const VkCommandBufferBeginInfo *info)
|
||||
{
|
||||
reset(vkb_emu_cur(), get(vkb_emu_cur(), cb));
|
||||
return vkb_emu_real()->vkBeginCommandBuffer(cb, info);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindPipeline(VkCommandBuffer cb, VkPipelineBindPoint bp, VkPipeline p)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
if (bp == VK_PIPELINE_BIND_POINT_COMPUTE) get(e, cb)->compute_pipeline = p;
|
||||
if (bp == VK_PIPELINE_BIND_POINT_GRAPHICS) vkb_emu_gfx_bind_pipeline(e, cb, p);
|
||||
vkb_emu_real()->vkCmdBindPipeline(cb, bp, p);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindDescriptorSets(VkCommandBuffer cb, VkPipelineBindPoint bp, VkPipelineLayout layout,
|
||||
uint32_t first, uint32_t count, const VkDescriptorSet *sets,
|
||||
uint32_t ndyn, const uint32_t *dyn)
|
||||
{
|
||||
if (bp == VK_PIPELINE_BIND_POINT_COMPUTE && count <= 32 && ndyn <= 64) {
|
||||
cb_state *c = get(vkb_emu_cur(), cb);
|
||||
/* Drop earlier calls this one covers completely. */
|
||||
uint32_t k = 0;
|
||||
for (uint32_t i = 0; i < c->nsets; i++) {
|
||||
bind_sets *b = &c->sets[i];
|
||||
if (b->first >= first && b->first + b->count <= first + count) continue;
|
||||
c->sets[k++] = *b;
|
||||
}
|
||||
c->nsets = k;
|
||||
if (c->nsets == c->capsets) {
|
||||
c->capsets = c->capsets ? c->capsets * 2 : 8;
|
||||
c->sets = realloc(c->sets, c->capsets * sizeof(*c->sets));
|
||||
}
|
||||
bind_sets *b = &c->sets[c->nsets++];
|
||||
b->layout = layout;
|
||||
b->first = first;
|
||||
b->count = count;
|
||||
b->ndyn = ndyn;
|
||||
memcpy(b->sets, sets, count * sizeof(*sets));
|
||||
if (ndyn) memcpy(b->dyn, dyn, ndyn * sizeof(*dyn));
|
||||
}
|
||||
vkb_emu_real()->vkCmdBindDescriptorSets(cb, bp, layout, first, count, sets, ndyn, dyn);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdPushConstants(VkCommandBuffer cb, VkPipelineLayout layout, VkShaderStageFlags stages,
|
||||
uint32_t offset, uint32_t size, const void *data)
|
||||
{
|
||||
if ((stages & VK_SHADER_STAGE_COMPUTE_BIT) && offset + size <= 256) {
|
||||
cb_state *c = get(vkb_emu_cur(), cb);
|
||||
uint32_t k = 0;
|
||||
for (uint32_t i = 0; i < c->npcs; i++) {
|
||||
push_consts *p = &c->pcs[i];
|
||||
if (p->offset >= offset && p->offset + p->size <= offset + size && p->stages == stages) continue;
|
||||
c->pcs[k++] = *p;
|
||||
}
|
||||
c->npcs = k;
|
||||
if (c->npcs == c->cappcs) {
|
||||
c->cappcs = c->cappcs ? c->cappcs * 2 : 8;
|
||||
c->pcs = realloc(c->pcs, c->cappcs * sizeof(*c->pcs));
|
||||
}
|
||||
push_consts *p = &c->pcs[c->npcs++];
|
||||
p->layout = layout;
|
||||
p->stages = stages;
|
||||
p->offset = offset;
|
||||
p->size = size;
|
||||
memcpy(p->data + offset, data, size);
|
||||
}
|
||||
vkb_emu_real()->vkCmdPushConstants(cb, layout, stages, offset, size, data);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdPushDescriptorSetWithTemplate(VkCommandBuffer cb, VkDescriptorUpdateTemplate tmpl,
|
||||
VkPipelineLayout layout, uint32_t set, const void *data)
|
||||
{
|
||||
/* Only the template's bind point decides; recording it for both costs nothing when replayed
|
||||
* into the same bind point it was made for. Sizes are unknown here: the bridge's raw template
|
||||
* path hands over the packed size (vkb_emu_push_size). */
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
cb_state *c = get(e, cb);
|
||||
size_t size = vkb_emu_push_size;
|
||||
if (size && size < (1u << 20)) {
|
||||
if (c->npts == c->cappts) {
|
||||
c->cappts = c->cappts ? c->cappts * 2 : 4;
|
||||
c->pts = realloc(c->pts, c->cappts * sizeof(*c->pts));
|
||||
}
|
||||
push_tmpl *p = &c->pts[c->npts++];
|
||||
p->tmpl = tmpl;
|
||||
p->layout = layout;
|
||||
p->set = set;
|
||||
p->size = size;
|
||||
p->data = malloc(size);
|
||||
memcpy(p->data, data, size);
|
||||
}
|
||||
vkb_emu_real()->vkCmdPushDescriptorSetWithTemplate(cb, tmpl, layout, set, data);
|
||||
}
|
||||
|
||||
/* Puts back what the app had bound for compute after an emulation recorded its own dispatch. */
|
||||
void vkb_emu_restore_compute(vkb_emu_device *e, VkCommandBuffer cb)
|
||||
{
|
||||
cb_state *c = get(e, cb);
|
||||
const vkb_dispatch *r = vkb_emu_real();
|
||||
if (c->compute_pipeline) r->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_COMPUTE, c->compute_pipeline);
|
||||
for (uint32_t i = 0; i < c->nsets; i++) {
|
||||
bind_sets *b = &c->sets[i];
|
||||
r->vkCmdBindDescriptorSets(cb, VK_PIPELINE_BIND_POINT_COMPUTE, b->layout, b->first, b->count, b->sets, b->ndyn, b->dyn);
|
||||
}
|
||||
for (uint32_t i = 0; i < c->npts; i++) {
|
||||
push_tmpl *p = &c->pts[i];
|
||||
r->vkCmdPushDescriptorSetWithTemplate(cb, p->tmpl, p->layout, p->set, p->data);
|
||||
}
|
||||
for (uint32_t i = 0; i < c->npcs; i++) {
|
||||
push_consts *p = &c->pcs[i];
|
||||
r->vkCmdPushConstants(cb, p->layout, p->stages, p->offset, p->size, p->data + p->offset);
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_emu_cmdstate_install(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
cmdstate *s = calloc(1, sizeof(*s));
|
||||
pthread_mutex_init(&s->lock, NULL);
|
||||
e->cmdstate = s;
|
||||
dev->dt.vkBeginCommandBuffer = emu_BeginCommandBuffer;
|
||||
dev->dt.vkCmdBindPipeline = emu_CmdBindPipeline;
|
||||
dev->dt.vkCmdBindDescriptorSets = emu_CmdBindDescriptorSets;
|
||||
dev->dt.vkCmdPushConstants = emu_CmdPushConstants;
|
||||
if (dev->real.vkCmdPushDescriptorSetWithTemplate) dev->dt.vkCmdPushDescriptorSetWithTemplate = emu_CmdPushDescriptorSetWithTemplate;
|
||||
}
|
||||
|
||||
void vkb_emu_cmdstate_uninstall(vkb_srv_table *dev)
|
||||
{
|
||||
cmdstate *s = dev->emu->cmdstate;
|
||||
if (!s) return;
|
||||
for (int i = 0; i < CB_BUCKETS; i++) {
|
||||
while (s->b[i]) {
|
||||
cb_state *c = s->b[i];
|
||||
s->b[i] = c->next;
|
||||
reset(dev->emu, c);
|
||||
for (uint32_t j = 0; j < c->nscratch; j++) dev->real.vkDestroyDescriptorPool(dev->device, c->scratch[j], NULL);
|
||||
free(c->scratch);
|
||||
free(c->sets);
|
||||
free(c->pcs);
|
||||
free(c->pts);
|
||||
vkb_emu_gfx_free(c->gfx);
|
||||
free(c);
|
||||
}
|
||||
}
|
||||
pthread_mutex_destroy(&s->lock);
|
||||
free(s);
|
||||
dev->emu->cmdstate = NULL;
|
||||
}
|
||||
@@ -0,0 +1,454 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Vertex attribute divisor (VK_EXT/KHR_vertex_attribute_divisor) on a GPU without it.
|
||||
*
|
||||
* A binding with divisor d != 1 fetches element firstInstance + i / d for instance i (d = 0: always
|
||||
* firstInstance). Emulated by giving such bindings a stride of 0 - every instance reads the same
|
||||
* element - and rebinding the buffer at that element before each draw. With d > 1 the draw is
|
||||
* split into runs of instances that share elements; each run keeps its own firstInstance, so
|
||||
* gl_InstanceIndex and every ordinary instance-rate attribute stay exactly as they were.
|
||||
* Indirect draws cannot be split on the CPU: divisor-0 bindings use element 0 there, d > 1 is
|
||||
* approximated the same way (logged once).
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define MAX_BIND 32
|
||||
|
||||
typedef struct div_info {
|
||||
uint32_t mask; /* bindings emulated */
|
||||
uint32_t divisor[MAX_BIND];
|
||||
uint32_t stride[MAX_BIND]; /* the app's stride (baked pipelines) */
|
||||
int dynamic_stride; /* the pipeline takes strides at bind time */
|
||||
int dynamic_input; /* the pipeline takes vertex input at record time */
|
||||
int split; /* some divisor > 1: draws are split */
|
||||
VkPipeline zero_base; /* variant whose vertex shader reads BaseInstance as 0 */
|
||||
VkShaderModule zero_vs; /* its vertex shader, between creation steps */
|
||||
uint32_t vs_stage;
|
||||
} div_info;
|
||||
|
||||
typedef struct pipe_rec {
|
||||
VkPipeline p;
|
||||
div_info info;
|
||||
struct pipe_rec *next;
|
||||
} pipe_rec;
|
||||
|
||||
typedef struct gfx_state {
|
||||
VkPipeline pipeline; /* bound graphics pipeline */
|
||||
div_info pipe; /* the bound pipeline's */
|
||||
div_info dyn; /* from vkCmdSetVertexInputEXT */
|
||||
int use_dyn;
|
||||
VkBuffer buf[MAX_BIND];
|
||||
VkDeviceSize off[MAX_BIND], size[MAX_BIND], stride[MAX_BIND];
|
||||
uint32_t bound; /* slots the app bound */
|
||||
uint32_t tampered; /* slots we rebound */
|
||||
} gfx_state;
|
||||
|
||||
typedef struct div_state {
|
||||
pthread_mutex_t lock;
|
||||
pipe_rec *b[256];
|
||||
} div_state;
|
||||
|
||||
static div_state *dstate(vkb_emu_device *e) { return e->divisor; }
|
||||
|
||||
static unsigned ph(VkPipeline p)
|
||||
{
|
||||
uint64_t k = (uint64_t)p;
|
||||
k ^= k >> 33;
|
||||
k *= 0xff51afd7ed558ccdull;
|
||||
return (unsigned)(k >> 56);
|
||||
}
|
||||
|
||||
static const div_info *find_pipe(vkb_emu_device *e, VkPipeline p)
|
||||
{
|
||||
div_state *s = dstate(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
pipe_rec *r = s->b[ph(p)];
|
||||
while (r && r->p != p) r = r->next;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return r ? &r->info : NULL;
|
||||
}
|
||||
|
||||
static void store_pipe(vkb_emu_device *e, VkPipeline p, const div_info *info)
|
||||
{
|
||||
div_state *s = dstate(e);
|
||||
pipe_rec *r = calloc(1, sizeof(*r));
|
||||
r->p = p;
|
||||
r->info = *info;
|
||||
pthread_mutex_lock(&s->lock);
|
||||
r->next = s->b[ph(p)];
|
||||
s->b[ph(p)] = r;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
}
|
||||
|
||||
static void drop_pipe(vkb_emu_device *e, VkPipeline p)
|
||||
{
|
||||
div_state *s = dstate(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
pipe_rec **pp = &s->b[ph(p)];
|
||||
while (*pp && (*pp)->p != p) pp = &(*pp)->next;
|
||||
pipe_rec *r = *pp;
|
||||
if (r) *pp = r->next;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
if (r && r->info.zero_base) e->dev->real.vkDestroyPipeline(e->dev->device, r->info.zero_base, NULL);
|
||||
free(r);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ pipelines */
|
||||
|
||||
static int has_dynamic(const VkGraphicsPipelineCreateInfo *ci, VkDynamicState d)
|
||||
{
|
||||
if (!ci->pDynamicState) return 0;
|
||||
for (uint32_t i = 0; i < ci->pDynamicState->dynamicStateCount; i++)
|
||||
if (ci->pDynamicState->pDynamicStates[i] == d) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Strips the divisor state of one create info; returns what the pipeline needs at draw time. */
|
||||
void vkb_emu_divisor_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, div_info *out)
|
||||
{
|
||||
memset(out, 0, sizeof(*out));
|
||||
if (!(e->flags & VKB_EMU_DIVISOR)) return;
|
||||
out->dynamic_stride = has_dynamic(ci, VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE);
|
||||
out->dynamic_input = has_dynamic(ci, VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
|
||||
/* Pieces linked from libraries bring their own records. */
|
||||
for (const VkBaseInStructure *b = ci->pNext; b; b = b->pNext) {
|
||||
if (b->sType != VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR) continue;
|
||||
const VkPipelineLibraryCreateInfoKHR *l = (const void *)b;
|
||||
for (uint32_t i = 0; i < l->libraryCount; i++) {
|
||||
const div_info *li = find_pipe(e, l->pLibraries[i]);
|
||||
if (!li || !li->mask) continue;
|
||||
for (uint32_t k = 0; k < MAX_BIND; k++)
|
||||
if (li->mask & (1u << k)) {
|
||||
out->mask |= 1u << k;
|
||||
out->divisor[k] = li->divisor[k];
|
||||
out->stride[k] = li->stride[k];
|
||||
if (li->divisor[k] > 1) out->split = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
VkPipelineVertexInputStateCreateInfo *vi = (VkPipelineVertexInputStateCreateInfo *)ci->pVertexInputState;
|
||||
if (!vi || out->dynamic_input) return;
|
||||
VkPipelineVertexInputDivisorStateCreateInfo *d =
|
||||
vkb_emu_chain_take(vi, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO);
|
||||
if (!d) return;
|
||||
VkVertexInputBindingDescription *bd = (VkVertexInputBindingDescription *)vi->pVertexBindingDescriptions;
|
||||
for (uint32_t i = 0; i < d->vertexBindingDivisorCount; i++) {
|
||||
uint32_t b = d->pVertexBindingDivisors[i].binding, div = d->pVertexBindingDivisors[i].divisor;
|
||||
if (div == 1 || b >= MAX_BIND) continue;
|
||||
for (uint32_t k = 0; k < vi->vertexBindingDescriptionCount; k++) {
|
||||
if (bd[k].binding != b) continue;
|
||||
out->mask |= 1u << b;
|
||||
out->divisor[b] = div;
|
||||
out->stride[b] = bd[k].stride;
|
||||
if (div > 1) out->split = 1;
|
||||
bd[k].stride = 0;
|
||||
}
|
||||
}
|
||||
/* The vertex shader's SPIR-V is still at hand here (it may be inline). */
|
||||
if (out->split && ci->pStages) {
|
||||
for (uint32_t st = 0; st < ci->stageCount; st++) {
|
||||
if (ci->pStages[st].stage != VK_SHADER_STAGE_VERTEX_BIT) continue;
|
||||
out->zero_vs = vkb_emu_shader_zero_base_instance(e, device, &ci->pStages[st]);
|
||||
out->vs_stage = st;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_emu_divisor_created(vkb_emu_device *e, VkDevice device, VkPipelineCache cache, const VkGraphicsPipelineCreateInfo *ci,
|
||||
VkPipeline p, div_info *info)
|
||||
{
|
||||
if (!(e->flags & VKB_EMU_DIVISOR)) return;
|
||||
if (!p) {
|
||||
if (info->zero_vs) vkb_emu_real()->vkDestroyShaderModule(device, info->zero_vs, NULL);
|
||||
return;
|
||||
}
|
||||
if (info->zero_vs) {
|
||||
/* Split draws move BaseInstance: a variant that reads it as 0 serves the usual
|
||||
* firstInstance = 0 draws exactly. */
|
||||
VkPipelineShaderStageCreateInfo *st = malloc(ci->stageCount * sizeof(*st));
|
||||
memcpy(st, ci->pStages, ci->stageCount * sizeof(*st));
|
||||
st[info->vs_stage].module = info->zero_vs;
|
||||
st[info->vs_stage].pNext = NULL;
|
||||
VkGraphicsPipelineCreateInfo v = *ci;
|
||||
v.pStages = st;
|
||||
if (vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, 1, &v, NULL, &info->zero_base) != VK_SUCCESS)
|
||||
info->zero_base = VK_NULL_HANDLE;
|
||||
vkb_emu_real()->vkDestroyShaderModule(device, info->zero_vs, NULL);
|
||||
info->zero_vs = VK_NULL_HANDLE;
|
||||
free(st);
|
||||
}
|
||||
if (info->mask || info->dynamic_input || info->dynamic_stride) store_pipe(e, p, info);
|
||||
if (info->mask)
|
||||
VKB_DBG("divisor: pipeline %p emulates bindings 0x%x (dynamic stride %d, dynamic input %d, split %d, variant %p)", (void *)p,
|
||||
info->mask, info->dynamic_stride, info->dynamic_input, info->split, (void *)info->zero_base);
|
||||
}
|
||||
|
||||
size_t vkb_emu_divisor_info_size(void) { return sizeof(div_info); }
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_DestroyPipeline(VkDevice device, VkPipeline p, const VkAllocationCallbacks *pAllocator)
|
||||
{
|
||||
if (p) drop_pipe(vkb_emu_cur(), p);
|
||||
vkb_emu_real()->vkDestroyPipeline(device, p, pAllocator);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ command buffers */
|
||||
|
||||
static gfx_state *gfx(vkb_emu_device *e, VkCommandBuffer cb) { return vkb_emu_cb_gfx(e, cb, sizeof(gfx_state)); }
|
||||
|
||||
void vkb_emu_gfx_reset(void *g)
|
||||
{
|
||||
if (g) memset(g, 0, sizeof(gfx_state));
|
||||
}
|
||||
|
||||
void vkb_emu_gfx_free(void *g) { free(g); }
|
||||
|
||||
void vkb_emu_gfx_bind_pipeline(vkb_emu_device *e, VkCommandBuffer cb, VkPipeline p)
|
||||
{
|
||||
if (!(e->flags & VKB_EMU_DIVISOR)) return;
|
||||
gfx_state *g = gfx(e, cb);
|
||||
g->pipeline = p;
|
||||
const div_info *i = find_pipe(e, p);
|
||||
if (i) g->pipe = *i;
|
||||
else memset(&g->pipe, 0, sizeof(g->pipe));
|
||||
g->use_dyn = g->pipe.dynamic_input;
|
||||
}
|
||||
|
||||
static void record_bind(gfx_state *g, uint32_t first, uint32_t n, const VkBuffer *b, const VkDeviceSize *o, const VkDeviceSize *s,
|
||||
const VkDeviceSize *st)
|
||||
{
|
||||
for (uint32_t i = 0; i < n && first + i < MAX_BIND; i++) {
|
||||
uint32_t k = first + i;
|
||||
g->buf[k] = b[i];
|
||||
g->off[k] = o[i];
|
||||
g->size[k] = s ? s[i] : VK_WHOLE_SIZE;
|
||||
if (st) g->stride[k] = st[i];
|
||||
g->bound |= 1u << k;
|
||||
g->tampered &= ~(1u << k);
|
||||
}
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *b,
|
||||
const VkDeviceSize *o)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
record_bind(gfx(e, cb), first, n, b, o, NULL, NULL);
|
||||
vkb_emu_real()->vkCmdBindVertexBuffers(cb, first, n, b, o);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers2(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *b,
|
||||
const VkDeviceSize *o, const VkDeviceSize *s, const VkDeviceSize *st)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
record_bind(gfx(e, cb), first, n, b, o, s, st);
|
||||
vkb_emu_real()->vkCmdBindVertexBuffers2(cb, first, n, b, o, s, st);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdSetVertexInputEXT(VkCommandBuffer cb, uint32_t nb, const VkVertexInputBindingDescription2EXT *bd,
|
||||
uint32_t na, const VkVertexInputAttributeDescription2EXT *ad)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
gfx_state *g = gfx(e, cb);
|
||||
memset(&g->dyn, 0, sizeof(g->dyn));
|
||||
g->dyn.dynamic_stride = 1;
|
||||
g->dyn.dynamic_input = 1;
|
||||
VkVertexInputBindingDescription2EXT *w = (VkVertexInputBindingDescription2EXT *)bd;
|
||||
for (uint32_t i = 0; i < nb; i++) {
|
||||
uint32_t b = w[i].binding;
|
||||
if (w[i].inputRate != VK_VERTEX_INPUT_RATE_INSTANCE || w[i].divisor == 1 || b >= MAX_BIND) continue;
|
||||
g->dyn.mask |= 1u << b;
|
||||
g->dyn.divisor[b] = w[i].divisor;
|
||||
g->dyn.stride[b] = w[i].stride;
|
||||
g->stride[b] = w[i].stride;
|
||||
w[i].stride = 0;
|
||||
w[i].divisor = 1;
|
||||
}
|
||||
vkb_emu_real()->vkCmdSetVertexInputEXT(cb, nb, bd, na, ad);
|
||||
}
|
||||
|
||||
/* Rebinds the emulated bindings for instances starting at `inst` (relative to the draw), and puts
|
||||
* back any slot we changed that the current pipeline does not emulate. */
|
||||
static void prepare(vkb_emu_device *e, VkCommandBuffer cb, gfx_state *g, const div_info *di, uint32_t first_instance, uint32_t inst)
|
||||
{
|
||||
const vkb_dispatch *r = vkb_emu_real();
|
||||
for (uint32_t k = 0; k < MAX_BIND; k++) {
|
||||
uint32_t bit = 1u << k;
|
||||
if (!(g->bound & bit)) continue;
|
||||
if (di->mask & bit) {
|
||||
uint32_t d = di->divisor[k];
|
||||
VkDeviceSize stride = di->dynamic_input ? g->dyn.stride[k] : (di->dynamic_stride ? g->stride[k] : di->stride[k]);
|
||||
VkDeviceSize elem = (VkDeviceSize)first_instance + (d ? inst / d : 0);
|
||||
VkDeviceSize off = g->off[k] + elem * stride;
|
||||
if (di->dynamic_stride || di->dynamic_input) {
|
||||
VkDeviceSize size = g->size[k] == VK_WHOLE_SIZE ? VK_WHOLE_SIZE : (g->size[k] > elem * stride ? g->size[k] - elem * stride : 0);
|
||||
VkDeviceSize zero = 0;
|
||||
r->vkCmdBindVertexBuffers2(cb, k, 1, &g->buf[k], &off, size == VK_WHOLE_SIZE ? NULL : &size, &zero);
|
||||
} else {
|
||||
r->vkCmdBindVertexBuffers(cb, k, 1, &g->buf[k], &off);
|
||||
}
|
||||
g->tampered |= bit;
|
||||
} else if (g->tampered & bit) {
|
||||
if (di->dynamic_stride) {
|
||||
VkDeviceSize size = g->size[k];
|
||||
r->vkCmdBindVertexBuffers2(cb, k, 1, &g->buf[k], &g->off[k], size == VK_WHOLE_SIZE ? NULL : &size, &g->stride[k]);
|
||||
} else {
|
||||
r->vkCmdBindVertexBuffers(cb, k, 1, &g->buf[k], &g->off[k]);
|
||||
}
|
||||
g->tampered &= ~bit;
|
||||
}
|
||||
}
|
||||
(void)e;
|
||||
}
|
||||
|
||||
static const div_info *active(gfx_state *g)
|
||||
{
|
||||
return g->use_dyn ? &g->dyn : &g->pipe;
|
||||
}
|
||||
|
||||
/* The next instance where some emulated binding moves to its next element. */
|
||||
static uint32_t next_boundary(const div_info *di, uint32_t i, uint32_t count)
|
||||
{
|
||||
uint32_t next = count;
|
||||
for (uint32_t k = 0; k < MAX_BIND; k++) {
|
||||
if (!(di->mask & (1u << k)) || di->divisor[k] <= 1) continue;
|
||||
uint32_t d = di->divisor[k], nb = (i / d + 1) * d;
|
||||
if (nb < next) next = nb;
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
/* A split draw binds the BaseInstance-as-0 variant when that keeps it exact. */
|
||||
static int split_begin(vkb_emu_device *e, VkCommandBuffer cb, gfx_state *g, const div_info *di, uint32_t fi, uint32_t ic)
|
||||
{
|
||||
(void)e;
|
||||
if (!di->split || next_boundary(di, 0, ic) >= ic) return 0;
|
||||
if (fi == 0 && di->zero_base) {
|
||||
vkb_emu_real()->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, di->zero_base);
|
||||
return 1;
|
||||
}
|
||||
if (fi != 0) VKB_ONCE(VKB_LOG_WARN, "divisor emulation: a split draw with firstInstance > 0 may see SV_InstanceID offset (logged once)");
|
||||
(void)g;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void split_end(VkCommandBuffer cb, gfx_state *g, int variant)
|
||||
{
|
||||
if (variant) vkb_emu_real()->vkCmdBindPipeline(cb, VK_PIPELINE_BIND_POINT_GRAPHICS, g->pipeline);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdDraw(VkCommandBuffer cb, uint32_t vc, uint32_t ic, uint32_t fv, uint32_t fi)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
gfx_state *g = gfx(e, cb);
|
||||
const div_info *di = active(g);
|
||||
if (!di->mask && !g->tampered) {
|
||||
vkb_emu_real()->vkCmdDraw(cb, vc, ic, fv, fi);
|
||||
return;
|
||||
}
|
||||
VKB_DBG("divisor: draw %u instances from %u, bindings 0x%x (dyn %d), bound 0x%x", ic, fi, di->mask, g->use_dyn, g->bound);
|
||||
int variant = split_begin(e, cb, g, di, fi, ic);
|
||||
for (uint32_t i = 0; i < ic || (ic == 0 && i == 0);) {
|
||||
uint32_t end = next_boundary(di, i, ic);
|
||||
prepare(e, cb, g, di, fi, i);
|
||||
if (ic) vkb_emu_real()->vkCmdDraw(cb, vc, end - i, fv, fi + i);
|
||||
if (!ic) break;
|
||||
i = end;
|
||||
}
|
||||
split_end(cb, g, variant);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndexed(VkCommandBuffer cb, uint32_t xc, uint32_t ic, uint32_t fx, int32_t vo, uint32_t fi)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
gfx_state *g = gfx(e, cb);
|
||||
const div_info *di = active(g);
|
||||
if (!di->mask && !g->tampered) {
|
||||
vkb_emu_real()->vkCmdDrawIndexed(cb, xc, ic, fx, vo, fi);
|
||||
return;
|
||||
}
|
||||
int variant = split_begin(e, cb, g, di, fi, ic);
|
||||
for (uint32_t i = 0; i < ic || (ic == 0 && i == 0);) {
|
||||
uint32_t end = next_boundary(di, i, ic);
|
||||
prepare(e, cb, g, di, fi, i);
|
||||
if (ic) vkb_emu_real()->vkCmdDrawIndexed(cb, xc, end - i, fx, vo, fi + i);
|
||||
if (!ic) break;
|
||||
i = end;
|
||||
}
|
||||
split_end(cb, g, variant);
|
||||
}
|
||||
|
||||
static void indirect_prepare(vkb_emu_device *e, VkCommandBuffer cb)
|
||||
{
|
||||
gfx_state *g = gfx(e, cb);
|
||||
const div_info *di = active(g);
|
||||
if (!di->mask && !g->tampered) return;
|
||||
for (uint32_t k = 0; k < MAX_BIND; k++)
|
||||
if ((di->mask & (1u << k)) && di->divisor[k] > 1)
|
||||
VKB_ONCE(VKB_LOG_WARN, "divisor emulation: an indirect draw with an instance divisor > 1 is approximated (logged once)");
|
||||
prepare(e, cb, g, di, 0, 0);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndirect(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, uint32_t n, uint32_t s)
|
||||
{
|
||||
indirect_prepare(vkb_emu_cur(), cb);
|
||||
vkb_emu_real()->vkCmdDrawIndirect(cb, b, o, n, s);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndexedIndirect(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, uint32_t n, uint32_t s)
|
||||
{
|
||||
indirect_prepare(vkb_emu_cur(), cb);
|
||||
vkb_emu_real()->vkCmdDrawIndexedIndirect(cb, b, o, n, s);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndirectCount(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, VkBuffer cbuf, VkDeviceSize co,
|
||||
uint32_t max, uint32_t s)
|
||||
{
|
||||
indirect_prepare(vkb_emu_cur(), cb);
|
||||
vkb_emu_real()->vkCmdDrawIndirectCount(cb, b, o, cbuf, co, max, s);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdDrawIndexedIndirectCount(VkCommandBuffer cb, VkBuffer b, VkDeviceSize o, VkBuffer cbuf,
|
||||
VkDeviceSize co, uint32_t max, uint32_t s)
|
||||
{
|
||||
indirect_prepare(vkb_emu_cur(), cb);
|
||||
vkb_emu_real()->vkCmdDrawIndexedIndirectCount(cb, b, o, cbuf, co, max, s);
|
||||
}
|
||||
|
||||
void vkb_emu_divisor_install(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
if (!(e->flags & VKB_EMU_DIVISOR)) return;
|
||||
div_state *s = calloc(1, sizeof(*s));
|
||||
pthread_mutex_init(&s->lock, NULL);
|
||||
e->divisor = s;
|
||||
vkb_dispatch *dt = &dev->dt;
|
||||
dt->vkDestroyPipeline = emu_DestroyPipeline;
|
||||
dt->vkCmdBindVertexBuffers = emu_CmdBindVertexBuffers;
|
||||
if (dev->real.vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = emu_CmdBindVertexBuffers2;
|
||||
if (dev->real.vkCmdSetVertexInputEXT) dt->vkCmdSetVertexInputEXT = emu_CmdSetVertexInputEXT;
|
||||
dt->vkCmdDraw = emu_CmdDraw;
|
||||
dt->vkCmdDrawIndexed = emu_CmdDrawIndexed;
|
||||
dt->vkCmdDrawIndirect = emu_CmdDrawIndirect;
|
||||
dt->vkCmdDrawIndexedIndirect = emu_CmdDrawIndexedIndirect;
|
||||
if (dev->real.vkCmdDrawIndirectCount) dt->vkCmdDrawIndirectCount = emu_CmdDrawIndirectCount;
|
||||
if (dev->real.vkCmdDrawIndexedIndirectCount) dt->vkCmdDrawIndexedIndirectCount = emu_CmdDrawIndexedIndirectCount;
|
||||
}
|
||||
|
||||
void vkb_emu_divisor_uninstall(vkb_srv_table *dev)
|
||||
{
|
||||
div_state *s = dev->emu->divisor;
|
||||
if (!s) return;
|
||||
for (int i = 0; i < 256; i++) {
|
||||
while (s->b[i]) {
|
||||
pipe_rec *r = s->b[i];
|
||||
s->b[i] = r->next;
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
pthread_mutex_destroy(&s->lock);
|
||||
free(s);
|
||||
dev->emu->divisor = NULL;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Installs the feature emulations into a device.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
|
||||
void vkb_emu_install_features(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_cmdstate_install(dev);
|
||||
vkb_emu_shader_install(dev);
|
||||
vkb_emu_bcn_install(dev);
|
||||
vkb_emu_divisor_install(dev);
|
||||
}
|
||||
|
||||
void vkb_emu_uninstall_features(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_divisor_uninstall(dev);
|
||||
vkb_emu_bcn_uninstall(dev);
|
||||
vkb_emu_shader_uninstall(dev);
|
||||
vkb_emu_cmdstate_uninstall(dev);
|
||||
}
|
||||
@@ -0,0 +1,478 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Emulation wrappers installed into a device's dispatch table, like a Vulkan layer: the generated
|
||||
* handlers call c->dt, which for an emulating device points here first. The device is found
|
||||
* through the per-call table the connection loop sets (vkb_srv_current_table).
|
||||
*
|
||||
* VK_KHR_maintenance5 (Zink and DXVK 2.7 refuse a Vulkan 1.3 device without it):
|
||||
* - 64-bit flags structures (pipeline create flags 2, buffer usage 2) folded into the 32-bit
|
||||
* fields, which hold every bit a 1.3 driver knows;
|
||||
* - shader modules given inline (VkShaderModuleCreateInfo chained to a stage) created and
|
||||
* destroyed around the pipeline;
|
||||
* - vkCmdBindIndexBuffer2, vkGetRenderingAreaGranularity, vkGetImageSubresourceLayout2 and
|
||||
* vkGetDeviceImageSubresourceLayout on their 1.0 equivalents;
|
||||
* - VK_REMAINING_ARRAY_LAYERS in copy regions and VK_WHOLE_SIZE in vertex buffer sizes, resolved
|
||||
* from the image/buffer the server keeps a record of.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* ------------------------------------------------------------------ resource records */
|
||||
|
||||
static unsigned rh(uint64_t k)
|
||||
{
|
||||
k ^= k >> 29;
|
||||
k *= 0xbf58476d1ce4e5b9ull;
|
||||
return (unsigned)(k >> 52) & (VKB_EMU_BUCKETS - 1);
|
||||
}
|
||||
|
||||
void vkb_emu_track_image(vkb_emu_device *e, VkImage img, const VkImageCreateInfo *ci, VkFormat client_format)
|
||||
{
|
||||
vkb_emu_image *r = calloc(1, sizeof(*r));
|
||||
r->image = img;
|
||||
r->type = ci->imageType;
|
||||
r->format = ci->format;
|
||||
r->client_format = client_format;
|
||||
r->extent = ci->extent;
|
||||
r->mips = ci->mipLevels;
|
||||
r->layers = ci->arrayLayers;
|
||||
pthread_mutex_lock(&e->lock);
|
||||
unsigned h = rh((uint64_t)img);
|
||||
r->next = e->images[h];
|
||||
e->images[h] = r;
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
}
|
||||
|
||||
vkb_emu_image *vkb_emu_find_image(vkb_emu_device *e, VkImage img)
|
||||
{
|
||||
pthread_mutex_lock(&e->lock);
|
||||
vkb_emu_image *r = e->images[rh((uint64_t)img)];
|
||||
while (r && r->image != img) r = r->next;
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void untrack_image(vkb_emu_device *e, VkImage img)
|
||||
{
|
||||
pthread_mutex_lock(&e->lock);
|
||||
vkb_emu_image **pp = &e->images[rh((uint64_t)img)];
|
||||
while (*pp && (*pp)->image != img) pp = &(*pp)->next;
|
||||
vkb_emu_image *r = *pp;
|
||||
if (r) *pp = r->next;
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
if (r) {
|
||||
vkb_emu_image_release(e, r);
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
|
||||
static void track_buffer(vkb_emu_device *e, VkBuffer b, VkDeviceSize size)
|
||||
{
|
||||
vkb_emu_buffer *r = calloc(1, sizeof(*r));
|
||||
r->buffer = b;
|
||||
r->size = size;
|
||||
pthread_mutex_lock(&e->lock);
|
||||
unsigned h = rh((uint64_t)b);
|
||||
r->next = e->buffers[h];
|
||||
e->buffers[h] = r;
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
}
|
||||
|
||||
static VkDeviceSize buffer_size(vkb_emu_device *e, VkBuffer b)
|
||||
{
|
||||
pthread_mutex_lock(&e->lock);
|
||||
vkb_emu_buffer *r = e->buffers[rh((uint64_t)b)];
|
||||
while (r && r->buffer != b) r = r->next;
|
||||
VkDeviceSize s = r ? r->size : 0;
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
return s;
|
||||
}
|
||||
|
||||
static void untrack_buffer(vkb_emu_device *e, VkBuffer b)
|
||||
{
|
||||
pthread_mutex_lock(&e->lock);
|
||||
vkb_emu_buffer **pp = &e->buffers[rh((uint64_t)b)];
|
||||
while (*pp && (*pp)->buffer != b) pp = &(*pp)->next;
|
||||
vkb_emu_buffer *r = *pp;
|
||||
if (r) *pp = r->next;
|
||||
pthread_mutex_unlock(&e->lock);
|
||||
free(r);
|
||||
}
|
||||
|
||||
vkb_emu_device *vkb_emu_cur(void)
|
||||
{
|
||||
vkb_srv_table *t = vkb_srv_current_table();
|
||||
return t ? t->emu : NULL;
|
||||
}
|
||||
|
||||
const vkb_dispatch *vkb_emu_real(void)
|
||||
{
|
||||
return &vkb_srv_current_table()->real;
|
||||
}
|
||||
|
||||
/* Removes the first structure of type t from a chain we own (decoded into the call's arena). */
|
||||
void *vkb_emu_chain_take(const void *head_const, VkStructureType t)
|
||||
{
|
||||
VkBaseOutStructure *prev = (VkBaseOutStructure *)head_const;
|
||||
while (prev->pNext) {
|
||||
if (prev->pNext->sType == t) {
|
||||
VkBaseOutStructure *found = prev->pNext;
|
||||
prev->pNext = found->pNext;
|
||||
return found;
|
||||
}
|
||||
prev = prev->pNext;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ resources */
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
|
||||
const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
VkBufferCreateInfo *ci = (VkBufferCreateInfo *)pCreateInfo;
|
||||
if (e->flags & VKB_EMU_MAINT5) {
|
||||
VkBufferUsageFlags2CreateInfo *u = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
|
||||
if (u) ci->usage = (VkBufferUsageFlags)u->usage;
|
||||
}
|
||||
vkb_emu_bcn_buffer_usage(e, ci);
|
||||
VkResult r = vkb_emu_real()->vkCreateBuffer(device, ci, pAllocator, pBuffer);
|
||||
if (r == VK_SUCCESS) track_buffer(e, *pBuffer, ci->size);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
|
||||
{
|
||||
if (buffer) untrack_buffer(vkb_emu_cur(), buffer);
|
||||
vkb_emu_real()->vkDestroyBuffer(device, buffer, pAllocator);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
|
||||
const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
|
||||
{
|
||||
if (vkb_emu_cur()->flags & VKB_EMU_MAINT5) vkb_emu_chain_take(pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO);
|
||||
return vkb_emu_real()->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
|
||||
const VkAllocationCallbacks *pAllocator, VkImage *pImage)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
VkImageCreateInfo *ci = (VkImageCreateInfo *)pCreateInfo;
|
||||
VkFormat client_format = ci->format;
|
||||
vkb_emu_image_create_info(e, ci);
|
||||
VkResult r = vkb_emu_real()->vkCreateImage(device, ci, pAllocator, pImage);
|
||||
if (r == VK_SUCCESS) vkb_emu_track_image(e, *pImage, ci, client_format);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
|
||||
{
|
||||
if (image) untrack_image(vkb_emu_cur(), image);
|
||||
vkb_emu_real()->vkDestroyImage(device, image, pAllocator);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ pipelines */
|
||||
|
||||
/* Fold flags2 and create inline shader modules; temporaries are recorded in mods[]. */
|
||||
static void prep_stage(VkDevice device, VkPipelineShaderStageCreateInfo *st, VkShaderModule *mods, uint32_t *nmods, uint32_t cap)
|
||||
{
|
||||
if (st->module) return;
|
||||
VkShaderModuleCreateInfo *smci = vkb_emu_chain_take(st, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
|
||||
if (!smci) return;
|
||||
VkShaderModule m = VK_NULL_HANDLE;
|
||||
smci->pNext = NULL;
|
||||
if (vkb_emu_real()->vkCreateShaderModule(device, smci, NULL, &m) == VK_SUCCESS) {
|
||||
st->module = m;
|
||||
if (*nmods < cap) mods[(*nmods)++] = m;
|
||||
}
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
|
||||
const VkGraphicsPipelineCreateInfo *infos,
|
||||
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
VkShaderModule mods[64];
|
||||
uint32_t nmods = 0;
|
||||
size_t dsz = vkb_emu_divisor_info_size();
|
||||
uint8_t *divs = calloc(n ? n : 1, dsz);
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
VkGraphicsPipelineCreateInfo *ci = (VkGraphicsPipelineCreateInfo *)&infos[i];
|
||||
vkb_emu_divisor_pipeline(e, device, ci, (div_info *)(divs + i * dsz));
|
||||
vkb_emu_depth_clip_pipeline(e, ci);
|
||||
/* Shader rewrites first: they read inline SPIR-V before it becomes a module. */
|
||||
vkb_emu_shader_pipeline(e, device, ci, mods, &nmods, 64);
|
||||
if (e->flags & VKB_EMU_MAINT5) {
|
||||
VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
|
||||
if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags;
|
||||
for (uint32_t s = 0; s < ci->stageCount; s++)
|
||||
prep_stage(device, (VkPipelineShaderStageCreateInfo *)&ci->pStages[s], mods, &nmods, 64);
|
||||
}
|
||||
}
|
||||
VkResult r = vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, n, infos, pAllocator, pPipelines);
|
||||
/* Before the temporary modules go: a divisor variant is built from the same stages. */
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
vkb_emu_divisor_created(e, device, cache, &infos[i], r >= 0 ? pPipelines[i] : VK_NULL_HANDLE, (div_info *)(divs + i * dsz));
|
||||
for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL);
|
||||
free(divs);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateComputePipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
|
||||
const VkComputePipelineCreateInfo *infos,
|
||||
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
VkShaderModule mods[64];
|
||||
uint32_t nmods = 0;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
VkComputePipelineCreateInfo *ci = (VkComputePipelineCreateInfo *)&infos[i];
|
||||
if (e->flags & VKB_EMU_MAINT5) {
|
||||
VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO);
|
||||
if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags;
|
||||
prep_stage(device, &ci->stage, mods, &nmods, 64);
|
||||
}
|
||||
}
|
||||
VkResult r = vkb_emu_real()->vkCreateComputePipelines(device, cache, n, infos, pAllocator, pPipelines);
|
||||
for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL);
|
||||
return r;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ maintenance5 entry points */
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindIndexBuffer2(VkCommandBuffer cb, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
|
||||
VkIndexType type)
|
||||
{
|
||||
(void)size;
|
||||
vkb_emu_real()->vkCmdBindIndexBuffer(cb, buffer, offset, type);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo *info, VkExtent2D *g)
|
||||
{
|
||||
(void)device;
|
||||
(void)info;
|
||||
g->width = 1;
|
||||
g->height = 1;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_GetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2 *sub,
|
||||
VkSubresourceLayout2 *layout)
|
||||
{
|
||||
vkb_emu_real()->vkGetImageSubresourceLayout(device, image, &sub->imageSubresource, &layout->subresourceLayout);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo *info,
|
||||
VkSubresourceLayout2 *layout)
|
||||
{
|
||||
VkImage img;
|
||||
memset(&layout->subresourceLayout, 0, sizeof(layout->subresourceLayout));
|
||||
if (vkb_emu_real()->vkCreateImage(device, info->pCreateInfo, NULL, &img) != VK_SUCCESS) return;
|
||||
vkb_emu_real()->vkGetImageSubresourceLayout(device, img, &info->pSubresource->imageSubresource, &layout->subresourceLayout);
|
||||
vkb_emu_real()->vkDestroyImage(device, img, NULL);
|
||||
}
|
||||
|
||||
/* VK_REMAINING_ARRAY_LAYERS in a copy region, resolved against the image. */
|
||||
static void fix_layers(vkb_emu_device *e, VkImage img, VkImageSubresourceLayers *l)
|
||||
{
|
||||
if (l->layerCount != VK_REMAINING_ARRAY_LAYERS) return;
|
||||
vkb_emu_image *r = vkb_emu_find_image(e, img);
|
||||
l->layerCount = r && r->layers > l->baseArrayLayer ? r->layers - l->baseArrayLayer : 1;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
|
||||
uint32_t n, const VkImageCopy *regions)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].srcSubresource);
|
||||
fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].dstSubresource);
|
||||
}
|
||||
if (vkb_emu_copy_image(e, cb, src, sl, dst, dl, n, regions)) return;
|
||||
vkb_emu_real()->vkCmdCopyImage(cb, src, sl, dst, dl, n, regions);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImage2(VkCommandBuffer cb, const VkCopyImageInfo2 *info)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < info->regionCount; i++) {
|
||||
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource);
|
||||
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource);
|
||||
}
|
||||
if (vkb_emu_copy_image2(e, cb, info)) return;
|
||||
vkb_emu_real()->vkCmdCopyImage2(cb, info);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBlitImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
|
||||
uint32_t n, const VkImageBlit *regions, VkFilter filter)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].srcSubresource);
|
||||
fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].dstSubresource);
|
||||
}
|
||||
vkb_emu_real()->vkCmdBlitImage(cb, src, sl, dst, dl, n, regions, filter);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBlitImage2(VkCommandBuffer cb, const VkBlitImageInfo2 *info)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < info->regionCount; i++) {
|
||||
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource);
|
||||
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource);
|
||||
}
|
||||
vkb_emu_real()->vkCmdBlitImage2(cb, info);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdResolveImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl,
|
||||
uint32_t n, const VkImageResolve *regions)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].srcSubresource);
|
||||
fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].dstSubresource);
|
||||
}
|
||||
vkb_emu_real()->vkCmdResolveImage(cb, src, sl, dst, dl, n, regions);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdResolveImage2(VkCommandBuffer cb, const VkResolveImageInfo2 *info)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < info->regionCount; i++) {
|
||||
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource);
|
||||
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource);
|
||||
}
|
||||
vkb_emu_real()->vkCmdResolveImage2(cb, info);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyBufferToImage(VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n,
|
||||
const VkBufferImageCopy *regions)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < n; i++) fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].imageSubresource);
|
||||
if (vkb_emu_copy_buffer_to_image(e, cb, src, dst, dl, n, regions)) return;
|
||||
vkb_emu_real()->vkCmdCopyBufferToImage(cb, src, dst, dl, n, regions);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyBufferToImage2(VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < info->regionCount; i++)
|
||||
fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource);
|
||||
if (vkb_emu_copy_buffer_to_image2(e, cb, info)) return;
|
||||
vkb_emu_real()->vkCmdCopyBufferToImage2(cb, info);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkBuffer dst, uint32_t n,
|
||||
const VkBufferImageCopy *regions)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < n; i++) fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].imageSubresource);
|
||||
if (vkb_emu_bcn_blocks_readback(e, src)) return;
|
||||
vkb_emu_real()->vkCmdCopyImageToBuffer(cb, src, sl, dst, n, regions);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer2(VkCommandBuffer cb, const VkCopyImageToBufferInfo2 *info)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
for (uint32_t i = 0; i < info->regionCount; i++)
|
||||
fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource);
|
||||
if (vkb_emu_bcn_blocks_readback(e, info->srcImage)) return;
|
||||
vkb_emu_real()->vkCmdCopyImageToBuffer2(cb, info);
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers2(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *buffers,
|
||||
const VkDeviceSize *offsets, const VkDeviceSize *sizes,
|
||||
const VkDeviceSize *strides)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
if (sizes) {
|
||||
VkDeviceSize *s = (VkDeviceSize *)sizes;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
if (s[i] != VK_WHOLE_SIZE || !buffers[i]) continue;
|
||||
VkDeviceSize total = buffer_size(e, buffers[i]);
|
||||
s[i] = total > offsets[i] ? total - offsets[i] : 0;
|
||||
}
|
||||
}
|
||||
vkb_emu_real()->vkCmdBindVertexBuffers2(cb, first, n, buffers, offsets, sizes, strides);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ install */
|
||||
|
||||
void vkb_emu_install(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
vkb_dispatch *dt = &dev->dt;
|
||||
/* Resource records are needed by every emulation. */
|
||||
dt->vkCreateBuffer = emu_CreateBuffer;
|
||||
dt->vkDestroyBuffer = emu_DestroyBuffer;
|
||||
dt->vkCreateImage = emu_CreateImage;
|
||||
dt->vkDestroyImage = emu_DestroyImage;
|
||||
dt->vkCreateGraphicsPipelines = emu_CreateGraphicsPipelines;
|
||||
dt->vkCreateComputePipelines = emu_CreateComputePipelines;
|
||||
dt->vkCmdCopyImage = emu_CmdCopyImage;
|
||||
dt->vkCmdCopyBufferToImage = emu_CmdCopyBufferToImage;
|
||||
if (dev->real.vkCmdCopyImage2) dt->vkCmdCopyImage2 = emu_CmdCopyImage2;
|
||||
if (dev->real.vkCmdCopyBufferToImage2) dt->vkCmdCopyBufferToImage2 = emu_CmdCopyBufferToImage2;
|
||||
dt->vkCmdCopyImageToBuffer = emu_CmdCopyImageToBuffer;
|
||||
if (dev->real.vkCmdCopyImageToBuffer2) dt->vkCmdCopyImageToBuffer2 = emu_CmdCopyImageToBuffer2;
|
||||
if (e->flags & VKB_EMU_MAINT5) {
|
||||
dt->vkCreateBufferView = emu_CreateBufferView;
|
||||
dt->vkCmdBindIndexBuffer2 = emu_CmdBindIndexBuffer2;
|
||||
dt->vkGetRenderingAreaGranularity = emu_GetRenderingAreaGranularity;
|
||||
dt->vkGetImageSubresourceLayout2 = emu_GetImageSubresourceLayout2;
|
||||
dt->vkGetDeviceImageSubresourceLayout = emu_GetDeviceImageSubresourceLayout;
|
||||
dt->vkCmdBlitImage = emu_CmdBlitImage;
|
||||
dt->vkCmdResolveImage = emu_CmdResolveImage;
|
||||
if (dev->real.vkCmdBlitImage2) dt->vkCmdBlitImage2 = emu_CmdBlitImage2;
|
||||
if (dev->real.vkCmdResolveImage2) dt->vkCmdResolveImage2 = emu_CmdResolveImage2;
|
||||
if (dev->real.vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = emu_CmdBindVertexBuffers2;
|
||||
}
|
||||
vkb_emu_install_features(dev);
|
||||
vkb_emu_depth_clip_install(dev);
|
||||
VKB_INFO("device %u: emulation 0x%x installed", dev->id, e->flags);
|
||||
}
|
||||
|
||||
void vkb_emu_uninstall(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
vkb_emu_uninstall_features(dev);
|
||||
for (int i = 0; i < VKB_EMU_BUCKETS; i++) {
|
||||
while (e->images[i]) {
|
||||
vkb_emu_image *r = e->images[i];
|
||||
e->images[i] = r->next;
|
||||
vkb_emu_image_release(e, r);
|
||||
free(r);
|
||||
}
|
||||
while (e->buffers[i]) {
|
||||
vkb_emu_buffer *r = e->buffers[i];
|
||||
e->buffers[i] = r->next;
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ depth clip enable */
|
||||
|
||||
/* VK_EXT_depth_clip_enable on a GPU without it. Without the extension Vulkan clips exactly when
|
||||
* depth clamp is off, so a pipeline's clamp becomes "not clip" (D3D's DepthClipEnable = FALSE is
|
||||
* clamping; clip + clamp only differs for fragments the clip removes anyway). The client hides
|
||||
* dynamic depth clip/clamp while this is emulated, so both are static pipeline state here. */
|
||||
void vkb_emu_depth_clip_pipeline(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci)
|
||||
{
|
||||
if (!(e->flags & VKB_EMU_DEPTH_CLIP)) return;
|
||||
VkPipelineRasterizationStateCreateInfo *rs = (VkPipelineRasterizationStateCreateInfo *)ci->pRasterizationState;
|
||||
if (!rs) return;
|
||||
VkPipelineRasterizationDepthClipStateCreateInfoEXT *dc =
|
||||
vkb_emu_chain_take(rs, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT);
|
||||
if (dc) rs->depthClampEnable = dc->depthClipEnable ? VK_FALSE : VK_TRUE;
|
||||
}
|
||||
|
||||
void vkb_emu_depth_clip_install(vkb_srv_table *dev)
|
||||
{
|
||||
(void)dev;
|
||||
}
|
||||
@@ -0,0 +1,429 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Shader-side emulations, done when a graphics pipeline is created (both ends of the vertex ->
|
||||
* fragment interface are known then):
|
||||
*
|
||||
* clip distance (shaderClipDistance missing): the last pre-rasterization stage's ClipDistance
|
||||
* output becomes an ordinary varying at a free location; the fragment shader reads it and
|
||||
* discards the fragment when any distance is negative. For planar clip distances this is the
|
||||
* same set of pixels the hardware clipper would keep.
|
||||
* cull distance (shaderCullDistance missing): the output becomes an unread varying - nothing is
|
||||
* culled, which costs fragments but never drops geometry that should be visible.
|
||||
* point size in geometry/tessellation (shaderTessellationAndGeometryPointSize missing): same.
|
||||
*
|
||||
* Shader modules are kept as SPIR-V so a pipeline can build rewritten variants; the driver's own
|
||||
* module is created from a variant that needs none of the missing features.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "server_emu.h"
|
||||
#include "spirv_edit.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
typedef struct shader_rec {
|
||||
VkShaderModule module;
|
||||
uint32_t *code;
|
||||
size_t size;
|
||||
struct shader_rec *next;
|
||||
} shader_rec;
|
||||
|
||||
typedef struct shader_state {
|
||||
pthread_mutex_t lock;
|
||||
shader_rec *mods[1024];
|
||||
} shader_state;
|
||||
|
||||
#define SHADER_EMU (VKB_EMU_CLIP_DISTANCE | VKB_EMU_CULL_DISTANCE | VKB_EMU_POINT_SIZE)
|
||||
/* Emulations that need the shader modules' SPIR-V kept. */
|
||||
#define SHADER_STORE (SHADER_EMU | VKB_EMU_DIVISOR)
|
||||
|
||||
static unsigned mh(VkShaderModule m)
|
||||
{
|
||||
uint64_t k = (uint64_t)m;
|
||||
k ^= k >> 31;
|
||||
k *= 0x94d049bb133111ebull;
|
||||
return (unsigned)(k >> 54);
|
||||
}
|
||||
|
||||
static shader_state *state(vkb_emu_device *e) { return e->shaders; }
|
||||
|
||||
static const shader_rec *find_module(vkb_emu_device *e, VkShaderModule m)
|
||||
{
|
||||
shader_state *s = state(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
shader_rec *r = s->mods[mh(m)];
|
||||
while (r && r->module != m) r = r->next;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ rewrites */
|
||||
|
||||
/* Finds a standalone Output/Input variable decorated with a builtin; 0 if none. 2 = in a block. */
|
||||
static uint32_t builtin_var(const spv_mod *m, uint32_t builtin, uint32_t storage, int *in_block)
|
||||
{
|
||||
*in_block = 0;
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op == SpvOpDecorate && in->w[1] == SpvDecorationBuiltIn && in->w[2] == builtin) {
|
||||
int d = spv_find_def(m, in->w[0]);
|
||||
if (d >= 0 && m->ins[d].op == SpvOpVariable && m->ins[d].w[2] == storage) return in->w[0];
|
||||
}
|
||||
if (in->op == SpvOpMemberDecorate && in->w[2] == SpvDecorationBuiltIn && in->w[3] == builtin) *in_block = 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint32_t var_pointee(const spv_mod *m, uint32_t var)
|
||||
{
|
||||
int d = spv_find_def(m, var);
|
||||
if (d < 0) return 0;
|
||||
int p = spv_find_def(m, m->ins[d].w[0]);
|
||||
return p < 0 ? 0 : m->ins[p].w[2];
|
||||
}
|
||||
|
||||
static void add_decoration(spv_mod *m, uint32_t id, uint32_t dec, uint32_t value)
|
||||
{
|
||||
uint32_t ops[3] = {id, dec, value};
|
||||
spv_insert(m, spv_annotations_end(m), SpvOpDecorate, ops, 3);
|
||||
}
|
||||
|
||||
/* Builtin output -> plain varying at *loc (advanced). Returns the element count, 0 if absent. */
|
||||
static uint32_t demote_builtin(spv_mod *m, uint32_t builtin, uint32_t *loc, int *unsupported)
|
||||
{
|
||||
int in_block;
|
||||
uint32_t var = builtin_var(m, builtin, SpvStorageClassOutput, &in_block);
|
||||
if (!var) {
|
||||
if (in_block) *unsupported = 1;
|
||||
return 0;
|
||||
}
|
||||
uint32_t pointee = var_pointee(m, var);
|
||||
uint32_t n = spv_array_length(m, pointee);
|
||||
if (!n) n = 1;
|
||||
spv_remove_decoration(m, var, SpvDecorationBuiltIn);
|
||||
add_decoration(m, var, SpvDecorationLocation, *loc);
|
||||
*loc += n;
|
||||
return n;
|
||||
}
|
||||
|
||||
/* The pre-rasterization side. Returns the clip distance count (0: none), -1 if it cannot. */
|
||||
static int rewrite_pre_raster(spv_mod *m, uint32_t emu, uint32_t clip_loc, int last_stage)
|
||||
{
|
||||
int unsupported = 0;
|
||||
uint32_t loc = clip_loc;
|
||||
int clip = 0;
|
||||
if ((emu & VKB_EMU_CLIP_DISTANCE) && spv_has_capability(m, SpvCapabilityClipDistance)) {
|
||||
clip = (int)demote_builtin(m, SpvBuiltInClipDistance, &loc, &unsupported);
|
||||
spv_remove_capability(m, SpvCapabilityClipDistance);
|
||||
}
|
||||
if ((emu & VKB_EMU_CULL_DISTANCE) && spv_has_capability(m, SpvCapabilityCullDistance)) {
|
||||
demote_builtin(m, SpvBuiltInCullDistance, &loc, &unsupported);
|
||||
spv_remove_capability(m, SpvCapabilityCullDistance);
|
||||
}
|
||||
int model = spv_execution_model(m);
|
||||
if ((emu & VKB_EMU_POINT_SIZE) && (model == SpvExecutionModelGeometry || model == SpvExecutionModelTessellationEvaluation) &&
|
||||
(spv_has_capability(m, SpvCapabilityGeometryPointSize) || spv_has_capability(m, SpvCapabilityTessellationPointSize))) {
|
||||
demote_builtin(m, SpvBuiltInPointSize, &loc, &unsupported);
|
||||
spv_remove_capability(m, SpvCapabilityGeometryPointSize);
|
||||
spv_remove_capability(m, SpvCapabilityTessellationPointSize);
|
||||
}
|
||||
(void)last_stage;
|
||||
if (unsupported) VKB_ONCE(VKB_LOG_WARN, "emulation: clip/cull distance inside an output block is not handled (logged once)");
|
||||
return unsupported && !clip ? -1 : clip;
|
||||
}
|
||||
|
||||
/* The fragment side: read the distances at `loc` and discard when any is negative. */
|
||||
static int rewrite_fragment(spv_mod *m, uint32_t loc, uint32_t n)
|
||||
{
|
||||
uint32_t f32 = spv_type_float(m, 32);
|
||||
uint32_t len = spv_const_u32(m, n);
|
||||
uint32_t arr = spv_type_array(m, f32, len);
|
||||
uint32_t parr = spv_type_pointer(m, SpvStorageClassInput, arr);
|
||||
uint32_t pf = spv_type_pointer(m, SpvStorageClassInput, f32);
|
||||
uint32_t tbool = spv_type_bool(m);
|
||||
uint32_t zero = spv_const_f32(m, 0.0f);
|
||||
uint32_t idx[16];
|
||||
for (uint32_t i = 0; i < n && i < 16; i++) idx[i] = spv_const_u32(m, i);
|
||||
uint32_t var = spv_new_id(m);
|
||||
uint32_t vops[3] = {parr, var, SpvStorageClassInput};
|
||||
spv_insert(m, spv_types_end(m), SpvOpVariable, vops, 3);
|
||||
add_decoration(m, var, SpvDecorationLocation, loc);
|
||||
spv_add_interface(m, var);
|
||||
|
||||
int ep = spv_find_op(m, SpvOpEntryPoint, 0);
|
||||
if (ep < 0) return -1;
|
||||
uint32_t fn = m->ins[ep].w[1];
|
||||
int fi = -1;
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpFunction && m->ins[i].w[1] == fn) fi = (int)i;
|
||||
if (fi < 0) return -1;
|
||||
int li = spv_find_op(m, SpvOpLabel, (uint32_t)fi);
|
||||
if (li < 0) return -1;
|
||||
uint32_t first_label = m->ins[li].w[0];
|
||||
uint32_t at = (uint32_t)li + 1;
|
||||
while (at < m->count && (m->ins[at].op == SpvOpVariable || m->ins[at].op == SpvOpLine || m->ins[at].op == SpvOpNoLine)) at++;
|
||||
|
||||
uint32_t any = 0;
|
||||
for (uint32_t i = 0; i < n && i < 16; i++) {
|
||||
uint32_t p = spv_new_id(m), v = spv_new_id(m), lt = spv_new_id(m);
|
||||
uint32_t ac[4] = {pf, p, var, idx[i]};
|
||||
at = spv_insert(m, at, SpvOpAccessChain, ac, 4) + 1;
|
||||
uint32_t ld[3] = {f32, v, p};
|
||||
at = spv_insert(m, at, SpvOpLoad, ld, 3) + 1;
|
||||
uint32_t cmp[4] = {tbool, lt, v, zero};
|
||||
at = spv_insert(m, at, SpvOpFOrdLessThan, cmp, 4) + 1;
|
||||
if (any) {
|
||||
uint32_t o = spv_new_id(m), orr[4] = {tbool, o, any, lt};
|
||||
at = spv_insert(m, at, SpvOpLogicalOr, orr, 4) + 1;
|
||||
any = o;
|
||||
} else {
|
||||
any = lt;
|
||||
}
|
||||
}
|
||||
uint32_t kill = spv_new_id(m), merge = spv_new_id(m);
|
||||
uint32_t sm[2] = {merge, 0};
|
||||
at = spv_insert(m, at, SpvOpSelectionMerge, sm, 2) + 1;
|
||||
uint32_t bc[3] = {any, kill, merge};
|
||||
at = spv_insert(m, at, SpvOpBranchConditional, bc, 3) + 1;
|
||||
at = spv_insert(m, at, SpvOpLabel, &kill, 1) + 1;
|
||||
at = spv_insert(m, at, spv_version(m) >= 0x00010600 ? SpvOpTerminateInvocation : SpvOpKill, NULL, 0) + 1;
|
||||
at = spv_insert(m, at, SpvOpLabel, &merge, 1) + 1;
|
||||
/* Phis that named the old entry block as a predecessor now come from the merge block. */
|
||||
for (uint32_t i = at; i < m->count; i++) {
|
||||
spv_inst *in = &m->ins[i];
|
||||
if (in->op != 245 /* OpPhi */) continue;
|
||||
for (uint32_t k = 3; k < (uint32_t)in->n - 1; k += 2)
|
||||
if (in->w[k] == first_label) in->w[k] = merge;
|
||||
}
|
||||
return m->err ? -1 : 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ module store */
|
||||
|
||||
static VkResult make_module(VkDevice device, const spv_mod *m, VkShaderModule *out)
|
||||
{
|
||||
uint32_t *code;
|
||||
size_t size = spv_write(m, &code);
|
||||
if (!size) return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
const char *dump = getenv("VKBRIDGE_DUMP_SPIRV");
|
||||
if (dump && *dump) {
|
||||
static int seq;
|
||||
char path[512];
|
||||
snprintf(path, sizeof(path), "%s/vkbridge-%d-%d.spv", dump, (int)getpid(), __atomic_fetch_add(&seq, 1, __ATOMIC_RELAXED));
|
||||
FILE *f = fopen(path, "wb");
|
||||
if (f) {
|
||||
fwrite(code, 1, size, f);
|
||||
fclose(f);
|
||||
}
|
||||
}
|
||||
VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, NULL, 0, size, code};
|
||||
VkResult r = vkb_emu_real()->vkCreateShaderModule(device, &ci, NULL, out);
|
||||
free(code);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *ci,
|
||||
const VkAllocationCallbacks *pAllocator, VkShaderModule *pModule)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
spv_mod m;
|
||||
VkResult r;
|
||||
int needs = 0;
|
||||
if (spv_parse(&m, ci->pCode, ci->codeSize) == 0) {
|
||||
needs = spv_has_capability(&m, SpvCapabilityClipDistance) || spv_has_capability(&m, SpvCapabilityCullDistance) ||
|
||||
spv_has_capability(&m, SpvCapabilityGeometryPointSize) || spv_has_capability(&m, SpvCapabilityTessellationPointSize);
|
||||
}
|
||||
if (needs) {
|
||||
/* The driver's module must not ask for what it lacks; pipelines use rewritten variants. */
|
||||
int maxo = spv_max_location(&m, SpvStorageClassOutput);
|
||||
rewrite_pre_raster(&m, e->flags, (uint32_t)(maxo + 1), 1);
|
||||
r = make_module(device, &m, pModule);
|
||||
} else {
|
||||
r = vkb_emu_real()->vkCreateShaderModule(device, ci, pAllocator, pModule);
|
||||
}
|
||||
spv_free(&m);
|
||||
if (r != VK_SUCCESS) return r;
|
||||
shader_rec *rec = calloc(1, sizeof(*rec));
|
||||
rec->module = *pModule;
|
||||
rec->size = ci->codeSize;
|
||||
rec->code = malloc(ci->codeSize);
|
||||
memcpy(rec->code, ci->pCode, ci->codeSize);
|
||||
shader_state *s = state(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
unsigned h = mh(*pModule);
|
||||
rec->next = s->mods[h];
|
||||
s->mods[h] = rec;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static VKAPI_ATTR void VKAPI_CALL emu_DestroyShaderModule(VkDevice device, VkShaderModule module, const VkAllocationCallbacks *pAllocator)
|
||||
{
|
||||
vkb_emu_device *e = vkb_emu_cur();
|
||||
if (module) {
|
||||
shader_state *s = state(e);
|
||||
pthread_mutex_lock(&s->lock);
|
||||
shader_rec **pp = &s->mods[mh(module)];
|
||||
while (*pp && (*pp)->module != module) pp = &(*pp)->next;
|
||||
shader_rec *r = *pp;
|
||||
if (r) *pp = r->next;
|
||||
pthread_mutex_unlock(&s->lock);
|
||||
if (r) {
|
||||
free(r->code);
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
vkb_emu_real()->vkDestroyShaderModule(device, module, pAllocator);
|
||||
}
|
||||
|
||||
/* The SPIR-V of a stage: its module's (kept here) or the inline VkShaderModuleCreateInfo's. */
|
||||
static int stage_code(vkb_emu_device *e, const VkPipelineShaderStageCreateInfo *st, const uint32_t **code, size_t *size)
|
||||
{
|
||||
if (st->module) {
|
||||
const shader_rec *r = find_module(e, st->module);
|
||||
if (!r) return 0;
|
||||
*code = r->code;
|
||||
*size = r->size;
|
||||
return 1;
|
||||
}
|
||||
for (const VkBaseInStructure *b = st->pNext; b; b = b->pNext) {
|
||||
if (b->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) {
|
||||
*code = ((const VkShaderModuleCreateInfo *)b)->pCode;
|
||||
*size = ((const VkShaderModuleCreateInfo *)b)->codeSize;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Replace a stage's shader by a rewritten module (recorded for destruction after the call). */
|
||||
static void set_stage_module(VkDevice device, VkPipelineShaderStageCreateInfo *st, const spv_mod *m, VkShaderModule *mods,
|
||||
uint32_t *nmods, uint32_t cap)
|
||||
{
|
||||
VkShaderModule mod;
|
||||
if (*nmods >= cap || make_module(device, m, &mod) != VK_SUCCESS) return;
|
||||
mods[(*nmods)++] = mod;
|
||||
st->module = mod;
|
||||
vkb_emu_chain_take(st, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
|
||||
}
|
||||
|
||||
void vkb_emu_shader_pipeline(vkb_emu_device *e, VkDevice device, VkGraphicsPipelineCreateInfo *ci, VkShaderModule *mods,
|
||||
uint32_t *nmods, uint32_t cap)
|
||||
{
|
||||
if (!(e->flags & SHADER_EMU) || !ci->pStages) return;
|
||||
VkPipelineShaderStageCreateInfo *pre = NULL, *frag = NULL;
|
||||
int pre_rank = -1;
|
||||
for (uint32_t s = 0; s < ci->stageCount; s++) {
|
||||
VkPipelineShaderStageCreateInfo *st = (VkPipelineShaderStageCreateInfo *)&ci->pStages[s];
|
||||
int rank = st->stage == VK_SHADER_STAGE_VERTEX_BIT ? 0 : st->stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT ? 1
|
||||
: st->stage == VK_SHADER_STAGE_GEOMETRY_BIT ? 2 : -1;
|
||||
if (rank > pre_rank) {
|
||||
pre_rank = rank;
|
||||
pre = st;
|
||||
}
|
||||
if (st->stage == VK_SHADER_STAGE_FRAGMENT_BIT) frag = st;
|
||||
}
|
||||
if (!pre) return;
|
||||
const uint32_t *code;
|
||||
size_t size;
|
||||
if (!stage_code(e, pre, &code, &size)) return;
|
||||
spv_mod pm;
|
||||
if (spv_parse(&pm, code, size) != 0) return;
|
||||
if (!spv_has_capability(&pm, SpvCapabilityClipDistance) && !spv_has_capability(&pm, SpvCapabilityCullDistance) &&
|
||||
!spv_has_capability(&pm, SpvCapabilityGeometryPointSize) && !spv_has_capability(&pm, SpvCapabilityTessellationPointSize)) {
|
||||
spv_free(&pm);
|
||||
return;
|
||||
}
|
||||
spv_mod fm;
|
||||
int have_frag = 0;
|
||||
const uint32_t *fcode;
|
||||
size_t fsize;
|
||||
if (frag && stage_code(e, frag, &fcode, &fsize) && spv_parse(&fm, fcode, fsize) == 0) have_frag = 1;
|
||||
int loc = spv_max_location(&pm, SpvStorageClassOutput);
|
||||
if (have_frag) {
|
||||
int fl = spv_max_location(&fm, SpvStorageClassInput);
|
||||
if (fl > loc) loc = fl;
|
||||
}
|
||||
int clip = rewrite_pre_raster(&pm, e->flags, (uint32_t)(loc + 1), 1);
|
||||
if (clip >= 0) set_stage_module(device, pre, &pm, mods, nmods, cap);
|
||||
if (clip > 0) {
|
||||
if (have_frag) {
|
||||
if (rewrite_fragment(&fm, (uint32_t)(loc + 1), (uint32_t)clip) == 0) set_stage_module(device, frag, &fm, mods, nmods, cap);
|
||||
} else {
|
||||
VKB_ONCE(VKB_LOG_WARN, "emulation: clip distances in a pipeline without a fragment shader are not applied (logged once)");
|
||||
}
|
||||
}
|
||||
VKB_DBG("emulation: pipeline with %d clip distance(s) rewritten at location %d", clip, loc + 1);
|
||||
spv_free(&pm);
|
||||
if (have_frag) spv_free(&fm);
|
||||
}
|
||||
|
||||
/* A vertex shader that reads BaseInstance as 0 (divisor emulation splits draws, which moves
|
||||
* BaseInstance; DXVK derives SV_InstanceID from it). VK_NULL_HANDLE when the shader never reads it. */
|
||||
VkShaderModule vkb_emu_shader_zero_base_instance(vkb_emu_device *e, VkDevice device, const VkPipelineShaderStageCreateInfo *vs)
|
||||
{
|
||||
const uint32_t *code;
|
||||
size_t size;
|
||||
if (!e->shaders || !stage_code(e, vs, &code, &size)) return VK_NULL_HANDLE;
|
||||
spv_mod m;
|
||||
if (spv_parse(&m, code, size) != 0) return VK_NULL_HANDLE;
|
||||
int in_block;
|
||||
uint32_t var = builtin_var(&m, SpvBuiltInBaseInstance, SpvStorageClassInput, &in_block);
|
||||
VkShaderModule out = VK_NULL_HANDLE;
|
||||
if (var) {
|
||||
int d = spv_find_def(&m, var);
|
||||
int p = d >= 0 ? spv_find_def(&m, m.ins[d].w[0]) : -1;
|
||||
uint32_t type = p >= 0 ? m.ins[p].w[2] : 0;
|
||||
int td = spv_find_def(&m, type);
|
||||
uint32_t zero = 0;
|
||||
if (td >= 0 && m.ins[td].op == SpvOpTypeInt) {
|
||||
zero = spv_new_id(&m);
|
||||
uint32_t ops[3] = {type, zero, 0};
|
||||
spv_insert(&m, spv_types_end(&m), SpvOpConstant, ops, 3);
|
||||
}
|
||||
int changed = 0;
|
||||
for (uint32_t i = 0; zero && i < m.count; i++) {
|
||||
spv_inst *in = &m.ins[i];
|
||||
if (in->op == SpvOpLoad && in->w[2] == var) {
|
||||
/* %r = OpLoad %int %BaseInstance -> %r = OpCopyObject %int %zero */
|
||||
in->op = 83; /* OpCopyObject */
|
||||
in->w[2] = zero;
|
||||
in->n = 4;
|
||||
changed = 1;
|
||||
}
|
||||
}
|
||||
if (changed) make_module(device, &m, &out);
|
||||
}
|
||||
spv_free(&m);
|
||||
return out;
|
||||
}
|
||||
|
||||
void vkb_emu_shader_install(vkb_srv_table *dev)
|
||||
{
|
||||
vkb_emu_device *e = dev->emu;
|
||||
if (!(e->flags & SHADER_STORE)) return;
|
||||
shader_state *s = calloc(1, sizeof(*s));
|
||||
pthread_mutex_init(&s->lock, NULL);
|
||||
e->shaders = s;
|
||||
dev->dt.vkCreateShaderModule = emu_CreateShaderModule;
|
||||
dev->dt.vkDestroyShaderModule = emu_DestroyShaderModule;
|
||||
}
|
||||
|
||||
void vkb_emu_shader_uninstall(vkb_srv_table *dev)
|
||||
{
|
||||
shader_state *s = dev->emu->shaders;
|
||||
if (!s) return;
|
||||
for (int i = 0; i < 1024; i++) {
|
||||
while (s->mods[i]) {
|
||||
shader_rec *r = s->mods[i];
|
||||
s->mods[i] = r->next;
|
||||
free(r->code);
|
||||
free(r);
|
||||
}
|
||||
}
|
||||
pthread_mutex_destroy(&s->lock);
|
||||
free(s);
|
||||
dev->emu->shaders = NULL;
|
||||
}
|
||||
@@ -0,0 +1,354 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Instances, devices and the startup self-test.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
vkb_pd_knowledge vkb_pds[VKB_MAX_PDS];
|
||||
int vkb_npds;
|
||||
|
||||
static int has_ext(const VkExtensionProperties *e, uint32_t n, const char *name)
|
||||
{
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
if (!strcmp(e[i].extensionName, name)) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
const vkb_pd_knowledge *vkb_pd_lookup(const vkb_dispatch *dt, VkPhysicalDevice pd)
|
||||
{
|
||||
VkPhysicalDeviceIDProperties id = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES};
|
||||
VkPhysicalDeviceProperties2 p2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &id};
|
||||
if (!dt->vkGetPhysicalDeviceProperties2) return NULL;
|
||||
dt->vkGetPhysicalDeviceProperties2(pd, &p2);
|
||||
for (int i = 0; i < vkb_npds; i++)
|
||||
if (vkb_pds[i].valid && !memcmp(vkb_pds[i].uuid, id.deviceUUID, VK_UUID_SIZE)) return &vkb_pds[i];
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* What the self-test found, for a later session's log (the in-app server tests once). */
|
||||
void vkb_log_summary(void)
|
||||
{
|
||||
for (int i = 0; i < vkb_npds; i++) {
|
||||
const vkb_pd_knowledge *k = &vkb_pds[i];
|
||||
if (k->valid)
|
||||
VKB_INFO("%s: memory sharing = %s, missing 0x%x, emulating 0x%x (from the first session's self-test)", k->name,
|
||||
vkb_mem_strategy_name(k->info.strategy), k->info.missing, k->info.emu);
|
||||
}
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ startup self-test */
|
||||
|
||||
static void log_device(const vkb_dispatch *dt, VkPhysicalDevice pd, const VkPhysicalDeviceProperties *p)
|
||||
{
|
||||
VKB_INFO("GPU: %s (vendor 0x%04x device 0x%04x, Vulkan %u.%u.%u, driver 0x%08x)", p->deviceName,
|
||||
p->vendorID, p->deviceID, VK_API_VERSION_MAJOR(p->apiVersion), VK_API_VERSION_MINOR(p->apiVersion),
|
||||
VK_API_VERSION_PATCH(p->apiVersion), p->driverVersion);
|
||||
VkPhysicalDeviceFeatures f;
|
||||
dt->vkGetPhysicalDeviceFeatures(pd, &f);
|
||||
#define F(x) #x, f.x
|
||||
VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(textureCompressionBC), F(shaderClipDistance),
|
||||
F(shaderCullDistance), F(geometryShader), F(tessellationShader), F(depthClamp), F(shaderFloat64), F(shaderInt64));
|
||||
VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(multiViewport), F(independentBlend), F(logicOp),
|
||||
F(fillModeNonSolid), F(dualSrcBlend), F(sampleRateShading), F(depthBiasClamp), F(wideLines));
|
||||
VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(drawIndirectFirstInstance), F(multiDrawIndirect),
|
||||
F(occlusionQueryPrecise), F(pipelineStatisticsQuery), F(vertexPipelineStoresAndAtomics),
|
||||
F(fragmentStoresAndAtomics), F(shaderStorageImageWriteWithoutFormat), F(imageCubeArray));
|
||||
VKB_INFO("features: %s=%u %s=%u %s=%u %s=%u %s=%u %s=%u", F(robustBufferAccess), F(fullDrawIndexUint32), F(samplerAnisotropy),
|
||||
F(depthBounds), F(largePoints), F(shaderStorageImageExtendedFormats));
|
||||
#undef F
|
||||
uint32_t n = 0;
|
||||
dt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL);
|
||||
VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e));
|
||||
dt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e);
|
||||
static const char *const watch[] = {
|
||||
"VK_EXT_depth_clip_enable", "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor",
|
||||
"VK_EXT_external_memory_dma_buf", "VK_EXT_image_drm_format_modifier", "VK_KHR_external_memory_fd",
|
||||
"VK_EXT_external_memory_host", "VK_ANDROID_external_memory_android_hardware_buffer",
|
||||
"VK_KHR_external_semaphore_fd", "VK_KHR_external_fence_fd", "VK_EXT_queue_family_foreign",
|
||||
"VK_EXT_robustness2", "VK_EXT_transform_feedback", "VK_EXT_custom_border_color",
|
||||
"VK_EXT_mutable_descriptor_type", "VK_VALVE_mutable_descriptor_type", "VK_EXT_extended_dynamic_state3",
|
||||
"VK_EXT_graphics_pipeline_library", "VK_EXT_physical_device_drm", "VK_KHR_push_descriptor",
|
||||
"VK_EXT_descriptor_indexing", "VK_KHR_timeline_semaphore", "VK_EXT_memory_budget",
|
||||
"VK_KHR_maintenance5", "VK_EXT_line_rasterization", "VK_EXT_provoking_vertex",
|
||||
};
|
||||
char line[1024];
|
||||
size_t len = 0;
|
||||
line[0] = 0;
|
||||
for (size_t i = 0; i < sizeof(watch) / sizeof(watch[0]); i++) {
|
||||
int ok = has_ext(e, n, watch[i]);
|
||||
len += (size_t)snprintf(line + len, sizeof(line) - len, "%s%s%s", len ? " " : "", ok ? "+" : "-", watch[i] + 3);
|
||||
if (len > 700 || i + 1 == sizeof(watch) / sizeof(watch[0])) {
|
||||
VKB_INFO("extensions: %s", line);
|
||||
len = 0;
|
||||
line[0] = 0;
|
||||
}
|
||||
}
|
||||
VKB_INFO("%u device extensions in total", n);
|
||||
/* All of them, until the device runs show which ones the server's process sees (it is not an
|
||||
* app process, and saw fewer than the capability viewer on the same tablet). */
|
||||
len = 0;
|
||||
line[0] = 0;
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
len += (size_t)snprintf(line + len, sizeof(line) - len, "%s%s:%u", len ? " " : "", e[i].extensionName + 3, e[i].specVersion);
|
||||
if (len > 700 || i + 1 == n) {
|
||||
VKB_INFO(" all: %s", line);
|
||||
len = 0;
|
||||
line[0] = 0;
|
||||
}
|
||||
}
|
||||
free(e);
|
||||
VkPhysicalDeviceMemoryProperties mp;
|
||||
dt->vkGetPhysicalDeviceMemoryProperties(pd, &mp);
|
||||
for (uint32_t i = 0; i < mp.memoryHeapCount; i++)
|
||||
VKB_INFO("memory heap %u: %llu MB flags 0x%x", i, (unsigned long long)(mp.memoryHeaps[i].size >> 20), mp.memoryHeaps[i].flags);
|
||||
for (uint32_t i = 0; i < mp.memoryTypeCount; i++)
|
||||
VKB_INFO("memory type %u: heap %u flags 0x%x", i, mp.memoryTypes[i].heapIndex, mp.memoryTypes[i].propertyFlags);
|
||||
}
|
||||
|
||||
void vkb_selftest_all(void)
|
||||
{
|
||||
uint32_t api = VK_API_VERSION_1_0;
|
||||
if (vkb_global_dt.vkEnumerateInstanceVersion) vkb_global_dt.vkEnumerateInstanceVersion(&api);
|
||||
if (api > VK_API_VERSION_1_3) api = VK_API_VERSION_1_3;
|
||||
VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO, NULL, "vkbridge-selftest", 1, "vkbridge", 1, api};
|
||||
VkInstanceCreateInfo ci = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, NULL, 0, &app, 0, NULL, 0, NULL};
|
||||
VkInstance inst;
|
||||
VkResult r = vkb_global_dt.vkCreateInstance(&ci, NULL, &inst);
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_ERR("self-test: vkCreateInstance failed (%d); the driver is unusable", r);
|
||||
return;
|
||||
}
|
||||
vkb_dispatch dt;
|
||||
vkb_dispatch_load_instance(&dt, vkb_gipa, inst);
|
||||
uint32_t n = 0;
|
||||
dt.vkEnumeratePhysicalDevices(inst, &n, NULL);
|
||||
if (n > VKB_MAX_PDS) n = VKB_MAX_PDS;
|
||||
VkPhysicalDevice pds[VKB_MAX_PDS];
|
||||
dt.vkEnumeratePhysicalDevices(inst, &n, pds);
|
||||
VKB_INFO("self-test: loader Vulkan %u.%u, %u physical device(s)", VK_API_VERSION_MAJOR(api), VK_API_VERSION_MINOR(api), n);
|
||||
for (uint32_t i = 0; i < n; i++) {
|
||||
VkPhysicalDeviceIDProperties id = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES};
|
||||
VkPhysicalDeviceProperties2 p2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &id};
|
||||
dt.vkGetPhysicalDeviceProperties2(pds[i], &p2);
|
||||
log_device(&dt, pds[i], &p2.properties);
|
||||
vkb_pd_knowledge *k = &vkb_pds[vkb_npds++];
|
||||
memcpy(k->uuid, id.deviceUUID, VK_UUID_SIZE);
|
||||
snprintf(k->name, sizeof(k->name), "%s", p2.properties.deviceName);
|
||||
k->info.real_api_version = p2.properties.apiVersion;
|
||||
vkb_mem_selftest(k, inst, &dt, pds[i]);
|
||||
k->info.emu_available = vkb_emu_detect(&dt, pds[i], &k->info.missing);
|
||||
k->info.emu = k->info.emu_available;
|
||||
const char *emu_env = getenv("VKBRIDGE_EMULATE");
|
||||
if (emu_env && !strcmp(emu_env, "0")) k->info.emu = 0;
|
||||
k->valid = 1;
|
||||
VKB_INFO("%s: memory sharing = %s, missing 0x%x, emulating 0x%x", k->name, vkb_mem_strategy_name(k->info.strategy),
|
||||
k->info.missing, k->info.emu);
|
||||
}
|
||||
dt.vkDestroyInstance(inst, NULL);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ instance */
|
||||
|
||||
void vkb_sv_vkCreateInstance(vkb_srv_call *c)
|
||||
{
|
||||
VkInstanceCreateInfo *ci = NULL;
|
||||
if (vkb_dec_u8(&c->d)) {
|
||||
ci = vkb_dec_alloc(&c->d, sizeof(*ci));
|
||||
if (ci) vkb_dec_VkInstanceCreateInfo(&c->d, ci);
|
||||
}
|
||||
uint8_t want_out = vkb_dec_u8(&c->d);
|
||||
if (c->d.err || !ci || !want_out) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
VkInstance inst = VK_NULL_HANDLE;
|
||||
VkResult r = vkb_global_dt.vkCreateInstance(ci, NULL, &inst);
|
||||
uint32_t id = 0;
|
||||
if (r == VK_SUCCESS) {
|
||||
vkb_srv_table *t = calloc(1, sizeof(*t));
|
||||
pthread_mutex_init(&t->lock, NULL);
|
||||
t->instance = inst;
|
||||
t->proc = c->conn->proc;
|
||||
t->api_version = ci->pApplicationInfo ? ci->pApplicationInfo->apiVersion : VK_API_VERSION_1_0;
|
||||
vkb_dispatch_load_instance(&t->real, vkb_gipa, inst);
|
||||
t->dt = t->real;
|
||||
id = vkb_table_register(t);
|
||||
if (!id) {
|
||||
t->real.vkDestroyInstance(inst, NULL);
|
||||
free(t);
|
||||
r = VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
inst = VK_NULL_HANDLE;
|
||||
} else {
|
||||
VKB_INFO("instance %u created (app \"%s\", engine \"%s\", Vulkan %u.%u)", id,
|
||||
ci->pApplicationInfo && ci->pApplicationInfo->pApplicationName ? ci->pApplicationInfo->pApplicationName : "",
|
||||
ci->pApplicationInfo && ci->pApplicationInfo->pEngineName ? ci->pApplicationInfo->pEngineName : "",
|
||||
VK_API_VERSION_MAJOR(t->api_version), VK_API_VERSION_MINOR(t->api_version));
|
||||
}
|
||||
} else {
|
||||
VKB_ERR("vkCreateInstance failed: %d", r);
|
||||
}
|
||||
vkb_enc_u32(&c->r, (uint32_t)r);
|
||||
vkb_enc_u64(&c->r, (uint64_t)(uintptr_t)inst);
|
||||
vkb_enc_u32(&c->r, id);
|
||||
}
|
||||
|
||||
void vkb_sv_vkDestroyInstance(vkb_srv_call *c)
|
||||
{
|
||||
VkInstance inst = (VkInstance)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
vkb_srv_table *t = c->table;
|
||||
if (!t || t->is_device || t->instance != inst) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
vkb_table_unregister(t);
|
||||
t->real.vkDestroyInstance(inst, NULL);
|
||||
pthread_mutex_destroy(&t->lock);
|
||||
free(t);
|
||||
c->table = NULL;
|
||||
}
|
||||
|
||||
void vkb_sv_vkbQueryServer(vkb_srv_call *c)
|
||||
{
|
||||
VkPhysicalDevice pd = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
if (c->d.err || !c->table) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
const vkb_pd_knowledge *k = vkb_pd_lookup(c->dt, pd);
|
||||
vkb_server_pd_info info;
|
||||
memset(&info, 0, sizeof(info));
|
||||
if (k) info = k->info;
|
||||
else VKB_WARN("query for a physical device the self-test did not see");
|
||||
vkb_enc_raw(&c->r, &info, sizeof(info));
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ device */
|
||||
|
||||
static int list_has(const char *const *l, uint32_t n, const char *s)
|
||||
{
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
if (l[i] && !strcmp(l[i], s)) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void vkb_sv_vkCreateDevice(vkb_srv_call *c)
|
||||
{
|
||||
VkPhysicalDevice pd = (VkPhysicalDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
VkDeviceCreateInfo *ci = NULL;
|
||||
if (vkb_dec_u8(&c->d)) {
|
||||
ci = vkb_dec_alloc(&c->d, sizeof(*ci));
|
||||
if (ci) vkb_dec_VkDeviceCreateInfo(&c->d, ci);
|
||||
}
|
||||
uint8_t want_out = vkb_dec_u8(&c->d);
|
||||
vkb_srv_table *inst = c->table;
|
||||
if (c->d.err || !ci || !want_out || !inst || inst->is_device) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
const vkb_pd_knowledge *k = vkb_pd_lookup(&inst->real, pd);
|
||||
uint32_t strategy = k ? k->info.strategy : VKB_MEM_NONE;
|
||||
uint32_t emu = k ? k->info.emu : 0;
|
||||
|
||||
/* Extensions the server itself needs (memory sharing), when the driver has them. */
|
||||
uint32_t avail_n = 0;
|
||||
inst->real.vkEnumerateDeviceExtensionProperties(pd, NULL, &avail_n, NULL);
|
||||
VkExtensionProperties *avail = vkb_dec_alloc(&c->d, (avail_n ? avail_n : 1) * sizeof(*avail));
|
||||
inst->real.vkEnumerateDeviceExtensionProperties(pd, NULL, &avail_n, avail);
|
||||
uint32_t extra_n = 0;
|
||||
const char *const *extra = vkb_mem_required_extensions(strategy, &extra_n);
|
||||
const char **exts = vkb_dec_alloc(&c->d, (ci->enabledExtensionCount + extra_n + 10) * sizeof(char *));
|
||||
uint32_t n = 0;
|
||||
for (uint32_t i = 0; i < ci->enabledExtensionCount; i++) {
|
||||
const char *e = ci->ppEnabledExtensionNames[i];
|
||||
if (!has_ext(avail, avail_n, e)) {
|
||||
VKB_DBG("device extension %s is emulated or client-side; not passed to the driver", e);
|
||||
continue;
|
||||
}
|
||||
exts[n++] = e;
|
||||
}
|
||||
for (uint32_t i = 0; i < extra_n; i++)
|
||||
if (has_ext(avail, avail_n, extra[i]) && !list_has(exts, n, extra[i])) exts[n++] = extra[i];
|
||||
/* What the client's presentation code uses on every device (dma-buf swapchains, sync fds). */
|
||||
static const char *const wsi_exts[] = {
|
||||
"VK_KHR_external_memory_fd", "VK_EXT_external_memory_dma_buf", "VK_KHR_image_format_list",
|
||||
"VK_EXT_image_drm_format_modifier", "VK_KHR_external_semaphore_fd", "VK_KHR_external_fence_fd",
|
||||
};
|
||||
for (size_t i = 0; i < sizeof(wsi_exts) / sizeof(wsi_exts[0]); i++)
|
||||
if (has_ext(avail, avail_n, wsi_exts[i]) && !list_has(exts, n, wsi_exts[i])) exts[n++] = wsi_exts[i];
|
||||
/* The BC decoder binds its buffer and image with push descriptors. */
|
||||
if ((emu & VKB_EMU_BCN) && has_ext(avail, avail_n, "VK_KHR_push_descriptor") && !list_has(exts, n, "VK_KHR_push_descriptor"))
|
||||
exts[n++] = "VK_KHR_push_descriptor";
|
||||
ci->enabledExtensionCount = n;
|
||||
ci->ppEnabledExtensionNames = exts;
|
||||
ci->enabledLayerCount = 0;
|
||||
ci->ppEnabledLayerNames = NULL;
|
||||
|
||||
vkb_emu_device_create_info(inst, pd, emu, ci, c->d.arena);
|
||||
|
||||
VkDevice dev = VK_NULL_HANDLE;
|
||||
VkResult r = inst->real.vkCreateDevice(pd, ci, NULL, &dev);
|
||||
uint32_t id = 0;
|
||||
if (r == VK_SUCCESS) {
|
||||
vkb_srv_table *t = calloc(1, sizeof(*t));
|
||||
pthread_mutex_init(&t->lock, NULL);
|
||||
t->is_device = 1;
|
||||
t->proc = c->conn->proc;
|
||||
t->instance = inst->instance;
|
||||
t->device = dev;
|
||||
t->physical = pd;
|
||||
t->parent = inst;
|
||||
t->pd = k;
|
||||
t->api_version = inst->api_version;
|
||||
t->real = inst->real;
|
||||
PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(inst->instance, "vkGetDeviceProcAddr");
|
||||
vkb_dispatch_load_device(&t->real, gdpa, dev);
|
||||
t->dt = t->real;
|
||||
id = vkb_table_register(t);
|
||||
if (!id) {
|
||||
t->real.vkDestroyDevice(dev, NULL);
|
||||
free(t);
|
||||
dev = VK_NULL_HANDLE;
|
||||
r = VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
} else {
|
||||
vkb_emu_device_init(t, emu);
|
||||
vkb_pcache_device_init(t);
|
||||
vkb_dsmap_device_init(t);
|
||||
vkb_spvfix_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]);
|
||||
}
|
||||
} else {
|
||||
VKB_ERR("vkCreateDevice failed: %d (%u extensions)", r, n);
|
||||
for (uint32_t i = 0; i < n; i++) VKB_ERR(" requested %s", exts[i]);
|
||||
}
|
||||
vkb_enc_u32(&c->r, (uint32_t)r);
|
||||
vkb_enc_u64(&c->r, (uint64_t)(uintptr_t)dev);
|
||||
vkb_enc_u32(&c->r, id);
|
||||
}
|
||||
|
||||
void vkb_sv_vkDestroyDevice(vkb_srv_call *c)
|
||||
{
|
||||
VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
vkb_srv_table *t = c->table;
|
||||
if (!t || !t->is_device || t->device != dev) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
vkb_table_unregister(t);
|
||||
vkb_spvfix_device_destroy(t);
|
||||
vkb_dsmap_device_destroy(t);
|
||||
vkb_pcache_device_destroy(t);
|
||||
vkb_emu_device_destroy(t);
|
||||
vkb_mem_free_all(t);
|
||||
t->real.vkDestroyDevice(dev, NULL);
|
||||
VKB_INFO("device %u destroyed", t->id);
|
||||
pthread_mutex_destroy(&t->lock);
|
||||
free(t);
|
||||
c->table = NULL;
|
||||
}
|
||||
@@ -0,0 +1,329 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* vkbridge server entry point.
|
||||
*
|
||||
* libvkbridge_server.so --socket <path> [--log <file>] [--vulkan <libvulkan>] [--cache-dir <dir>] [--selftest]
|
||||
*
|
||||
* Packaged as a "library" so Android extracts it into the native library directory, from where
|
||||
* the app executes it like proot. It loads the system Vulkan loader (on the device: the vendor's
|
||||
* Mali driver behind /system/lib64/libvulkan.so), runs a self-test that decides how mapped memory
|
||||
* is shared with the Linux side, then serves the session's Vulkan calls until it is killed or its
|
||||
* parent dies.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <signal.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/prctl.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/un.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef __ANDROID__
|
||||
#include <android/log.h>
|
||||
#elif defined(__GLIBC__)
|
||||
#include <execinfo.h>
|
||||
#endif
|
||||
|
||||
PFN_vkGetInstanceProcAddr vkb_gipa;
|
||||
vkb_dispatch vkb_global_dt;
|
||||
int vkb_verbose;
|
||||
|
||||
static FILE *log_file;
|
||||
static int log_level = VKB_LOG_INFO;
|
||||
static pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
|
||||
int vkb_log_level(void) { return log_level; }
|
||||
|
||||
void vkb_log(int level, const char *fmt, ...)
|
||||
{
|
||||
if (level > log_level) return;
|
||||
char msg[2048];
|
||||
va_list ap;
|
||||
va_start(ap, fmt);
|
||||
vsnprintf(msg, sizeof(msg), fmt, ap);
|
||||
va_end(ap);
|
||||
static const char *const tags[] = {"E", "W", "I", "D"};
|
||||
struct timespec ts;
|
||||
clock_gettime(CLOCK_REALTIME, &ts);
|
||||
struct tm tm;
|
||||
localtime_r(&ts.tv_sec, &tm);
|
||||
pthread_mutex_lock(&log_lock);
|
||||
FILE *f = log_file ? log_file : stderr;
|
||||
fprintf(f, "%02d:%02d:%02d.%03ld vkbridge-server %s %s\n", tm.tm_hour, tm.tm_min, tm.tm_sec,
|
||||
ts.tv_nsec / 1000000, tags[level & 3], msg);
|
||||
fflush(f);
|
||||
pthread_mutex_unlock(&log_lock);
|
||||
#ifdef __ANDROID__
|
||||
static const int prio[] = {ANDROID_LOG_ERROR, ANDROID_LOG_WARN, ANDROID_LOG_INFO, ANDROID_LOG_DEBUG};
|
||||
__android_log_write(prio[level & 3], "vkbridge", msg);
|
||||
#endif
|
||||
}
|
||||
|
||||
extern __thread const char *vkb_srv_current_cmd;
|
||||
|
||||
/* A crash is almost always the driver's: say in which call, then die as we would have. */
|
||||
__attribute__((unused)) static void on_crash(int sig)
|
||||
{
|
||||
char buf[256];
|
||||
const char *cmd = vkb_srv_current_cmd ? vkb_srv_current_cmd : "(no Vulkan call)";
|
||||
int n = snprintf(buf, sizeof(buf), "vkbridge-server E crashed with signal %d in %s\n", sig, cmd);
|
||||
if (log_file) {
|
||||
if (write(fileno(log_file), buf, (size_t)n) < 0) {}
|
||||
}
|
||||
if (write(2, buf, (size_t)n) < 0) {}
|
||||
#ifdef __ANDROID__
|
||||
__android_log_write(ANDROID_LOG_FATAL, "vkbridge", buf);
|
||||
#elif defined(__GLIBC__)
|
||||
void *frames[32];
|
||||
int nf = backtrace(frames, 32);
|
||||
backtrace_symbols_fd(frames, nf, 2);
|
||||
if (log_file) backtrace_symbols_fd(frames, nf, fileno(log_file));
|
||||
#endif
|
||||
signal(sig, SIG_DFL);
|
||||
raise(sig);
|
||||
}
|
||||
|
||||
static void *load_vulkan(const char *override)
|
||||
{
|
||||
const char *names[] = {
|
||||
override,
|
||||
#ifdef __ANDROID__
|
||||
"libvulkan.so",
|
||||
#else
|
||||
"libvulkan.so.1",
|
||||
"libvulkan.so",
|
||||
#endif
|
||||
};
|
||||
for (size_t i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
|
||||
if (!names[i]) continue;
|
||||
void *h = dlopen(names[i], RTLD_NOW | RTLD_LOCAL);
|
||||
if (h) {
|
||||
VKB_INFO("Vulkan loader: %s", names[i]);
|
||||
return h;
|
||||
}
|
||||
VKB_WARN("cannot open %s: %s", names[i], dlerror());
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int listen_on(const char *path)
|
||||
{
|
||||
struct sockaddr_un a;
|
||||
if (strlen(path) >= sizeof(a.sun_path)) {
|
||||
VKB_ERR("socket path too long (%zu bytes): %s", strlen(path), path);
|
||||
return -1;
|
||||
}
|
||||
int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
||||
if (fd < 0) {
|
||||
VKB_ERR("socket: %s", strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
memset(&a, 0, sizeof(a));
|
||||
a.sun_family = AF_UNIX;
|
||||
strcpy(a.sun_path, path);
|
||||
unlink(path);
|
||||
if (bind(fd, (struct sockaddr *)&a, sizeof(a)) < 0) {
|
||||
VKB_ERR("bind %s: %s", path, strerror(errno));
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
chmod(path, 0600);
|
||||
if (listen(fd, 128) < 0) {
|
||||
VKB_ERR("listen: %s", strerror(errno));
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
/* Opens (or switches to) the log file; NULL keeps logging to stderr/logcat only. */
|
||||
static void open_log(const char *path)
|
||||
{
|
||||
FILE *f = path ? fopen(path, "ae") : NULL;
|
||||
if (path && !f) fprintf(stderr, "vkbridge-server: cannot open log %s: %s\n", path, strerror(errno));
|
||||
pthread_mutex_lock(&log_lock);
|
||||
FILE *old = log_file;
|
||||
log_file = f;
|
||||
pthread_mutex_unlock(&log_lock);
|
||||
if (old) fclose(old);
|
||||
}
|
||||
|
||||
/* Loads the Vulkan loader and runs the self-test; 0 when there is nothing to serve. */
|
||||
static int server_init(const char *vk_lib, const char *cache_dir)
|
||||
{
|
||||
VKB_INFO("starting (pid %d, protocol %016llx)", getpid(), (unsigned long long)VKB_PROTOCOL_HASH);
|
||||
void *lib = load_vulkan(vk_lib);
|
||||
if (!lib) {
|
||||
VKB_ERR("no Vulkan loader; nothing to serve");
|
||||
return 0;
|
||||
}
|
||||
vkb_gipa = (PFN_vkGetInstanceProcAddr)dlsym(lib, "vkGetInstanceProcAddr");
|
||||
if (!vkb_gipa) {
|
||||
VKB_ERR("the Vulkan loader exports no vkGetInstanceProcAddr");
|
||||
return 0;
|
||||
}
|
||||
vkb_dispatch_load_instance(&vkb_global_dt, vkb_gipa, VK_NULL_HANDLE);
|
||||
vkb_pcache_set_dir(cache_dir);
|
||||
vkb_selftest_all();
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifdef VKB_JNI
|
||||
/*
|
||||
* In the app's own process (the default on the device): Android chooses the GPU driver, Samsung's
|
||||
* updatable one included, while the app starts up, and only for the app's process - a separate
|
||||
* executable gets the plain /vendor driver, which on the Tab S10+ lacked VK_EXT_robustness2 and
|
||||
* more that the app itself sees. Winlator's Vortek runs its server in-process for the same reason.
|
||||
* Started once and kept for the app's life; each session only points the log at its own folder.
|
||||
*/
|
||||
#include <jni.h>
|
||||
|
||||
static pthread_mutex_t jni_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static char jni_socket[256];
|
||||
static int jni_state; /* 0 not started, 1 serving, -1 failed */
|
||||
|
||||
static void *serve_thread(void *arg)
|
||||
{
|
||||
vkb_srv_serve((int)(intptr_t)arg);
|
||||
VKB_ERR("in-app server stopped serving");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static char *jstr(JNIEnv *env, jstring s)
|
||||
{
|
||||
if (!s) return NULL;
|
||||
const char *c = (*env)->GetStringUTFChars(env, s, NULL);
|
||||
char *r = c ? strdup(c) : NULL;
|
||||
if (c) (*env)->ReleaseStringUTFChars(env, s, c);
|
||||
return r;
|
||||
}
|
||||
|
||||
JNIEXPORT jint JNICALL Java_com_droiddeck_launcher_gpu_VkBridgeNative_nativeStart(JNIEnv *env, jclass cls, jstring jsocket,
|
||||
jstring jlog, jstring jcache)
|
||||
{
|
||||
(void)cls;
|
||||
char *sock = jstr(env, jsocket), *logp = jstr(env, jlog), *cache = jstr(env, jcache);
|
||||
pthread_mutex_lock(&jni_lock);
|
||||
open_log(logp);
|
||||
if (getenv("VKBRIDGE_DEBUG")) {
|
||||
vkb_verbose = 1;
|
||||
log_level = VKB_LOG_DEBUG;
|
||||
}
|
||||
int ok = 0;
|
||||
if (jni_state == 1 && sock && !strcmp(sock, jni_socket) && access(sock, F_OK) == 0) {
|
||||
VKB_INFO("in-app server already serving at %s (pid %d); this session's log continues here", sock, getpid());
|
||||
vkb_log_summary();
|
||||
ok = 1;
|
||||
} else if (jni_state == 1) {
|
||||
VKB_ERR("in-app server serves %s, asked for %s (or its socket is gone)", jni_socket, sock ? sock : "(none)");
|
||||
} else if (jni_state == 0 && sock) {
|
||||
jni_state = -1;
|
||||
if (server_init(NULL, cache)) {
|
||||
int lfd = listen_on(sock);
|
||||
pthread_t t;
|
||||
if (lfd >= 0 && pthread_create(&t, NULL, serve_thread, (void *)(intptr_t)lfd) == 0) {
|
||||
pthread_detach(t);
|
||||
snprintf(jni_socket, sizeof(jni_socket), "%s", sock);
|
||||
jni_state = 1;
|
||||
ok = 1;
|
||||
VKB_INFO("listening on %s (in the app's process)", sock);
|
||||
}
|
||||
}
|
||||
}
|
||||
pthread_mutex_unlock(&jni_lock);
|
||||
free(sock);
|
||||
free(logp);
|
||||
free(cache);
|
||||
return ok;
|
||||
}
|
||||
#else
|
||||
static void usage(void)
|
||||
{
|
||||
fprintf(stderr, "usage: vkbridge-server --socket PATH [--log FILE] [--vulkan LIB] [--cache-dir DIR] [--selftest] [--verbose]\n");
|
||||
}
|
||||
|
||||
static pid_t parent_pid;
|
||||
|
||||
static void *parent_watch(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
for (;;) {
|
||||
sleep(1);
|
||||
if (getppid() != parent_pid) {
|
||||
VKB_INFO("the app (pid %d) is gone; exiting", (int)parent_pid);
|
||||
_exit(0);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void start_parent_watch(void)
|
||||
{
|
||||
parent_pid = getppid();
|
||||
if (parent_pid <= 1) return; /* started by init or a shell that already left: nothing to watch */
|
||||
pthread_t t;
|
||||
pthread_attr_t a;
|
||||
pthread_attr_init(&a);
|
||||
pthread_attr_setdetachstate(&a, PTHREAD_CREATE_DETACHED);
|
||||
pthread_create(&t, &a, parent_watch, NULL);
|
||||
pthread_attr_destroy(&a);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
const char *sock_path = getenv("VKBRIDGE_SOCKET");
|
||||
const char *log_path = getenv("VKBRIDGE_SERVER_LOG");
|
||||
const char *vk_lib = getenv("VKBRIDGE_SERVER_VULKAN");
|
||||
const char *cache_dir = getenv("VKBRIDGE_CACHE_DIR");
|
||||
int selftest_only = 0;
|
||||
for (int i = 1; i < argc; i++) {
|
||||
if (!strcmp(argv[i], "--socket") && i + 1 < argc) sock_path = argv[++i];
|
||||
else if (!strcmp(argv[i], "--log") && i + 1 < argc) log_path = argv[++i];
|
||||
else if (!strcmp(argv[i], "--vulkan") && i + 1 < argc) vk_lib = argv[++i];
|
||||
else if (!strcmp(argv[i], "--cache-dir") && i + 1 < argc) cache_dir = argv[++i];
|
||||
else if (!strcmp(argv[i], "--selftest")) selftest_only = 1;
|
||||
else if (!strcmp(argv[i], "--verbose")) vkb_verbose = 1;
|
||||
else {
|
||||
usage();
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
if (getenv("VKBRIDGE_DEBUG")) vkb_verbose = 1;
|
||||
if (vkb_verbose) log_level = VKB_LOG_DEBUG;
|
||||
open_log(log_path);
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
signal(SIGSEGV, on_crash);
|
||||
signal(SIGBUS, on_crash);
|
||||
signal(SIGABRT, on_crash);
|
||||
signal(SIGILL, on_crash);
|
||||
signal(SIGFPE, on_crash);
|
||||
/* The server is the app's child: when the app dies, so does the session's GPU. Not with
|
||||
* PR_SET_PDEATHSIG: that fires when the parent THREAD exits, and Android's ProcessBuilder forks
|
||||
* from the session's start-up thread, which ends right after starting the guest (the server
|
||||
* was killed 6 ms into the first device run). The parent process is watched instead. */
|
||||
start_parent_watch();
|
||||
|
||||
if (!server_init(vk_lib, cache_dir)) return 1;
|
||||
if (selftest_only) return vkb_npds > 0 ? 0 : 1;
|
||||
|
||||
if (!sock_path) {
|
||||
usage();
|
||||
return 2;
|
||||
}
|
||||
int lfd = listen_on(sock_path);
|
||||
if (lfd < 0) return 1;
|
||||
VKB_INFO("listening on %s", sock_path);
|
||||
vkb_srv_serve(lfd);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,834 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Host-visible memory shared with the client.
|
||||
*
|
||||
* A Linux program maps Vulkan memory and writes to it directly; those writes must land in the
|
||||
* pages the GPU reads. The server makes such memory shareable in one of three ways, chosen per
|
||||
* GPU by a self-test at startup that checks the GPU and both CPU mappings really see the same
|
||||
* bytes:
|
||||
* hostptr the client creates a memfd, the server maps it and imports it
|
||||
* (VK_EXT_external_memory_host);
|
||||
* dmabuf the server allocates exportable memory and hands the client its dma-buf
|
||||
* (VK_EXT_external_memory_dma_buf), which the client maps;
|
||||
* ahb the server allocates a BLOB AHardwareBuffer, imports it, and hands the client the
|
||||
* dma-buf behind it (Android only);
|
||||
* dmaheap the server allocates from /dev/dma_heap (system-uncached, else system), imports that
|
||||
* dma-buf into the driver and hands it to the client - what GameNative's wrapper does on
|
||||
* Mali when the driver will not export one (Android; root-only on desktops).
|
||||
* VKBRIDGE_MEMORY=hostptr|dmabuf|dmaheap|ahb forces one.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#ifdef __ANDROID__
|
||||
#define VK_USE_PLATFORM_ANDROID_KHR 1
|
||||
#endif
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <linux/dma-heap.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifdef __ANDROID__
|
||||
#include <vulkan/vulkan_android.h>
|
||||
/* libnativewindow, opened at run time (getNativeHandle is not in the NDK headers). */
|
||||
typedef struct {
|
||||
uint32_t width, height, layers, format;
|
||||
uint64_t usage;
|
||||
uint32_t stride, rfu0;
|
||||
uint64_t rfu1;
|
||||
} vkb_ahb_desc;
|
||||
typedef struct {
|
||||
int version, numFds, numInts;
|
||||
int data[0];
|
||||
} vkb_native_handle;
|
||||
static int (*p_AHardwareBuffer_allocate)(const vkb_ahb_desc *, struct AHardwareBuffer **);
|
||||
static void (*p_AHardwareBuffer_release)(struct AHardwareBuffer *);
|
||||
static const vkb_native_handle *(*p_AHardwareBuffer_getNativeHandle)(const struct AHardwareBuffer *);
|
||||
#define AHB_FORMAT_BLOB 0x21
|
||||
#define AHB_USAGE_CPU_READ_OFTEN 3ull
|
||||
#define AHB_USAGE_CPU_WRITE_OFTEN (3ull << 4)
|
||||
#define AHB_USAGE_GPU_DATA_BUFFER (1ull << 24)
|
||||
|
||||
static int ahb_load(void)
|
||||
{
|
||||
static int state;
|
||||
if (state) return state > 0;
|
||||
void *h = dlopen("libnativewindow.so", RTLD_NOW);
|
||||
if (!h) h = dlopen("libandroid.so", RTLD_NOW);
|
||||
if (h) {
|
||||
p_AHardwareBuffer_allocate = dlsym(h, "AHardwareBuffer_allocate");
|
||||
p_AHardwareBuffer_release = dlsym(h, "AHardwareBuffer_release");
|
||||
p_AHardwareBuffer_getNativeHandle = dlsym(h, "AHardwareBuffer_getNativeHandle");
|
||||
}
|
||||
state = (p_AHardwareBuffer_allocate && p_AHardwareBuffer_release && p_AHardwareBuffer_getNativeHandle) ? 1 : -1;
|
||||
if (state < 0) VKB_WARN("AHardwareBuffer functions unavailable");
|
||||
return state > 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static const char *const ext_hostptr[] = {"VK_KHR_external_memory", "VK_EXT_external_memory_host"};
|
||||
static const char *const ext_dmabuf[] = {"VK_KHR_external_memory", "VK_KHR_external_memory_fd", "VK_EXT_external_memory_dma_buf"};
|
||||
#ifdef __ANDROID__
|
||||
static const char *const ext_ahb[] = {"VK_KHR_external_memory", "VK_ANDROID_external_memory_android_hardware_buffer",
|
||||
"VK_EXT_queue_family_foreign", "VK_KHR_sampler_ycbcr_conversion",
|
||||
"VK_KHR_dedicated_allocation", "VK_KHR_get_memory_requirements2"};
|
||||
#endif
|
||||
|
||||
const char *const *vkb_mem_required_extensions(uint32_t strategy, uint32_t *count)
|
||||
{
|
||||
switch (strategy) {
|
||||
case VKB_MEM_HOSTPTR: *count = 2; return ext_hostptr;
|
||||
case VKB_MEM_DMABUF: *count = 3; return ext_dmabuf;
|
||||
case VKB_MEM_DMAHEAP: *count = 3; return ext_dmabuf;
|
||||
#ifdef __ANDROID__
|
||||
case VKB_MEM_AHB: *count = 6; return ext_ahb;
|
||||
#endif
|
||||
default: *count = 0; return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static uint32_t strategy_handle_type(uint32_t s)
|
||||
{
|
||||
switch (s) {
|
||||
case VKB_MEM_HOSTPTR: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
|
||||
case VKB_MEM_DMABUF: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
|
||||
case VKB_MEM_DMAHEAP: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
|
||||
#ifdef __ANDROID__
|
||||
case VKB_MEM_AHB: return VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
|
||||
#endif
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int vkb_memfd(const char *name, size_t size)
|
||||
{
|
||||
int fd = (int)syscall(SYS_memfd_create, name, 1u /* MFD_CLOEXEC */);
|
||||
if (fd < 0) return -1;
|
||||
if (ftruncate(fd, (off_t)size) < 0) {
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ tracking */
|
||||
|
||||
static unsigned mem_hash(VkDeviceMemory m)
|
||||
{
|
||||
uint64_t v = (uint64_t)(uintptr_t)m;
|
||||
v ^= v >> 17;
|
||||
v *= 0x9E3779B97F4A7C15ull;
|
||||
return (unsigned)(v >> 56);
|
||||
}
|
||||
|
||||
void vkb_mem_track(vkb_srv_table *dev, vkb_srv_mem *m)
|
||||
{
|
||||
pthread_mutex_lock(&dev->lock);
|
||||
unsigned h = mem_hash(m->mem);
|
||||
m->next = dev->mems[h];
|
||||
dev->mems[h] = m;
|
||||
pthread_mutex_unlock(&dev->lock);
|
||||
}
|
||||
|
||||
vkb_srv_mem *vkb_mem_find(vkb_srv_table *dev, VkDeviceMemory mem, int remove)
|
||||
{
|
||||
pthread_mutex_lock(&dev->lock);
|
||||
vkb_srv_mem **pp = &dev->mems[mem_hash(mem)];
|
||||
while (*pp && (*pp)->mem != mem) pp = &(*pp)->next;
|
||||
vkb_srv_mem *m = *pp;
|
||||
if (m && remove) *pp = m->next;
|
||||
pthread_mutex_unlock(&dev->lock);
|
||||
return m;
|
||||
}
|
||||
|
||||
/* Frees the server-side resources of an allocation (the VkDeviceMemory must already be freed). */
|
||||
static void mem_release_backing(vkb_srv_mem *m)
|
||||
{
|
||||
if (m->host_ptr) munmap(m->host_ptr, m->host_len);
|
||||
#ifdef __ANDROID__
|
||||
if (m->ahb) p_AHardwareBuffer_release(m->ahb);
|
||||
#endif
|
||||
free(m);
|
||||
}
|
||||
|
||||
void vkb_mem_release(vkb_srv_table *dev, vkb_srv_mem *m)
|
||||
{
|
||||
if (m->mapped) dev->real.vkUnmapMemory(dev->device, m->mem);
|
||||
dev->real.vkFreeMemory(dev->device, m->mem, NULL);
|
||||
mem_release_backing(m);
|
||||
}
|
||||
|
||||
void vkb_mem_free_all(vkb_srv_table *dev)
|
||||
{
|
||||
for (int i = 0; i < 256; i++) {
|
||||
vkb_srv_mem *m = dev->mems[i];
|
||||
dev->mems[i] = NULL;
|
||||
while (m) {
|
||||
vkb_srv_mem *n = m->next;
|
||||
vkb_mem_release(dev, m);
|
||||
m = n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* The dma-heap the dmaheap strategy allocates from, opened once: system-uncached first (the GPU
|
||||
* and the client both write through it without cache maintenance), else the cached system heap. */
|
||||
static int dmaheap_fd(void)
|
||||
{
|
||||
static int fd = -2;
|
||||
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
pthread_mutex_lock(&lock);
|
||||
if (fd == -2) {
|
||||
const char *names[] = {"/dev/dma_heap/system-uncached", "/dev/dma_heap/system"};
|
||||
if (getenv("VKBRIDGE_DMAHEAP_CACHED")) names[0] = "/dev/dma_heap/system";
|
||||
fd = -1;
|
||||
for (int i = 0; i < 2 && fd < 0; i++) {
|
||||
fd = open(names[i], O_RDONLY | O_CLOEXEC);
|
||||
if (fd >= 0) VKB_INFO("dmaheap: allocating from %s", names[i]);
|
||||
else VKB_INFO("dmaheap: %s: %s", names[i], strerror(errno));
|
||||
}
|
||||
}
|
||||
int r = fd;
|
||||
pthread_mutex_unlock(&lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
/* Unlinks every structure of type t from the chain starting at *head. */
|
||||
static void chain_drop(const void **head, VkStructureType t)
|
||||
{
|
||||
const VkBaseInStructure **pp = (const VkBaseInStructure **)head;
|
||||
while (*pp) {
|
||||
if ((*pp)->sType == t) *pp = (*pp)->pNext;
|
||||
else pp = (const VkBaseInStructure **)&((VkBaseInStructure *)*pp)->pNext;
|
||||
}
|
||||
}
|
||||
|
||||
/* The driver's vkGetDeviceProcAddr (for entry points the dispatch table does not carry). */
|
||||
PFN_vkGetDeviceProcAddr vkb_mem_gdpa;
|
||||
|
||||
/* ------------------------------------------------------------------ allocation */
|
||||
|
||||
/*
|
||||
* Allocates shared memory with strategy `s`. `ai` is the app's (or the self-test's) allocate
|
||||
* info; for hostptr, `client_fd` is the client's memfd (consumed). On success *out_fd is the fd
|
||||
* to send to the client (-1 for hostptr, where the client already has its pages).
|
||||
*/
|
||||
static VkResult alloc_shared(const vkb_dispatch *dt, VkDevice dev, uint32_t s, const VkMemoryAllocateInfo *ai,
|
||||
int client_fd, vkb_srv_mem **out, int *out_fd)
|
||||
{
|
||||
*out_fd = -1;
|
||||
*out = NULL;
|
||||
vkb_srv_mem *m = calloc(1, sizeof(*m));
|
||||
if (!m) {
|
||||
if (client_fd >= 0) close(client_fd);
|
||||
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
}
|
||||
m->size = ai->allocationSize;
|
||||
m->type = ai->memoryTypeIndex;
|
||||
m->strategy = s;
|
||||
VkMemoryAllocateInfo info = *ai;
|
||||
VkResult r = VK_ERROR_FEATURE_NOT_PRESENT;
|
||||
switch (s) {
|
||||
case VKB_MEM_HOSTPTR: {
|
||||
if (client_fd < 0) break;
|
||||
void *p = mmap(NULL, (size_t)ai->allocationSize, PROT_READ | PROT_WRITE, MAP_SHARED, client_fd, 0);
|
||||
close(client_fd);
|
||||
client_fd = -1;
|
||||
if (p == MAP_FAILED) {
|
||||
VKB_ERR("hostptr: mmap of the client's memory failed: %s", strerror(errno));
|
||||
r = VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
break;
|
||||
}
|
||||
m->host_ptr = p;
|
||||
m->host_len = (size_t)ai->allocationSize;
|
||||
VkMemoryHostPointerPropertiesEXT hp = {VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT};
|
||||
if (!dt->vkGetMemoryHostPointerPropertiesEXT ||
|
||||
dt->vkGetMemoryHostPointerPropertiesEXT(dev, VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, p, &hp) != VK_SUCCESS ||
|
||||
!(hp.memoryTypeBits & (1u << ai->memoryTypeIndex))) {
|
||||
r = VK_ERROR_INVALID_EXTERNAL_HANDLE;
|
||||
break;
|
||||
}
|
||||
VkImportMemoryHostPointerInfoEXT imp = {VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, info.pNext,
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, p};
|
||||
info.pNext = &imp;
|
||||
r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem);
|
||||
break;
|
||||
}
|
||||
case VKB_MEM_DMABUF: {
|
||||
VkExportMemoryAllocateInfo exp = {VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, info.pNext,
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT};
|
||||
/* An export the app asked for itself is merged rather than duplicated. */
|
||||
for (VkBaseOutStructure *b = (VkBaseOutStructure *)info.pNext; b; b = b->pNext) {
|
||||
if (b->sType == VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO) {
|
||||
((VkExportMemoryAllocateInfo *)b)->handleTypes |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
|
||||
exp.sType = VK_STRUCTURE_TYPE_MAX_ENUM;
|
||||
}
|
||||
}
|
||||
if (exp.sType != VK_STRUCTURE_TYPE_MAX_ENUM) info.pNext = &exp;
|
||||
r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem);
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_INFO("dmabuf: exportable allocation of %llu bytes (type %u) failed: %d", (unsigned long long)info.allocationSize,
|
||||
info.memoryTypeIndex, r);
|
||||
break;
|
||||
}
|
||||
VkMemoryGetFdInfoKHR gi = {VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, NULL, m->mem, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT};
|
||||
int fd = -1;
|
||||
VkResult fr = dt->vkGetMemoryFdKHR ? dt->vkGetMemoryFdKHR(dev, &gi, &fd) : VK_ERROR_EXTENSION_NOT_PRESENT;
|
||||
if (fr != VK_SUCCESS || fd < 0) {
|
||||
VKB_INFO("dmabuf: vkGetMemoryFdKHR %s: %d (fd %d)", dt->vkGetMemoryFdKHR ? "failed" : "not loaded", fr, fd);
|
||||
dt->vkFreeMemory(dev, m->mem, NULL);
|
||||
m->mem = VK_NULL_HANDLE;
|
||||
r = VK_ERROR_INVALID_EXTERNAL_HANDLE;
|
||||
break;
|
||||
}
|
||||
*out_fd = fd;
|
||||
break;
|
||||
}
|
||||
case VKB_MEM_DMAHEAP: {
|
||||
int hfd = dmaheap_fd();
|
||||
if (hfd < 0) break;
|
||||
uint64_t len = (ai->allocationSize + 4095) & ~4095ull;
|
||||
struct dma_heap_allocation_data hd = {len, 0, O_RDWR | O_CLOEXEC, 0};
|
||||
if (ioctl(hfd, DMA_HEAP_IOCTL_ALLOC, &hd) < 0) {
|
||||
VKB_INFO("dmaheap: allocating %llu bytes failed: %s", (unsigned long long)len, strerror(errno));
|
||||
r = VK_ERROR_OUT_OF_DEVICE_MEMORY;
|
||||
break;
|
||||
}
|
||||
int fd = (int)hd.fd;
|
||||
VkMemoryFdPropertiesKHR fp = {VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR};
|
||||
VkResult pr = dt->vkGetMemoryFdPropertiesKHR
|
||||
? dt->vkGetMemoryFdPropertiesKHR(dev, VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, fd, &fp)
|
||||
: VK_ERROR_EXTENSION_NOT_PRESENT;
|
||||
if (pr != VK_SUCCESS || !(fp.memoryTypeBits & (1u << ai->memoryTypeIndex))) {
|
||||
VKB_INFO("dmaheap: fd properties %d, memory types 0x%x (want type %u)", pr, fp.memoryTypeBits, ai->memoryTypeIndex);
|
||||
close(fd);
|
||||
r = VK_ERROR_INVALID_EXTERNAL_HANDLE;
|
||||
break;
|
||||
}
|
||||
/* The import takes its own fd; ours goes to the client. A dedicated-allocation struct
|
||||
* with an imported dma-buf crashes some Mali drivers (GameNative mesa PR #8): dropped. */
|
||||
int imp_fd = fcntl(fd, F_DUPFD_CLOEXEC, 0);
|
||||
VkImportMemoryFdInfoKHR imp = {VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, info.pNext,
|
||||
VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, imp_fd};
|
||||
chain_drop(&imp.pNext, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
|
||||
chain_drop(&imp.pNext, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
|
||||
info.pNext = &imp;
|
||||
info.allocationSize = len;
|
||||
r = imp_fd >= 0 ? dt->vkAllocateMemory(dev, &info, NULL, &m->mem) : VK_ERROR_TOO_MANY_OBJECTS;
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_INFO("dmaheap: import of %llu bytes failed: %d", (unsigned long long)len, r);
|
||||
if (imp_fd >= 0) close(imp_fd); /* a failed import leaves the fd with us */
|
||||
close(fd);
|
||||
break;
|
||||
}
|
||||
*out_fd = fd;
|
||||
break;
|
||||
}
|
||||
#ifdef __ANDROID__
|
||||
case VKB_MEM_AHB: {
|
||||
if (!ahb_load()) break;
|
||||
/* Through the device's own vkGetDeviceProcAddr: Android's loader answers NULL for it from
|
||||
* vkGetInstanceProcAddr(NULL, ...), which desktop loaders allow (the first device run). */
|
||||
PFN_vkGetAndroidHardwareBufferPropertiesANDROID get_props = NULL;
|
||||
if (vkb_mem_gdpa)
|
||||
get_props = (PFN_vkGetAndroidHardwareBufferPropertiesANDROID)vkb_mem_gdpa(dev, "vkGetAndroidHardwareBufferPropertiesANDROID");
|
||||
if (!get_props) {
|
||||
VKB_INFO("ahb: vkGetAndroidHardwareBufferPropertiesANDROID not found");
|
||||
break;
|
||||
}
|
||||
uint64_t sz = ai->allocationSize;
|
||||
if (sz > 0xFFFFFFFFull) {
|
||||
r = VK_ERROR_OUT_OF_DEVICE_MEMORY;
|
||||
break;
|
||||
}
|
||||
/* CPU usage decides how gralloc caches the pages; VKBRIDGE_AHB_RARELY=1 asks for uncached. */
|
||||
uint64_t cpu = getenv("VKBRIDGE_AHB_RARELY") ? (2ull | (2ull << 4)) : (AHB_USAGE_CPU_READ_OFTEN | AHB_USAGE_CPU_WRITE_OFTEN);
|
||||
vkb_ahb_desc d = {(uint32_t)sz, 1, 1, AHB_FORMAT_BLOB, cpu | AHB_USAGE_GPU_DATA_BUFFER, 0, 0, 0};
|
||||
struct AHardwareBuffer *ahb = NULL;
|
||||
int ar = p_AHardwareBuffer_allocate(&d, &ahb);
|
||||
if (ar != 0 || !ahb) {
|
||||
VKB_INFO("ahb: AHardwareBuffer_allocate(%u bytes) failed: %d", (unsigned)sz, ar);
|
||||
r = VK_ERROR_OUT_OF_DEVICE_MEMORY;
|
||||
break;
|
||||
}
|
||||
m->ahb = ahb;
|
||||
VkAndroidHardwareBufferPropertiesANDROID props = {VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID};
|
||||
VkResult pr = get_props(dev, ahb, &props);
|
||||
if (pr != VK_SUCCESS || !(props.memoryTypeBits & (1u << ai->memoryTypeIndex))) {
|
||||
VKB_INFO("ahb: properties %d, memory types 0x%x (want type %u)", pr, props.memoryTypeBits, ai->memoryTypeIndex);
|
||||
r = VK_ERROR_INVALID_EXTERNAL_HANDLE;
|
||||
break;
|
||||
}
|
||||
VkImportAndroidHardwareBufferInfoANDROID imp = {VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, info.pNext, ahb};
|
||||
info.pNext = &imp;
|
||||
info.allocationSize = props.allocationSize;
|
||||
r = dt->vkAllocateMemory(dev, &info, NULL, &m->mem);
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_INFO("ahb: import of %llu bytes failed: %d", (unsigned long long)info.allocationSize, r);
|
||||
break;
|
||||
}
|
||||
const vkb_native_handle *nh = p_AHardwareBuffer_getNativeHandle(ahb);
|
||||
if (!nh || nh->numFds < 1) {
|
||||
VKB_INFO("ahb: no fd in the native handle (%d)", nh ? nh->numFds : -1);
|
||||
dt->vkFreeMemory(dev, m->mem, NULL);
|
||||
m->mem = VK_NULL_HANDLE;
|
||||
r = VK_ERROR_INVALID_EXTERNAL_HANDLE;
|
||||
break;
|
||||
}
|
||||
/* Mali's gralloc can put more than one fd in the handle (metadata beside the pages): the
|
||||
* memory is the one at least as large as the allocation. */
|
||||
int pick = -1;
|
||||
for (int i = 0; i < nh->numFds && pick < 0; i++) {
|
||||
off_t end = lseek(nh->data[i], 0, SEEK_END);
|
||||
if (end >= (off_t)sz) pick = nh->data[i];
|
||||
if (nh->numFds > 1) VKB_INFO("ahb: handle fd %d of %d is %lld bytes", i + 1, nh->numFds, (long long)end);
|
||||
}
|
||||
if (pick < 0) {
|
||||
VKB_INFO("ahb: no fd in the handle covers %llu bytes", (unsigned long long)sz);
|
||||
dt->vkFreeMemory(dev, m->mem, NULL);
|
||||
m->mem = VK_NULL_HANDLE;
|
||||
r = VK_ERROR_INVALID_EXTERNAL_HANDLE;
|
||||
break;
|
||||
}
|
||||
*out_fd = fcntl(pick, F_DUPFD_CLOEXEC, 0);
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (client_fd >= 0) close(client_fd);
|
||||
if (r != VK_SUCCESS) {
|
||||
mem_release_backing(m);
|
||||
return r;
|
||||
}
|
||||
*out = m;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ handlers */
|
||||
|
||||
static void close_import_fds(const void *pNext)
|
||||
{
|
||||
for (const VkBaseInStructure *b = pNext; b; b = b->pNext)
|
||||
if (b->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) vkb_close_fd(((const VkImportMemoryFdInfoKHR *)b)->fd);
|
||||
}
|
||||
|
||||
void vkb_sv_vkAllocateMemory(vkb_srv_call *c)
|
||||
{
|
||||
VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
VkMemoryAllocateInfo ai;
|
||||
int have = vkb_dec_u8(&c->d);
|
||||
if (have) vkb_dec_VkMemoryAllocateInfo(&c->d, &ai);
|
||||
uint32_t mode = vkb_dec_u32(&c->d);
|
||||
int client_fd = vkb_dec_fd(&c->d);
|
||||
vkb_srv_table *t = c->table;
|
||||
if (c->d.err || !have || !t || !t->is_device || t->device != dev) {
|
||||
if (client_fd >= 0) close(client_fd);
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
VkResult r;
|
||||
vkb_srv_mem *m = NULL;
|
||||
int out_fd = -1;
|
||||
if (mode == VKB_ALLOC_SHARED) {
|
||||
uint32_t s = t->pd ? t->pd->info.strategy : VKB_MEM_NONE;
|
||||
r = alloc_shared(c->dt, dev, s, &ai, client_fd, &m, &out_fd);
|
||||
if (r != VK_SUCCESS) VKB_WARN("shared allocation of %llu bytes (type %u, %s) failed: %d",
|
||||
(unsigned long long)ai.allocationSize, ai.memoryTypeIndex, vkb_mem_strategy_name(s), r);
|
||||
} else {
|
||||
if (client_fd >= 0) close(client_fd);
|
||||
m = calloc(1, sizeof(*m));
|
||||
m->size = ai.allocationSize;
|
||||
m->type = ai.memoryTypeIndex;
|
||||
r = c->dt->vkAllocateMemory(dev, &ai, NULL, &m->mem);
|
||||
if (r != VK_SUCCESS) {
|
||||
close_import_fds(ai.pNext);
|
||||
free(m);
|
||||
m = NULL;
|
||||
}
|
||||
}
|
||||
if (m) vkb_mem_track(t, m);
|
||||
vkb_enc_u32(&c->r, (uint32_t)r);
|
||||
vkb_enc_u64(&c->r, m ? (uint64_t)(uintptr_t)m->mem : 0);
|
||||
vkb_enc_fd(&c->r, out_fd);
|
||||
if (out_fd >= 0) vkb_srv_close_after_send(c, out_fd);
|
||||
vkb_enc_u64(&c->r, m ? (uint64_t)m->size : 0);
|
||||
}
|
||||
|
||||
void vkb_sv_vkFreeMemory(vkb_srv_call *c)
|
||||
{
|
||||
VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
VkDeviceMemory mem;
|
||||
vkb_dec_bytes(&c->d, &mem, sizeof(mem));
|
||||
vkb_srv_table *t = c->table;
|
||||
if (c->d.err || !t || !t->is_device || t->device != dev) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
if (!mem) return;
|
||||
vkb_srv_mem *m = vkb_mem_find(t, mem, 1);
|
||||
if (m) {
|
||||
vkb_mem_release(t, m);
|
||||
} else {
|
||||
VKB_WARN("vkFreeMemory of untracked memory");
|
||||
c->dt->vkFreeMemory(dev, mem, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
static VkResult ensure_server_map(vkb_srv_table *t, vkb_srv_mem *m)
|
||||
{
|
||||
if (m->mapped) return VK_SUCCESS;
|
||||
pthread_mutex_lock(&t->lock);
|
||||
VkResult r = VK_SUCCESS;
|
||||
if (!m->mapped) r = t->real.vkMapMemory(t->device, m->mem, 0, VK_WHOLE_SIZE, 0, &m->mapped);
|
||||
pthread_mutex_unlock(&t->lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void flush_or_invalidate(vkb_srv_call *c, int flush)
|
||||
{
|
||||
VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
uint32_t n = vkb_dec_u32(&c->d);
|
||||
vkb_srv_table *t = c->table;
|
||||
if (c->d.err || !t || !t->is_device || t->device != dev || n > 65536) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
VkMappedMemoryRange *ranges = vkb_dec_alloc(&c->d, (n ? n : 1) * sizeof(*ranges));
|
||||
for (uint32_t i = 0; ranges && i < n; i++) vkb_dec_VkMappedMemoryRange(&c->d, &ranges[i]);
|
||||
if (c->d.err) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
VkResult r = VK_SUCCESS;
|
||||
for (uint32_t i = 0; i < n && r == VK_SUCCESS; i++) {
|
||||
vkb_srv_mem *m = vkb_mem_find(t, ranges[i].memory, 0);
|
||||
if (m) r = ensure_server_map(t, m);
|
||||
}
|
||||
if (r == VK_SUCCESS && n) {
|
||||
r = flush ? c->dt->vkFlushMappedMemoryRanges(dev, n, ranges) : c->dt->vkInvalidateMappedMemoryRanges(dev, n, ranges);
|
||||
}
|
||||
vkb_enc_u32(&c->r, (uint32_t)r);
|
||||
}
|
||||
|
||||
void vkb_sv_vkFlushMappedMemoryRanges(vkb_srv_call *c) { flush_or_invalidate(c, 1); }
|
||||
void vkb_sv_vkInvalidateMappedMemoryRanges(vkb_srv_call *c) { flush_or_invalidate(c, 0); }
|
||||
|
||||
/* ------------------------------------------------------------------ self-test */
|
||||
|
||||
typedef struct {
|
||||
const vkb_dispatch *idt;
|
||||
vkb_dispatch dt;
|
||||
VkPhysicalDevice pd;
|
||||
VkDevice dev;
|
||||
VkQueue queue;
|
||||
VkCommandPool pool;
|
||||
uint32_t qf;
|
||||
VkPhysicalDeviceMemoryProperties mp;
|
||||
VkDeviceSize import_align;
|
||||
} selftest;
|
||||
|
||||
static int submit_and_wait(selftest *st, VkCommandBuffer cb)
|
||||
{
|
||||
VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
|
||||
VkFence f;
|
||||
if (st->dt.vkCreateFence(st->dev, &fci, NULL, &f) != VK_SUCCESS) return 0;
|
||||
VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO, NULL, 0, NULL, NULL, 1, &cb, 0, NULL};
|
||||
int ok = st->dt.vkQueueSubmit(st->queue, 1, &si, f) == VK_SUCCESS &&
|
||||
st->dt.vkWaitForFences(st->dev, 1, &f, VK_TRUE, 5000000000ull) == VK_SUCCESS;
|
||||
st->dt.vkDestroyFence(st->dev, f, NULL);
|
||||
return ok;
|
||||
}
|
||||
|
||||
#define TEST_SIZE (256u * 1024u)
|
||||
|
||||
/* One allocation of `type` with strategy `s`, checked from both sides. 1 = shared and coherent
|
||||
* (no flush needed), 2 = shared when flushed, 0 = not shared. */
|
||||
static int test_type_mode(selftest *st, uint32_t s, uint32_t type, int no_flush);
|
||||
|
||||
/* Without flushes first: imported pages from an uncached heap are coherent in practice even where
|
||||
* the driver's type does not say HOST_COHERENT (Mali-G720: dma-heap imports land in type 1,
|
||||
* HOST_CACHED without COHERENT, and pass with no flush). Only if that fails, with flushes. */
|
||||
static int test_type(selftest *st, uint32_t s, uint32_t type)
|
||||
{
|
||||
int coherent_flag = (st->mp.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
|
||||
if (!coherent_flag && !getenv("VKBRIDGE_SELFTEST_NOFLUSH")) {
|
||||
int r = test_type_mode(st, s, type, 1);
|
||||
if (r) {
|
||||
VKB_INFO(" %s, type %u: coherent in practice (no flushes needed)", vkb_mem_strategy_name(s), type);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return test_type_mode(st, s, type, 0);
|
||||
}
|
||||
|
||||
static int test_type_mode(selftest *st, uint32_t s, uint32_t type, int no_flush)
|
||||
{
|
||||
const vkb_dispatch *dt = &st->dt;
|
||||
int result = 0;
|
||||
VkExternalMemoryBufferCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, NULL, strategy_handle_type(s)};
|
||||
VkBufferCreateInfo bci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, &ext, 0, TEST_SIZE,
|
||||
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
|
||||
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
|
||||
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
||||
VK_SHARING_MODE_EXCLUSIVE, 0, NULL};
|
||||
VkBuffer buf = VK_NULL_HANDLE;
|
||||
if (dt->vkCreateBuffer(st->dev, &bci, NULL, &buf) != VK_SUCCESS) return 0;
|
||||
VkMemoryRequirements req;
|
||||
dt->vkGetBufferMemoryRequirements(st->dev, buf, &req);
|
||||
if (!(req.memoryTypeBits & (1u << type))) {
|
||||
dt->vkDestroyBuffer(st->dev, buf, NULL);
|
||||
return 0;
|
||||
}
|
||||
VkDeviceSize size = req.size;
|
||||
if (s == VKB_MEM_HOSTPTR) size = (size + st->import_align - 1) & ~(st->import_align - 1);
|
||||
VkMemoryAllocateInfo ai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, size, type};
|
||||
int cfd = -1;
|
||||
if (s == VKB_MEM_HOSTPTR) {
|
||||
cfd = vkb_memfd("vkbridge-selftest", (size_t)size);
|
||||
if (cfd < 0) {
|
||||
dt->vkDestroyBuffer(st->dev, buf, NULL);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
int keep_fd = s == VKB_MEM_HOSTPTR ? fcntl(cfd, F_DUPFD_CLOEXEC, 0) : -1;
|
||||
vkb_srv_mem *m = NULL;
|
||||
int out_fd = -1;
|
||||
VkResult r = alloc_shared(dt, st->dev, s, &ai, cfd, &m, &out_fd);
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_INFO(" %s, type %u: allocation failed (%d)", vkb_mem_strategy_name(s), type, r);
|
||||
if (keep_fd >= 0) close(keep_fd);
|
||||
dt->vkDestroyBuffer(st->dev, buf, NULL);
|
||||
return 0;
|
||||
}
|
||||
int map_fd = s == VKB_MEM_HOSTPTR ? keep_fd : out_fd;
|
||||
uint8_t *cmap = mmap(NULL, (size_t)m->size, PROT_READ | PROT_WRITE, MAP_SHARED, map_fd, 0);
|
||||
if (map_fd >= 0) close(map_fd);
|
||||
void *smap = NULL;
|
||||
if (cmap == MAP_FAILED) {
|
||||
VKB_INFO(" %s, type %u: the client cannot map the memory (%s)", vkb_mem_strategy_name(s), type, strerror(errno));
|
||||
cmap = NULL;
|
||||
goto out;
|
||||
}
|
||||
if (dt->vkBindBufferMemory(st->dev, buf, m->mem, 0) != VK_SUCCESS ||
|
||||
dt->vkMapMemory(st->dev, m->mem, 0, VK_WHOLE_SIZE, 0, &smap) != VK_SUCCESS) {
|
||||
VKB_INFO(" %s, type %u: bind/map failed", vkb_mem_strategy_name(s), type);
|
||||
goto out;
|
||||
}
|
||||
int coherent = (st->mp.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) != 0;
|
||||
/* VKBRIDGE_SELFTEST_NOFLUSH=1 forces it for every type. */
|
||||
if (no_flush || getenv("VKBRIDGE_SELFTEST_NOFLUSH")) coherent = 1;
|
||||
VkMappedMemoryRange whole = {VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, NULL, m->mem, 0, VK_WHOLE_SIZE};
|
||||
|
||||
/* 1: the two CPU mappings are the same pages. */
|
||||
for (uint32_t i = 0; i < TEST_SIZE / 4; i += 997) ((volatile uint32_t *)cmap)[i] = 0x11220000u + i;
|
||||
__sync_synchronize();
|
||||
for (uint32_t i = 0; i < TEST_SIZE / 4; i += 997) {
|
||||
if (((volatile uint32_t *)smap)[i] != 0x11220000u + i) {
|
||||
VKB_INFO(" %s, type %u: CPU mappings differ at word %u", vkb_mem_strategy_name(s), type, i);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
/* 2: GPU writes, client reads. 3: client writes, GPU copies, client reads the copy. */
|
||||
for (uint32_t i = TEST_SIZE / 8; i < TEST_SIZE / 8 + TEST_SIZE / 32; i++) ((volatile uint32_t *)cmap)[i] = 0x5a000000u ^ (i * 2654435761u);
|
||||
if (!coherent) dt->vkFlushMappedMemoryRanges(st->dev, 1, &whole);
|
||||
VkCommandBufferAllocateInfo cai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, NULL, st->pool, VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1};
|
||||
VkCommandBuffer cb;
|
||||
if (dt->vkAllocateCommandBuffers(st->dev, &cai, &cb) != VK_SUCCESS) goto out;
|
||||
VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, NULL};
|
||||
dt->vkBeginCommandBuffer(cb, &bi);
|
||||
dt->vkCmdFillBuffer(cb, buf, 0, TEST_SIZE / 8, 0xA5A5A5A5u);
|
||||
/* Layout (bytes): [0, N/8) GPU fill; [N/2, N/2 + N/8) written by the client and copied by
|
||||
* the GPU to [3N/4, 3N/4 + N/8). */
|
||||
VkBufferCopy region = {TEST_SIZE / 2, TEST_SIZE / 4 * 3, TEST_SIZE / 8};
|
||||
dt->vkCmdCopyBuffer(cb, buf, buf, 1, ®ion);
|
||||
VkMemoryBarrier mb = {VK_STRUCTURE_TYPE_MEMORY_BARRIER, NULL, VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT};
|
||||
dt->vkCmdPipelineBarrier(cb, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &mb, 0, NULL, 0, NULL);
|
||||
dt->vkEndCommandBuffer(cb);
|
||||
int submitted = submit_and_wait(st, cb);
|
||||
dt->vkFreeCommandBuffers(st->dev, st->pool, 1, &cb);
|
||||
if (!submitted) {
|
||||
VKB_INFO(" %s, type %u: GPU submission failed", vkb_mem_strategy_name(s), type);
|
||||
goto out;
|
||||
}
|
||||
if (!coherent) dt->vkInvalidateMappedMemoryRanges(st->dev, 1, &whole);
|
||||
for (uint32_t i = 0; i < TEST_SIZE / 32; i++) {
|
||||
if (((volatile uint32_t *)cmap)[i] != 0xA5A5A5A5u) {
|
||||
VKB_INFO(" %s, type %u: the client does not see a GPU write (word %u = 0x%08x)", vkb_mem_strategy_name(s), type, i,
|
||||
((volatile uint32_t *)cmap)[i]);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
for (uint32_t i = 0; i < TEST_SIZE / 32; i++) {
|
||||
uint32_t want = 0x5a000000u ^ ((TEST_SIZE / 8 + i) * 2654435761u);
|
||||
uint32_t got = ((volatile uint32_t *)cmap)[TEST_SIZE / 16 * 3 + i];
|
||||
if (got != want) {
|
||||
VKB_INFO(" %s, type %u: the GPU does not see a client write (word %u = 0x%08x, want 0x%08x)", vkb_mem_strategy_name(s),
|
||||
type, i, got, want);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
result = coherent ? 1 : 2;
|
||||
VKB_INFO(" %s, type %u (flags 0x%x): shared OK%s", vkb_mem_strategy_name(s), type, st->mp.memoryTypes[type].propertyFlags,
|
||||
coherent ? ", coherent" : ", needs flushes");
|
||||
out:
|
||||
if (cmap) munmap(cmap, (size_t)m->size);
|
||||
if (smap) dt->vkUnmapMemory(st->dev, m->mem);
|
||||
dt->vkDestroyBuffer(st->dev, buf, NULL);
|
||||
dt->vkFreeMemory(st->dev, m->mem, NULL);
|
||||
mem_release_backing(m);
|
||||
return result;
|
||||
}
|
||||
|
||||
static int has_ext(const VkExtensionProperties *e, uint32_t n, const char *name)
|
||||
{
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
if (!strcmp(e[i].extensionName, name)) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* What the driver says it can do with each kind of external buffer memory (the device runs). */
|
||||
static void log_external_props(const vkb_dispatch *idt, VkPhysicalDevice pd)
|
||||
{
|
||||
if (!idt->vkGetPhysicalDeviceExternalBufferProperties) return;
|
||||
static const struct { uint32_t bit; const char *name; } types[] = {
|
||||
{VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, "opaque fd"},
|
||||
{VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, "dma-buf"},
|
||||
{VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, "host allocation"},
|
||||
#ifdef __ANDROID__
|
||||
{VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, "AHB"},
|
||||
#endif
|
||||
};
|
||||
for (size_t i = 0; i < sizeof(types) / sizeof(types[0]); i++) {
|
||||
VkPhysicalDeviceExternalBufferInfo bi = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, NULL, 0,
|
||||
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
|
||||
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
|
||||
(VkExternalMemoryHandleTypeFlagBits)types[i].bit};
|
||||
VkExternalBufferProperties ep = {VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES};
|
||||
idt->vkGetPhysicalDeviceExternalBufferProperties(pd, &bi, &ep);
|
||||
const VkExternalMemoryProperties *p = &ep.externalMemoryProperties;
|
||||
VKB_INFO("external buffers, %s: features 0x%x (%s%s%s), export from 0x%x, compatible 0x%x", types[i].name,
|
||||
p->externalMemoryFeatures,
|
||||
p->externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT ? "dedicated-only " : "",
|
||||
p->externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT ? "exportable " : "",
|
||||
p->externalMemoryFeatures & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT ? "importable" : "",
|
||||
p->exportFromImportedHandleTypes, p->compatibleHandleTypes);
|
||||
}
|
||||
}
|
||||
|
||||
void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch *idt, VkPhysicalDevice pd)
|
||||
{
|
||||
selftest st;
|
||||
memset(&st, 0, sizeof(st));
|
||||
st.idt = idt;
|
||||
st.pd = pd;
|
||||
idt->vkGetPhysicalDeviceMemoryProperties(pd, &st.mp);
|
||||
|
||||
uint32_t nq = 0;
|
||||
idt->vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, NULL);
|
||||
VkQueueFamilyProperties qp[16];
|
||||
if (nq > 16) nq = 16;
|
||||
idt->vkGetPhysicalDeviceQueueFamilyProperties(pd, &nq, qp);
|
||||
st.qf = 0;
|
||||
for (uint32_t i = 0; i < nq; i++)
|
||||
if (qp[i].queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)) {
|
||||
st.qf = i;
|
||||
break;
|
||||
}
|
||||
|
||||
uint32_t ne = 0;
|
||||
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &ne, NULL);
|
||||
VkExtensionProperties *ex = calloc(ne ? ne : 1, sizeof(*ex));
|
||||
idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &ne, ex);
|
||||
|
||||
uint32_t candidates[4];
|
||||
int nc = 0;
|
||||
const char *force = getenv("VKBRIDGE_MEMORY");
|
||||
/* GameNative's order on Mali: the driver's own export, a dma-heap import, then an AHB. */
|
||||
uint32_t order[] = {VKB_MEM_HOSTPTR, VKB_MEM_DMABUF, VKB_MEM_DMAHEAP, VKB_MEM_AHB};
|
||||
for (int i = 0; i < 4; i++) {
|
||||
uint32_t s = order[i];
|
||||
if (force && strcmp(force, vkb_mem_strategy_name(s))) continue;
|
||||
uint32_t n;
|
||||
const char *const *req = vkb_mem_required_extensions(s, &n);
|
||||
if (!req) continue;
|
||||
int ok = 1;
|
||||
for (uint32_t j = 0; j < n; j++)
|
||||
if (strcmp(req[j], "VK_KHR_external_memory") && strcmp(req[j], "VK_KHR_sampler_ycbcr_conversion") &&
|
||||
strcmp(req[j], "VK_KHR_dedicated_allocation") && strcmp(req[j], "VK_KHR_get_memory_requirements2") &&
|
||||
!has_ext(ex, ne, req[j]))
|
||||
ok = 0;
|
||||
if (ok) candidates[nc++] = s;
|
||||
else VKB_INFO("memory sharing: %s unavailable (driver lacks its extensions)", vkb_mem_strategy_name(s));
|
||||
}
|
||||
|
||||
/* One test device with every candidate's extensions. */
|
||||
const char *exts[16];
|
||||
uint32_t nx = 0;
|
||||
for (int i = 0; i < nc; i++) {
|
||||
uint32_t n;
|
||||
const char *const *req = vkb_mem_required_extensions(candidates[i], &n);
|
||||
for (uint32_t j = 0; j < n; j++) {
|
||||
if (!has_ext(ex, ne, req[j])) continue;
|
||||
int dup = 0;
|
||||
for (uint32_t q = 0; q < nx; q++) dup |= !strcmp(exts[q], req[j]);
|
||||
if (!dup && nx < 16) exts[nx++] = req[j];
|
||||
}
|
||||
}
|
||||
free(ex);
|
||||
float prio = 1.0f;
|
||||
VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, NULL, 0, st.qf, 1, &prio};
|
||||
VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, NULL, 0, 1, &qci, 0, NULL, nx, exts, NULL};
|
||||
if (idt->vkCreateDevice(pd, &dci, NULL, &st.dev) != VK_SUCCESS) {
|
||||
VKB_ERR("memory self-test: cannot create a device");
|
||||
return;
|
||||
}
|
||||
st.dt = *idt;
|
||||
PFN_vkGetDeviceProcAddr gdpa = (PFN_vkGetDeviceProcAddr)vkb_gipa(inst, "vkGetDeviceProcAddr");
|
||||
vkb_mem_gdpa = gdpa;
|
||||
log_external_props(idt, pd);
|
||||
vkb_dispatch_load_device(&st.dt, gdpa, st.dev);
|
||||
st.dt.vkGetDeviceQueue(st.dev, st.qf, 0, &st.queue);
|
||||
VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, NULL, 0, st.qf};
|
||||
st.dt.vkCreateCommandPool(st.dev, &pci, NULL, &st.pool);
|
||||
|
||||
VkPhysicalDeviceExternalMemoryHostPropertiesEXT hostp = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT};
|
||||
VkPhysicalDeviceProperties2 p2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &hostp};
|
||||
idt->vkGetPhysicalDeviceProperties2(pd, &p2);
|
||||
st.import_align = hostp.minImportedHostPointerAlignment ? hostp.minImportedHostPointerAlignment : 4096;
|
||||
if (st.import_align < 4096) st.import_align = 4096;
|
||||
|
||||
k->info.strategy = VKB_MEM_NONE;
|
||||
for (int i = 0; i < nc; i++) {
|
||||
uint32_t s = candidates[i];
|
||||
uint32_t shareable = 0, coherent = 0;
|
||||
for (uint32_t t = 0; t < st.mp.memoryTypeCount; t++) {
|
||||
if (!(st.mp.memoryTypes[t].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) continue;
|
||||
if (st.mp.memoryTypes[t].propertyFlags & VK_MEMORY_PROPERTY_PROTECTED_BIT) continue;
|
||||
int res = test_type(&st, s, t);
|
||||
if (res) shareable |= 1u << t;
|
||||
if (res == 1) coherent |= 1u << t;
|
||||
}
|
||||
if (coherent) {
|
||||
k->info.strategy = s;
|
||||
k->info.buffer_handle_types = strategy_handle_type(s);
|
||||
k->info.shareable_types = shareable;
|
||||
k->info.coherent_types = coherent;
|
||||
k->info.import_alignment = st.import_align;
|
||||
break;
|
||||
}
|
||||
VKB_INFO("memory sharing: %s failed the self-test", vkb_mem_strategy_name(s));
|
||||
}
|
||||
if (k->info.strategy == VKB_MEM_NONE)
|
||||
VKB_ERR("memory sharing: no method works on %s; Linux programs will get no host-visible memory", k->name);
|
||||
|
||||
st.dt.vkDestroyCommandPool(st.dev, st.pool, NULL);
|
||||
st.dt.vkDestroyDevice(st.dev, NULL);
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Descriptor update templates. The client repacks the app's data to the layout of the template
|
||||
* it created on the server (entries rewritten to packed offsets), so the blob is used as is.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
void vkb_sv_vkbDescUpdateRaw(vkb_srv_call *c)
|
||||
{
|
||||
VkDevice dev = (VkDevice)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
VkDescriptorSet set;
|
||||
VkDescriptorUpdateTemplate tmpl;
|
||||
vkb_dec_bytes(&c->d, &set, sizeof(set));
|
||||
vkb_dec_bytes(&c->d, &tmpl, sizeof(tmpl));
|
||||
size_t n = 0;
|
||||
const void *data = vkb_dec_blob(&c->d, &n);
|
||||
if (c->d.err || !c->table) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
if (!c->dt->vkUpdateDescriptorSetWithTemplate) {
|
||||
vkb_srv_missing(c, "vkUpdateDescriptorSetWithTemplate");
|
||||
return;
|
||||
}
|
||||
c->dt->vkUpdateDescriptorSetWithTemplate(dev, set, tmpl, data);
|
||||
}
|
||||
|
||||
void vkb_sv_vkbPushDescRaw(vkb_srv_call *c)
|
||||
{
|
||||
VkCommandBuffer cb = (VkCommandBuffer)(uintptr_t)vkb_dec_u64(&c->d);
|
||||
VkDescriptorUpdateTemplate tmpl;
|
||||
VkPipelineLayout layout;
|
||||
vkb_dec_bytes(&c->d, &tmpl, sizeof(tmpl));
|
||||
vkb_dec_bytes(&c->d, &layout, sizeof(layout));
|
||||
uint32_t set = vkb_dec_u32(&c->d);
|
||||
size_t n = 0;
|
||||
const void *data = vkb_dec_blob(&c->d, &n);
|
||||
if (c->d.err || !c->table) {
|
||||
vkb_srv_bad_message(c);
|
||||
return;
|
||||
}
|
||||
if (!c->dt->vkCmdPushDescriptorSetWithTemplate) {
|
||||
vkb_srv_missing(c, "vkCmdPushDescriptorSetWithTemplate");
|
||||
return;
|
||||
}
|
||||
extern __thread size_t vkb_emu_push_size;
|
||||
vkb_emu_push_size = n;
|
||||
c->dt->vkCmdPushDescriptorSetWithTemplate(cb, tmpl, layout, set, data);
|
||||
vkb_emu_push_size = 0;
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* Persistent pipeline cache. Mali compiles every pipeline from scratch in each new process unless
|
||||
* it is handed a VkPipelineCache; games through DXVK pass none. With a cache directory set
|
||||
* (--cache-dir), each device gets a cache loaded from <dir>/<vendor>-<device>-<cacheUUID>.vkpc:
|
||||
* - pipelines created without a cache use it;
|
||||
* - caches the app creates empty start from it, and are merged back into it when destroyed;
|
||||
* - it is written back every few seconds while new pipelines come in (the app stops the server
|
||||
* with SIGKILL, so there is no reliable last chance) and when the device goes away.
|
||||
* The file's header is checked against the GPU before the driver sees it.
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/stat.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#define PC_MAX_FILE (256u << 20)
|
||||
#define PC_SAVE_PERIOD_S 10
|
||||
|
||||
typedef struct vkb_pcache {
|
||||
vkb_srv_table *t;
|
||||
VkPipelineCache cache;
|
||||
char path[512];
|
||||
int dirty;
|
||||
size_t saved_size;
|
||||
PFN_vkCreateGraphicsPipelines create_gfx;
|
||||
PFN_vkCreateComputePipelines create_compute;
|
||||
PFN_vkCreatePipelineCache create_cache;
|
||||
PFN_vkDestroyPipelineCache destroy_cache;
|
||||
struct vkb_pcache *next;
|
||||
} vkb_pcache;
|
||||
|
||||
static const char *pc_dir;
|
||||
static pthread_mutex_t pc_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static vkb_pcache *pc_list;
|
||||
static int pc_thread_started;
|
||||
|
||||
void vkb_pcache_set_dir(const char *dir)
|
||||
{
|
||||
if (!dir || !*dir) return;
|
||||
mkdir(dir, 0700);
|
||||
pc_dir = dir;
|
||||
VKB_INFO("pipeline cache directory %s", dir);
|
||||
}
|
||||
|
||||
static vkb_pcache *cur(void)
|
||||
{
|
||||
vkb_srv_table *t = vkb_srv_current_table();
|
||||
return t ? t->pcache : NULL;
|
||||
}
|
||||
|
||||
/* The header every pipeline cache starts with (VkPipelineCacheHeaderVersionOne). */
|
||||
static int header_ok(const vkb_srv_table *t, const uint8_t *data, size_t size)
|
||||
{
|
||||
VkPipelineCacheHeaderVersionOne h;
|
||||
if (size < sizeof(h)) return 0;
|
||||
memcpy(&h, data, sizeof(h));
|
||||
VkPhysicalDeviceProperties props;
|
||||
t->real.vkGetPhysicalDeviceProperties(t->physical, &props);
|
||||
return h.headerSize >= sizeof(h) && h.headerVersion == VK_PIPELINE_CACHE_HEADER_VERSION_ONE &&
|
||||
h.vendorID == props.vendorID && h.deviceID == props.deviceID &&
|
||||
!memcmp(h.pipelineCacheUUID, props.pipelineCacheUUID, VK_UUID_SIZE);
|
||||
}
|
||||
|
||||
static uint8_t *read_file(const char *path, size_t *size)
|
||||
{
|
||||
*size = 0;
|
||||
int fd = open(path, O_RDONLY | O_CLOEXEC);
|
||||
if (fd < 0) return NULL;
|
||||
struct stat st;
|
||||
uint8_t *buf = NULL;
|
||||
if (fstat(fd, &st) == 0 && st.st_size > 0 && (uint64_t)st.st_size <= PC_MAX_FILE && (buf = malloc((size_t)st.st_size))) {
|
||||
size_t got = 0;
|
||||
while (got < (size_t)st.st_size) {
|
||||
ssize_t r = read(fd, buf + got, (size_t)st.st_size - got);
|
||||
if (r <= 0) break;
|
||||
got += (size_t)r;
|
||||
}
|
||||
if (got == (size_t)st.st_size) {
|
||||
*size = got;
|
||||
} else {
|
||||
free(buf);
|
||||
buf = NULL;
|
||||
}
|
||||
}
|
||||
close(fd);
|
||||
return buf;
|
||||
}
|
||||
|
||||
/* Writes the cache next to its file and renames it over, so a kill mid-write loses nothing. */
|
||||
static void save(vkb_pcache *p)
|
||||
{
|
||||
vkb_srv_table *t = p->t;
|
||||
size_t size = 0;
|
||||
if (t->real.vkGetPipelineCacheData(t->device, p->cache, &size, NULL) != VK_SUCCESS || !size || size > PC_MAX_FILE) return;
|
||||
if (size == p->saved_size) {
|
||||
/* Nothing new was compiled (merges of what it already had leave the size alone). */
|
||||
p->dirty = 0;
|
||||
return;
|
||||
}
|
||||
uint8_t *buf = malloc(size);
|
||||
if (!buf) return;
|
||||
VkResult r = t->real.vkGetPipelineCacheData(t->device, p->cache, &size, buf);
|
||||
if (r == VK_SUCCESS) {
|
||||
char tmp[600];
|
||||
snprintf(tmp, sizeof(tmp), "%s.%d.tmp", p->path, (int)getpid());
|
||||
int fd = open(tmp, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
|
||||
int ok = fd >= 0;
|
||||
for (size_t done = 0; ok && done < size;) {
|
||||
ssize_t w = write(fd, buf + done, size - done);
|
||||
if (w < 0 && errno == EINTR) continue;
|
||||
if (w <= 0) ok = 0;
|
||||
else done += (size_t)w;
|
||||
}
|
||||
if (fd >= 0 && fsync(fd) != 0) ok = 0;
|
||||
if (fd >= 0) close(fd);
|
||||
if (ok && rename(tmp, p->path) == 0) {
|
||||
VKB_INFO("device %u: pipeline cache saved (%zu KB)", t->id, size >> 10);
|
||||
p->saved_size = size;
|
||||
p->dirty = 0;
|
||||
} else {
|
||||
VKB_WARN("device %u: pipeline cache not saved to %s: %s", t->id, p->path, strerror(errno));
|
||||
unlink(tmp);
|
||||
}
|
||||
}
|
||||
free(buf);
|
||||
}
|
||||
|
||||
static void *saver(void *arg)
|
||||
{
|
||||
(void)arg;
|
||||
for (;;) {
|
||||
struct timespec ts = {PC_SAVE_PERIOD_S, 0};
|
||||
nanosleep(&ts, NULL);
|
||||
pthread_mutex_lock(&pc_lock);
|
||||
for (vkb_pcache *p = pc_list; p; p = p->next)
|
||||
if (__atomic_load_n(&p->dirty, __ATOMIC_RELAXED)) save(p);
|
||||
pthread_mutex_unlock(&pc_lock);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ wrappers */
|
||||
|
||||
static VkResult VKAPI_CALL pc_CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
|
||||
const VkGraphicsPipelineCreateInfo *ci, const VkAllocationCallbacks *a,
|
||||
VkPipeline *out)
|
||||
{
|
||||
vkb_pcache *p = cur();
|
||||
if (!cache) {
|
||||
cache = p->cache;
|
||||
__atomic_store_n(&p->dirty, 1, __ATOMIC_RELAXED);
|
||||
}
|
||||
return p->create_gfx(device, cache, n, ci, a, out);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL pc_CreateComputePipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
|
||||
const VkComputePipelineCreateInfo *ci, const VkAllocationCallbacks *a,
|
||||
VkPipeline *out)
|
||||
{
|
||||
vkb_pcache *p = cur();
|
||||
if (!cache) {
|
||||
cache = p->cache;
|
||||
__atomic_store_n(&p->dirty, 1, __ATOMIC_RELAXED);
|
||||
}
|
||||
return p->create_compute(device, cache, n, ci, a, out);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL pc_CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *ci,
|
||||
const VkAllocationCallbacks *a, VkPipelineCache *out)
|
||||
{
|
||||
vkb_pcache *p = cur();
|
||||
if (ci->initialDataSize) return p->create_cache(device, ci, a, out);
|
||||
size_t size = 0;
|
||||
uint8_t *buf = NULL;
|
||||
if (p->t->real.vkGetPipelineCacheData(device, p->cache, &size, NULL) == VK_SUCCESS && size && (buf = malloc(size)) &&
|
||||
p->t->real.vkGetPipelineCacheData(device, p->cache, &size, buf) != VK_SUCCESS)
|
||||
size = 0;
|
||||
VkPipelineCacheCreateInfo seeded = *ci;
|
||||
seeded.initialDataSize = buf ? size : 0;
|
||||
seeded.pInitialData = buf;
|
||||
VkResult r = p->create_cache(device, &seeded, a, out);
|
||||
free(buf);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL pc_DestroyPipelineCache(VkDevice device, VkPipelineCache cache, const VkAllocationCallbacks *a)
|
||||
{
|
||||
vkb_pcache *p = cur();
|
||||
if (cache && cache != p->cache && p->t->real.vkMergePipelineCaches(device, p->cache, 1, &cache) == VK_SUCCESS)
|
||||
__atomic_store_n(&p->dirty, 1, __ATOMIC_RELAXED);
|
||||
p->destroy_cache(device, cache, a);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ device hooks */
|
||||
|
||||
void vkb_pcache_device_init(vkb_srv_table *t)
|
||||
{
|
||||
if (!pc_dir || !t->real.vkCreatePipelineCache || !t->real.vkGetPipelineCacheData || !t->real.vkMergePipelineCaches) return;
|
||||
vkb_pcache *p = calloc(1, sizeof(*p));
|
||||
if (!p) return;
|
||||
p->t = t;
|
||||
VkPhysicalDeviceProperties props;
|
||||
t->real.vkGetPhysicalDeviceProperties(t->physical, &props);
|
||||
char uuid[2 * VK_UUID_SIZE + 1];
|
||||
for (int i = 0; i < VK_UUID_SIZE; i++) snprintf(uuid + 2 * i, 3, "%02x", props.pipelineCacheUUID[i]);
|
||||
snprintf(p->path, sizeof(p->path), "%s/%04x-%04x-%s.vkpc", pc_dir, props.vendorID, props.deviceID, uuid);
|
||||
|
||||
size_t size;
|
||||
uint8_t *data = read_file(p->path, &size);
|
||||
if (data && !header_ok(t, data, size)) {
|
||||
VKB_WARN("device %u: %s is not this GPU's pipeline cache; starting empty", t->id, p->path);
|
||||
free(data);
|
||||
data = NULL;
|
||||
size = 0;
|
||||
}
|
||||
VkPipelineCacheCreateInfo ci = {VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, NULL, 0, data ? size : 0, data};
|
||||
VkResult r = t->real.vkCreatePipelineCache(t->device, &ci, NULL, &p->cache);
|
||||
if (r != VK_SUCCESS && data) {
|
||||
VKB_WARN("device %u: driver refused the saved pipeline cache (%d); starting empty", t->id, r);
|
||||
ci.initialDataSize = 0;
|
||||
ci.pInitialData = NULL;
|
||||
r = t->real.vkCreatePipelineCache(t->device, &ci, NULL, &p->cache);
|
||||
}
|
||||
free(data);
|
||||
if (r != VK_SUCCESS) {
|
||||
VKB_WARN("device %u: no pipeline cache (%d)", t->id, r);
|
||||
free(p);
|
||||
return;
|
||||
}
|
||||
p->saved_size = size;
|
||||
VKB_INFO("device %u: pipeline cache %s (%zu KB loaded)", t->id, p->path, size >> 10);
|
||||
|
||||
vkb_dispatch *dt = &t->dt;
|
||||
p->create_gfx = dt->vkCreateGraphicsPipelines;
|
||||
p->create_compute = dt->vkCreateComputePipelines;
|
||||
p->create_cache = dt->vkCreatePipelineCache;
|
||||
p->destroy_cache = dt->vkDestroyPipelineCache;
|
||||
dt->vkCreateGraphicsPipelines = pc_CreateGraphicsPipelines;
|
||||
dt->vkCreateComputePipelines = pc_CreateComputePipelines;
|
||||
dt->vkCreatePipelineCache = pc_CreatePipelineCache;
|
||||
dt->vkDestroyPipelineCache = pc_DestroyPipelineCache;
|
||||
t->pcache = p;
|
||||
|
||||
pthread_mutex_lock(&pc_lock);
|
||||
p->next = pc_list;
|
||||
pc_list = p;
|
||||
if (!pc_thread_started) {
|
||||
pthread_t th;
|
||||
pthread_attr_t at;
|
||||
pthread_attr_init(&at);
|
||||
pthread_attr_setdetachstate(&at, PTHREAD_CREATE_DETACHED);
|
||||
pc_thread_started = pthread_create(&th, &at, saver, NULL) == 0;
|
||||
pthread_attr_destroy(&at);
|
||||
}
|
||||
pthread_mutex_unlock(&pc_lock);
|
||||
}
|
||||
|
||||
/* Before the device is destroyed: last save, then the cache goes. */
|
||||
void vkb_pcache_device_destroy(vkb_srv_table *t)
|
||||
{
|
||||
vkb_pcache *p = t->pcache;
|
||||
if (!p) return;
|
||||
pthread_mutex_lock(&pc_lock);
|
||||
for (vkb_pcache **pp = &pc_list; *pp; pp = &(*pp)->next) {
|
||||
if (*pp == p) {
|
||||
*pp = p->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (p->dirty) save(p);
|
||||
pthread_mutex_unlock(&pc_lock);
|
||||
t->dt.vkCreateGraphicsPipelines = p->create_gfx;
|
||||
t->dt.vkCreateComputePipelines = p->create_compute;
|
||||
t->dt.vkCreatePipelineCache = p->create_cache;
|
||||
t->dt.vkDestroyPipelineCache = p->destroy_cache;
|
||||
t->real.vkDestroyPipelineCache(t->device, p->cache, NULL);
|
||||
t->pcache = NULL;
|
||||
free(p);
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* SPIR-V fixes for Mali's shader compiler, applied to every module the app hands the driver.
|
||||
*
|
||||
* DXVK (1.7.3 and later) guards texture reads with OpSelect(cond, texel, vec4(0)) where cond is an
|
||||
* OpConstantComposite of OpSpecConstantTrue/False. Mali's compiler folds that composite as if it
|
||||
* were a plain constant - taking the spec constants at their default - and every texture reads
|
||||
* black. Declaring the composite OpSpecConstantComposite (same operands, same length) keeps it
|
||||
* specializable and the fold away. Found by leegao (bionic-vulkan-wrapper issue #93,
|
||||
* "OpCompositeConstant" write-up, 2025-08-10); Vortek patches the same pattern.
|
||||
*
|
||||
* The code is patched in place: it lives in the server's receive buffer (vkCreateShaderModule's
|
||||
* pCode, or a VkShaderModuleCreateInfo chained to a pipeline stage), so nothing is copied.
|
||||
* On for ARM GPUs; VKBRIDGE_SPIRV_FIX=1/0 forces it (host tests).
|
||||
*/
|
||||
#define _GNU_SOURCE
|
||||
#include "vkb_server.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#define OP_SPEC_CONSTANT_TRUE 48
|
||||
#define OP_SPEC_CONSTANT_FALSE 49
|
||||
#define OP_SPEC_CONSTANT 50
|
||||
#define OP_SPEC_CONSTANT_COMPOSITE 51
|
||||
#define OP_SPEC_CONSTANT_OP 52
|
||||
#define OP_CONSTANT_COMPOSITE 44
|
||||
#define OP_FUNCTION 54
|
||||
|
||||
typedef struct vkb_spvfix {
|
||||
PFN_vkCreateShaderModule create_module;
|
||||
PFN_vkCreateGraphicsPipelines create_gfx;
|
||||
PFN_vkCreateComputePipelines create_compute;
|
||||
unsigned long patched; /* composites changed, for the log */
|
||||
} vkb_spvfix;
|
||||
|
||||
static vkb_spvfix *cur(void)
|
||||
{
|
||||
vkb_srv_table *t = vkb_srv_current_table();
|
||||
return t ? t->spvfix : NULL;
|
||||
}
|
||||
|
||||
/* Patches one module in place; returns the number of composites changed. */
|
||||
static unsigned fix_module(uint32_t *w, size_t bytes)
|
||||
{
|
||||
size_t n = bytes / 4;
|
||||
if (n < 5 || w[0] != 0x07230203u) return 0;
|
||||
uint32_t bound = w[3];
|
||||
if (!bound || bound > (1u << 24)) return 0;
|
||||
uint8_t *spec = calloc(bound, 1);
|
||||
if (!spec) return 0;
|
||||
unsigned changed = 0;
|
||||
for (size_t i = 5; i < n;) {
|
||||
uint32_t op = w[i] & 0xffff, len = w[i] >> 16;
|
||||
if (!len || i + len > n) break;
|
||||
if (op == OP_FUNCTION) break; /* constants all come before the first function */
|
||||
if ((op == OP_SPEC_CONSTANT_TRUE || op == OP_SPEC_CONSTANT_FALSE || op == OP_SPEC_CONSTANT ||
|
||||
op == OP_SPEC_CONSTANT_COMPOSITE || op == OP_SPEC_CONSTANT_OP) && len >= 3 && w[i + 2] < bound) {
|
||||
spec[w[i + 2]] = 1;
|
||||
} else if (op == OP_CONSTANT_COMPOSITE && len >= 3 && w[i + 2] < bound) {
|
||||
int any = 0;
|
||||
for (uint32_t k = 3; k < len; k++) any |= w[i + k] < bound && spec[w[i + k]];
|
||||
if (any) {
|
||||
/* A composite of spec constants is itself one: declared so, it is no longer folded. */
|
||||
w[i] = (len << 16) | OP_SPEC_CONSTANT_COMPOSITE;
|
||||
spec[w[i + 2]] = 1;
|
||||
changed++;
|
||||
}
|
||||
}
|
||||
i += len;
|
||||
}
|
||||
free(spec);
|
||||
return changed;
|
||||
}
|
||||
|
||||
static void note(vkb_spvfix *f, unsigned changed)
|
||||
{
|
||||
if (!changed) return;
|
||||
unsigned long before = __atomic_fetch_add(&f->patched, changed, __ATOMIC_RELAXED);
|
||||
if (!before) VKB_INFO("SPIR-V fix: spec-constant composites redeclared for Mali's compiler (first in this device)");
|
||||
}
|
||||
|
||||
static void fix_stages(vkb_spvfix *f, uint32_t n, const VkPipelineShaderStageCreateInfo *st)
|
||||
{
|
||||
for (uint32_t i = 0; i < n; i++)
|
||||
for (const VkBaseInStructure *b = st[i].pNext; b; b = b->pNext)
|
||||
if (b->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO) {
|
||||
const VkShaderModuleCreateInfo *mi = (const void *)b;
|
||||
note(f, fix_module((uint32_t *)mi->pCode, mi->codeSize));
|
||||
}
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL fx_CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *ci, const VkAllocationCallbacks *a,
|
||||
VkShaderModule *out)
|
||||
{
|
||||
vkb_spvfix *f = cur();
|
||||
note(f, fix_module((uint32_t *)ci->pCode, ci->codeSize));
|
||||
return f->create_module(device, ci, a, out);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL fx_CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
|
||||
const VkGraphicsPipelineCreateInfo *ci, const VkAllocationCallbacks *a,
|
||||
VkPipeline *out)
|
||||
{
|
||||
vkb_spvfix *f = cur();
|
||||
for (uint32_t i = 0; i < n; i++) fix_stages(f, ci[i].stageCount, ci[i].pStages);
|
||||
return f->create_gfx(device, cache, n, ci, a, out);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL fx_CreateComputePipelines(VkDevice device, VkPipelineCache cache, uint32_t n,
|
||||
const VkComputePipelineCreateInfo *ci, const VkAllocationCallbacks *a,
|
||||
VkPipeline *out)
|
||||
{
|
||||
vkb_spvfix *f = cur();
|
||||
for (uint32_t i = 0; i < n; i++) fix_stages(f, 1, &ci[i].stage);
|
||||
return f->create_compute(device, cache, n, ci, a, out);
|
||||
}
|
||||
|
||||
void vkb_spvfix_device_init(vkb_srv_table *t)
|
||||
{
|
||||
VkPhysicalDeviceProperties p;
|
||||
t->real.vkGetPhysicalDeviceProperties(t->physical, &p);
|
||||
const char *env = getenv("VKBRIDGE_SPIRV_FIX");
|
||||
int on = env ? strcmp(env, "0") != 0 : p.vendorID == 0x13B5; /* ARM */
|
||||
if (!on || !t->dt.vkCreateShaderModule) return;
|
||||
vkb_spvfix *f = calloc(1, sizeof(*f));
|
||||
if (!f) return;
|
||||
vkb_dispatch *dt = &t->dt;
|
||||
f->create_module = dt->vkCreateShaderModule;
|
||||
f->create_gfx = dt->vkCreateGraphicsPipelines;
|
||||
f->create_compute = dt->vkCreateComputePipelines;
|
||||
dt->vkCreateShaderModule = fx_CreateShaderModule;
|
||||
dt->vkCreateGraphicsPipelines = fx_CreateGraphicsPipelines;
|
||||
dt->vkCreateComputePipelines = fx_CreateComputePipelines;
|
||||
t->spvfix = f;
|
||||
VKB_INFO("device %u: Mali SPIR-V fixes on", t->id);
|
||||
}
|
||||
|
||||
void vkb_spvfix_device_destroy(vkb_srv_table *t)
|
||||
{
|
||||
vkb_spvfix *f = t->spvfix;
|
||||
if (!f) return;
|
||||
t->dt.vkCreateShaderModule = f->create_module;
|
||||
t->dt.vkCreateGraphicsPipelines = f->create_gfx;
|
||||
t->dt.vkCreateComputePipelines = f->create_compute;
|
||||
if (f->patched) VKB_INFO("device %u: SPIR-V fix changed %lu composites", t->id, f->patched);
|
||||
free(f);
|
||||
t->spvfix = NULL;
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later */
|
||||
#include "spirv_edit.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int spv_parse(spv_mod *m, const uint32_t *code, size_t bytes)
|
||||
{
|
||||
memset(m, 0, sizeof(*m));
|
||||
if (bytes < 20 || (bytes & 3) || code[0] != 0x07230203u) return -1;
|
||||
memcpy(m->header, code, 20);
|
||||
size_t words = bytes / 4, pos = 5;
|
||||
while (pos < words) {
|
||||
uint32_t n = code[pos] >> 16, op = code[pos] & 0xffff;
|
||||
if (n == 0 || pos + n > words) return -1;
|
||||
spv_insert(m, m->count, (uint16_t)op, code + pos + 1, (uint16_t)(n - 1));
|
||||
if (m->err) return -1;
|
||||
pos += n;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t spv_write(const spv_mod *m, uint32_t **out)
|
||||
{
|
||||
size_t words = 5;
|
||||
for (uint32_t i = 0; i < m->count; i++) words += m->ins[i].n;
|
||||
uint32_t *buf = malloc(words * 4);
|
||||
if (!buf) return 0;
|
||||
memcpy(buf, m->header, 20);
|
||||
size_t pos = 5;
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
buf[pos++] = ((uint32_t)in->n << 16) | in->op;
|
||||
memcpy(buf + pos, in->w, (size_t)(in->n - 1) * 4);
|
||||
pos += in->n - 1;
|
||||
}
|
||||
*out = buf;
|
||||
return words * 4;
|
||||
}
|
||||
|
||||
void spv_free(spv_mod *m)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) free(m->ins[i].w);
|
||||
free(m->ins);
|
||||
memset(m, 0, sizeof(*m));
|
||||
}
|
||||
|
||||
uint32_t spv_insert(spv_mod *m, uint32_t at, uint16_t op, const uint32_t *ops, uint16_t nops)
|
||||
{
|
||||
if (m->count == m->cap) {
|
||||
uint32_t nc = m->cap ? m->cap * 2 : 1024;
|
||||
spv_inst *ni = realloc(m->ins, nc * sizeof(*ni));
|
||||
if (!ni) {
|
||||
m->err = 1;
|
||||
return 0;
|
||||
}
|
||||
m->ins = ni;
|
||||
m->cap = nc;
|
||||
}
|
||||
if (at > m->count) at = m->count;
|
||||
memmove(&m->ins[at + 1], &m->ins[at], (m->count - at) * sizeof(spv_inst));
|
||||
spv_inst *in = &m->ins[at];
|
||||
in->op = op;
|
||||
in->n = (uint16_t)(nops + 1);
|
||||
in->w = malloc((size_t)(nops ? nops : 1) * 4);
|
||||
if (!in->w) m->err = 1;
|
||||
else if (nops) memcpy(in->w, ops, (size_t)nops * 4);
|
||||
m->count++;
|
||||
return at;
|
||||
}
|
||||
|
||||
void spv_remove(spv_mod *m, uint32_t at)
|
||||
{
|
||||
if (at >= m->count) return;
|
||||
free(m->ins[at].w);
|
||||
memmove(&m->ins[at], &m->ins[at + 1], (m->count - at - 1) * sizeof(spv_inst));
|
||||
m->count--;
|
||||
}
|
||||
|
||||
int spv_find_op(const spv_mod *m, uint16_t op, uint32_t from)
|
||||
{
|
||||
for (uint32_t i = from; i < m->count; i++)
|
||||
if (m->ins[i].op == op) return (int)i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int is_type(uint16_t op) { return op >= 19 && op <= 38; }
|
||||
static int is_const(uint16_t op) { return (op >= 41 && op <= 46) || (op >= 48 && op <= 52); }
|
||||
|
||||
uint32_t spv_result_id(const spv_inst *in)
|
||||
{
|
||||
if (in->n < 2) return 0;
|
||||
if (is_type(in->op) || in->op == SpvOpLabel || in->op == SpvOpString || in->op == SpvOpExtInstImport || in->op == 73)
|
||||
return in->w[0];
|
||||
switch (in->op) {
|
||||
case SpvOpName: case SpvOpMemberName: case SpvOpDecorate: case SpvOpMemberDecorate: case SpvOpEntryPoint:
|
||||
case SpvOpExecutionMode: case SpvOpCapability: case SpvOpExtension: case SpvOpMemoryModel: case SpvOpStore:
|
||||
case SpvOpBranch: case SpvOpBranchConditional: case SpvOpSelectionMerge: case SpvOpReturn: case SpvOpKill:
|
||||
case SpvOpFunctionEnd: case SpvOpLine: case SpvOpNoLine: case SpvOpSource: case SpvOpSourceExtension:
|
||||
case SpvOpDecorateId: case SpvOpDecorateString: case SpvOpMemberDecorateString: case SpvOpModuleProcessed:
|
||||
case SpvOpExecutionModeId: case 246 /* LoopMerge */: case 251 /* Switch */: case 254 /* ReturnValue */:
|
||||
case 255 /* Unreachable */: case 74: case 75: case 224 /* ControlBarrier */: case 225 /* MemoryBarrier */:
|
||||
case SpvOpTerminateInvocation:
|
||||
return 0;
|
||||
default:
|
||||
return in->n >= 3 ? in->w[1] : 0;
|
||||
}
|
||||
}
|
||||
|
||||
int spv_find_def(const spv_mod *m, uint32_t id)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (spv_result_id(&m->ins[i]) == id) return (int)i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
uint32_t spv_types_end(const spv_mod *m)
|
||||
{
|
||||
int f = spv_find_op(m, SpvOpFunction, 0);
|
||||
return f < 0 ? m->count : (uint32_t)f;
|
||||
}
|
||||
|
||||
uint32_t spv_annotations_end(const spv_mod *m)
|
||||
{
|
||||
uint32_t end = spv_types_end(m);
|
||||
for (uint32_t i = 0; i < end; i++) {
|
||||
uint16_t op = m->ins[i].op;
|
||||
if (is_type(op) || is_const(op) || op == SpvOpVariable || op == SpvOpUndef) return i;
|
||||
}
|
||||
return end;
|
||||
}
|
||||
|
||||
static uint32_t add_global(spv_mod *m, uint16_t op, const uint32_t *ops, uint16_t n)
|
||||
{
|
||||
uint32_t at = spv_types_end(m);
|
||||
spv_insert(m, at, op, ops, n);
|
||||
return at;
|
||||
}
|
||||
|
||||
uint32_t spv_type_float(spv_mod *m, uint32_t width)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypeFloat && m->ins[i].w[1] == width && m->ins[i].n == 3) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m), ops[2] = {id, width};
|
||||
add_global(m, SpvOpTypeFloat, ops, 2);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_int(spv_mod *m, uint32_t width, uint32_t sign)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypeInt && m->ins[i].w[1] == width && m->ins[i].w[2] == sign) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {id, width, sign};
|
||||
add_global(m, SpvOpTypeInt, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_bool(spv_mod *m)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypeBool) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m);
|
||||
add_global(m, SpvOpTypeBool, &id, 1);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_pointer(spv_mod *m, uint32_t storage, uint32_t pointee)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpTypePointer && m->ins[i].w[1] == storage && m->ins[i].w[2] == pointee) return m->ins[i].w[0];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {id, storage, pointee};
|
||||
add_global(m, SpvOpTypePointer, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_type_array(spv_mod *m, uint32_t elem, uint32_t len_const)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
if (m->ins[i].op == SpvOpTypeArray && m->ins[i].w[1] == elem && m->ins[i].w[2] == len_const &&
|
||||
spv_get_decoration(m, m->ins[i].w[0], 6 /* ArrayStride */) < 0)
|
||||
return m->ins[i].w[0];
|
||||
}
|
||||
uint32_t id = spv_new_id(m), ops[3] = {id, elem, len_const};
|
||||
add_global(m, SpvOpTypeArray, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_const_u32(spv_mod *m, uint32_t v)
|
||||
{
|
||||
uint32_t t = spv_type_int(m, 32, 0);
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpConstant && m->ins[i].w[0] == t && m->ins[i].n == 4 && m->ins[i].w[2] == v) return m->ins[i].w[1];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {t, id, v};
|
||||
add_global(m, SpvOpConstant, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
uint32_t spv_const_f32(spv_mod *m, float v)
|
||||
{
|
||||
uint32_t t = spv_type_float(m, 32), bits;
|
||||
memcpy(&bits, &v, 4);
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpConstant && m->ins[i].w[0] == t && m->ins[i].n == 4 && m->ins[i].w[2] == bits) return m->ins[i].w[1];
|
||||
uint32_t id = spv_new_id(m), ops[3] = {t, id, bits};
|
||||
add_global(m, SpvOpConstant, ops, 3);
|
||||
return id;
|
||||
}
|
||||
|
||||
int64_t spv_get_decoration(const spv_mod *m, uint32_t id, uint32_t decoration)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op == SpvOpDecorate && in->w[0] == id && in->w[1] == decoration) return in->n > 3 ? (int64_t)in->w[2] : 0;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void spv_remove_decoration(spv_mod *m, uint32_t id, uint32_t decoration)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count;) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op == SpvOpDecorate && in->w[0] == id && in->w[1] == decoration) spv_remove(m, i);
|
||||
else i++;
|
||||
}
|
||||
}
|
||||
|
||||
int spv_has_capability(const spv_mod *m, uint32_t cap)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++)
|
||||
if (m->ins[i].op == SpvOpCapability && m->ins[i].w[0] == cap) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void spv_remove_capability(spv_mod *m, uint32_t cap)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count;) {
|
||||
if (m->ins[i].op == SpvOpCapability && m->ins[i].w[0] == cap) spv_remove(m, i);
|
||||
else i++;
|
||||
}
|
||||
}
|
||||
|
||||
void spv_add_capability(spv_mod *m, uint32_t cap)
|
||||
{
|
||||
if (!spv_has_capability(m, cap)) spv_insert(m, 0, SpvOpCapability, &cap, 1);
|
||||
}
|
||||
|
||||
int spv_execution_model(const spv_mod *m)
|
||||
{
|
||||
int e = spv_find_op(m, SpvOpEntryPoint, 0);
|
||||
return e < 0 ? -1 : (int)m->ins[e].w[0];
|
||||
}
|
||||
|
||||
void spv_add_interface(spv_mod *m, uint32_t var)
|
||||
{
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
spv_inst *in = &m->ins[i];
|
||||
if (in->op != SpvOpEntryPoint) continue;
|
||||
uint32_t *nw = realloc(in->w, (size_t)in->n * 4);
|
||||
if (!nw) {
|
||||
m->err = 1;
|
||||
return;
|
||||
}
|
||||
nw[in->n - 1] = var;
|
||||
in->w = nw;
|
||||
in->n++;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t spv_array_length(const spv_mod *m, uint32_t array_type)
|
||||
{
|
||||
int d = spv_find_def(m, array_type);
|
||||
if (d < 0 || m->ins[d].op != SpvOpTypeArray) return 0;
|
||||
int c = spv_find_def(m, m->ins[d].w[2]);
|
||||
if (c < 0 || m->ins[c].op != SpvOpConstant) return 0;
|
||||
return m->ins[c].w[2];
|
||||
}
|
||||
|
||||
/* Number of locations a type occupies. */
|
||||
static uint32_t loc_count(const spv_mod *m, uint32_t type, int depth)
|
||||
{
|
||||
int d = spv_find_def(m, type);
|
||||
if (d < 0 || depth > 16) return 1;
|
||||
const spv_inst *in = &m->ins[d];
|
||||
switch (in->op) {
|
||||
case SpvOpTypeArray: return spv_array_length(m, type) * loc_count(m, in->w[1], depth + 1);
|
||||
case 24 /* Matrix */: return in->w[2] * loc_count(m, in->w[1], depth + 1);
|
||||
case SpvOpTypeStruct: {
|
||||
uint32_t s = 0;
|
||||
for (uint32_t k = 1; k < (uint32_t)in->n - 1; k++) s += loc_count(m, in->w[k], depth + 1);
|
||||
return s;
|
||||
}
|
||||
case SpvOpTypeVector: {
|
||||
int e = spv_find_def(m, in->w[1]);
|
||||
uint32_t width = e >= 0 ? m->ins[e].w[1] : 32;
|
||||
return (width == 64 && in->w[2] > 2) ? 2 : 1;
|
||||
}
|
||||
default: return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int spv_max_location(const spv_mod *m, uint32_t storage)
|
||||
{
|
||||
int max = -1;
|
||||
for (uint32_t i = 0; i < m->count; i++) {
|
||||
const spv_inst *in = &m->ins[i];
|
||||
if (in->op != SpvOpVariable || in->w[2] != storage) continue;
|
||||
int p = spv_find_def(m, in->w[0]);
|
||||
if (p < 0) continue;
|
||||
uint32_t pointee = m->ins[p].w[2];
|
||||
int64_t loc = spv_get_decoration(m, in->w[1], SpvDecorationLocation);
|
||||
if (loc >= 0) {
|
||||
int top = (int)loc + (int)loc_count(m, pointee, 0) - 1;
|
||||
if (top > max) max = top;
|
||||
continue;
|
||||
}
|
||||
/* A block with member locations. */
|
||||
for (uint32_t k = 0; k < m->count; k++) {
|
||||
const spv_inst *md = &m->ins[k];
|
||||
if (md->op == SpvOpMemberDecorate && md->w[0] == pointee && md->w[2] == SpvDecorationLocation) {
|
||||
int st = spv_find_def(m, pointee);
|
||||
uint32_t mt = st >= 0 && md->w[1] + 1 < m->ins[st].n ? m->ins[st].w[1 + md->w[1]] : 0;
|
||||
int top = (int)md->w[3] + (int)loc_count(m, mt, 0) - 1;
|
||||
if (top > max) max = top;
|
||||
}
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* A small SPIR-V editor for the bridge's shader emulations: parse a module into instructions,
|
||||
* look things up, append/insert/remove instructions, and write it back.
|
||||
*/
|
||||
#ifndef VKB_SPIRV_EDIT_H
|
||||
#define VKB_SPIRV_EDIT_H
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
/* Opcodes and enums used (from the SPIR-V spec). */
|
||||
enum {
|
||||
SpvOpName = 5, SpvOpMemberName = 6, SpvOpExtension = 10, SpvOpExtInstImport = 11, SpvOpMemoryModel = 14,
|
||||
SpvOpEntryPoint = 15, SpvOpExecutionMode = 16, SpvOpCapability = 17, SpvOpTypeVoid = 19, SpvOpTypeBool = 20,
|
||||
SpvOpTypeInt = 21, SpvOpTypeFloat = 22, SpvOpTypeVector = 23, SpvOpTypeArray = 28, SpvOpTypeRuntimeArray = 29,
|
||||
SpvOpTypeStruct = 30, SpvOpTypePointer = 32, SpvOpTypeFunction = 33, SpvOpConstantTrue = 41,
|
||||
SpvOpConstantFalse = 42, SpvOpConstant = 43, SpvOpConstantComposite = 44, SpvOpFunction = 54,
|
||||
SpvOpFunctionParameter = 55, SpvOpFunctionEnd = 56, SpvOpVariable = 59, SpvOpLoad = 61, SpvOpStore = 62,
|
||||
SpvOpAccessChain = 65, SpvOpInBoundsAccessChain = 66, SpvOpDecorate = 71, SpvOpMemberDecorate = 72,
|
||||
SpvOpCompositeExtract = 81, SpvOpFOrdLessThan = 184, SpvOpLogicalOr = 166, SpvOpSelectionMerge = 247,
|
||||
SpvOpLabel = 248, SpvOpBranch = 249, SpvOpBranchConditional = 250, SpvOpReturn = 253, SpvOpKill = 252,
|
||||
SpvOpTerminateInvocation = 4416, SpvOpLine = 8, SpvOpNoLine = 317, SpvOpModuleProcessed = 330,
|
||||
SpvOpString = 7, SpvOpSource = 3, SpvOpSourceExtension = 4, SpvOpSourceContinued = 2, SpvOpExecutionModeId = 331,
|
||||
SpvOpDecorateId = 332, SpvOpDecorateString = 5632, SpvOpMemberDecorateString = 5633, SpvOpUndef = 1,
|
||||
SpvOpExtInst = 12, SpvOpIAdd = 128, SpvOpUDiv = 134, SpvOpISub = 130,
|
||||
};
|
||||
enum { SpvDecorationBuiltIn = 11, SpvDecorationLocation = 30, SpvDecorationComponent = 31, SpvDecorationBlock = 2,
|
||||
SpvDecorationFlat = 14, SpvDecorationPatch = 15 };
|
||||
enum { SpvBuiltInPosition = 0, SpvBuiltInPointSize = 1, SpvBuiltInClipDistance = 3, SpvBuiltInCullDistance = 4,
|
||||
SpvBuiltInInstanceIndex = 43, SpvBuiltInBaseInstance = 4425 };
|
||||
enum { SpvStorageClassInput = 1, SpvStorageClassOutput = 3, SpvStorageClassPrivate = 6, SpvStorageClassFunction = 7 };
|
||||
enum { SpvCapabilityClipDistance = 32, SpvCapabilityCullDistance = 33, SpvCapabilityTessellationPointSize = 23,
|
||||
SpvCapabilityGeometryPointSize = 24, SpvCapabilityDrawParameters = 4427 };
|
||||
enum { SpvExecutionModelVertex = 0, SpvExecutionModelTessellationControl = 1, SpvExecutionModelTessellationEvaluation = 2,
|
||||
SpvExecutionModelGeometry = 3, SpvExecutionModelFragment = 4, SpvExecutionModelGLCompute = 5 };
|
||||
|
||||
typedef struct spv_inst {
|
||||
uint16_t op;
|
||||
uint16_t n; /* word count including the first word */
|
||||
uint32_t *w; /* operand words (w[0] = first operand), n - 1 of them */
|
||||
} spv_inst;
|
||||
|
||||
typedef struct spv_mod {
|
||||
uint32_t header[5];
|
||||
spv_inst *ins;
|
||||
uint32_t count, cap;
|
||||
int err;
|
||||
} spv_mod;
|
||||
|
||||
int spv_parse(spv_mod *m, const uint32_t *code, size_t bytes);
|
||||
/* Writes the module into a malloc'd buffer; returns its size in bytes (0 on failure). */
|
||||
size_t spv_write(const spv_mod *m, uint32_t **out);
|
||||
void spv_free(spv_mod *m);
|
||||
|
||||
static inline uint32_t spv_version(const spv_mod *m) { return m->header[1]; }
|
||||
static inline uint32_t spv_new_id(spv_mod *m) { return m->header[3]++; }
|
||||
|
||||
/* Insert an instruction before index `at` (at = count appends). Operands copied. Returns index. */
|
||||
uint32_t spv_insert(spv_mod *m, uint32_t at, uint16_t op, const uint32_t *ops, uint16_t nops);
|
||||
void spv_remove(spv_mod *m, uint32_t at);
|
||||
|
||||
/* Index of the first instruction with this opcode (or of the defining instruction of `id`), or -1. */
|
||||
int spv_find_op(const spv_mod *m, uint16_t op, uint32_t from);
|
||||
int spv_find_def(const spv_mod *m, uint32_t id);
|
||||
/* The id an instruction defines (result id), or 0. */
|
||||
uint32_t spv_result_id(const spv_inst *in);
|
||||
|
||||
/* Section boundaries: index where new decorations / types / function code may be inserted. */
|
||||
uint32_t spv_types_end(const spv_mod *m); /* end of the types/constants/globals section */
|
||||
uint32_t spv_annotations_end(const spv_mod *m); /* end of the decoration section */
|
||||
|
||||
/* Types and constants: found when they already exist (non-aggregate types must be unique). */
|
||||
uint32_t spv_type_float(spv_mod *m, uint32_t width);
|
||||
uint32_t spv_type_int(spv_mod *m, uint32_t width, uint32_t sign);
|
||||
uint32_t spv_type_bool(spv_mod *m);
|
||||
uint32_t spv_type_pointer(spv_mod *m, uint32_t storage, uint32_t pointee);
|
||||
uint32_t spv_type_array(spv_mod *m, uint32_t elem, uint32_t len_const);
|
||||
uint32_t spv_const_u32(spv_mod *m, uint32_t v);
|
||||
uint32_t spv_const_f32(spv_mod *m, float v);
|
||||
|
||||
/* Decorations of an id: returns the operand (after the decoration) or -1. */
|
||||
int64_t spv_get_decoration(const spv_mod *m, uint32_t id, uint32_t decoration);
|
||||
void spv_remove_decoration(spv_mod *m, uint32_t id, uint32_t decoration);
|
||||
int spv_has_capability(const spv_mod *m, uint32_t cap);
|
||||
void spv_remove_capability(spv_mod *m, uint32_t cap);
|
||||
void spv_add_capability(spv_mod *m, uint32_t cap);
|
||||
/* The execution model of the (first) entry point, or -1. */
|
||||
int spv_execution_model(const spv_mod *m);
|
||||
/* Adds an interface variable to every entry point. */
|
||||
void spv_add_interface(spv_mod *m, uint32_t var);
|
||||
/* Highest Location used by variables of a storage class (members included), or -1. */
|
||||
int spv_max_location(const spv_mod *m, uint32_t storage);
|
||||
/* Length of an OpTypeArray (via its constant), or 0. */
|
||||
uint32_t spv_array_length(const spv_mod *m, uint32_t array_type);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,146 @@
|
||||
/* SPDX-License-Identifier: GPL-3.0-or-later
|
||||
*
|
||||
* DroidDeck Vulkan bridge - server side (bionic on the device, glibc for host tests).
|
||||
*
|
||||
* The server owns the real Vulkan objects. Linux programs in the session talk to it through the
|
||||
* client ICD (tools/vkbridge/client) over a Unix socket; every connection is one client thread.
|
||||
*/
|
||||
#ifndef VKB_SERVER_H
|
||||
#define VKB_SERVER_H
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "vkb_server_iface.h"
|
||||
#include "vkb_proto.h"
|
||||
#include "vkb_log.h"
|
||||
#include "gen/vkb_server_gen.h"
|
||||
|
||||
#define VKB_MAX_TABLES 65536
|
||||
#define VKB_MAX_PDS 16
|
||||
|
||||
/* A client process (all connections that said hello with the same token). */
|
||||
#define VKB_SEQ_RING 65536
|
||||
|
||||
typedef struct vkb_srv_proc {
|
||||
uint64_t token;
|
||||
int pid;
|
||||
int conns;
|
||||
struct vkb_srv_proc *next;
|
||||
/* Ordering of the process's asynchronous requests (vkb_msg_hdr.seq/barrier). */
|
||||
pthread_mutex_t olock;
|
||||
pthread_cond_t ocond;
|
||||
uint64_t watermark; /* every async seq <= this has run */
|
||||
uint8_t done[VKB_SEQ_RING]; /* seqs above the watermark that have run */
|
||||
int conn_closed; /* a connection ended (a seq may never arrive) */
|
||||
} vkb_srv_proc;
|
||||
|
||||
typedef struct vkb_srv_conn {
|
||||
int sock;
|
||||
vkb_srv_proc *proc;
|
||||
/* Receive buffer: messages are parsed out of it in place (srv_recv). */
|
||||
uint8_t *rb;
|
||||
size_t rcap, rpos, rlen;
|
||||
int fdq[2 * VKB_MAX_FDS]; /* descriptors received ahead of their message's turn */
|
||||
int fdn;
|
||||
vkb_arena arena;
|
||||
pthread_t thread;
|
||||
} vkb_srv_conn;
|
||||
|
||||
/* Startup knowledge about each physical device (keyed by deviceUUID). */
|
||||
typedef struct vkb_pd_knowledge {
|
||||
uint8_t uuid[VK_UUID_SIZE];
|
||||
char name[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
|
||||
vkb_server_pd_info info;
|
||||
int valid;
|
||||
} vkb_pd_knowledge;
|
||||
|
||||
/* A tracked device memory allocation. */
|
||||
typedef struct vkb_srv_mem {
|
||||
VkDeviceMemory mem;
|
||||
VkDeviceSize size;
|
||||
uint32_t type;
|
||||
uint32_t strategy;
|
||||
void *host_ptr; /* hostptr: server's mapping of the client's memfd */
|
||||
size_t host_len;
|
||||
void *mapped; /* server-side vkMapMemory pointer (for flush/invalidate) */
|
||||
void *ahb; /* AHardwareBuffer* (Android) */
|
||||
struct vkb_srv_mem *next;
|
||||
} vkb_srv_mem;
|
||||
|
||||
struct vkb_emu_device;
|
||||
|
||||
typedef struct vkb_srv_table {
|
||||
uint32_t id;
|
||||
int is_device;
|
||||
vkb_srv_proc *proc;
|
||||
VkInstance instance;
|
||||
VkDevice device;
|
||||
VkPhysicalDevice physical; /* device tables */
|
||||
struct vkb_srv_table *parent; /* device -> instance */
|
||||
vkb_dispatch dt; /* what handlers call (may hold emulation wrappers) */
|
||||
vkb_dispatch real; /* the driver's own entry points */
|
||||
uint32_t api_version;
|
||||
const vkb_pd_knowledge *pd;
|
||||
pthread_mutex_t lock;
|
||||
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 */
|
||||
struct vkb_spvfix *spvfix; /* server_spvfix.c */
|
||||
} vkb_srv_table;
|
||||
|
||||
/* server_main.c */
|
||||
extern PFN_vkGetInstanceProcAddr vkb_gipa;
|
||||
extern vkb_dispatch vkb_global_dt;
|
||||
extern int vkb_verbose;
|
||||
|
||||
void vkb_log_summary(void);
|
||||
|
||||
/* server_spvfix.c */
|
||||
void vkb_spvfix_device_init(vkb_srv_table *t);
|
||||
void vkb_spvfix_device_destroy(vkb_srv_table *t);
|
||||
|
||||
/* 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);
|
||||
void vkb_pcache_device_destroy(vkb_srv_table *t);
|
||||
|
||||
/* server_conn.c */
|
||||
void vkb_srv_serve(int listen_fd);
|
||||
vkb_srv_table *vkb_table_get(uint32_t id);
|
||||
uint32_t vkb_table_register(vkb_srv_table *t);
|
||||
void vkb_table_unregister(vkb_srv_table *t);
|
||||
void vkb_srv_reply_status(vkb_srv_call *c, uint32_t status);
|
||||
/* The table of the call being executed on this thread (emulation wrappers use it). */
|
||||
vkb_srv_table *vkb_srv_current_table(void);
|
||||
void vkb_srv_set_current_table(vkb_srv_table *t);
|
||||
void vkb_proc_cleanup(vkb_srv_proc *p);
|
||||
|
||||
/* server_instance.c */
|
||||
void vkb_selftest_all(void);
|
||||
const vkb_pd_knowledge *vkb_pd_lookup(const vkb_dispatch *dt, VkPhysicalDevice pd);
|
||||
extern vkb_pd_knowledge vkb_pds[VKB_MAX_PDS];
|
||||
extern int vkb_npds;
|
||||
|
||||
/* server_memory.c */
|
||||
extern PFN_vkGetDeviceProcAddr vkb_mem_gdpa;
|
||||
void vkb_mem_selftest(vkb_pd_knowledge *k, VkInstance inst, const vkb_dispatch *idt, VkPhysicalDevice pd);
|
||||
const char *const *vkb_mem_required_extensions(uint32_t strategy, uint32_t *count);
|
||||
void vkb_mem_track(vkb_srv_table *dev, vkb_srv_mem *m);
|
||||
vkb_srv_mem *vkb_mem_find(vkb_srv_table *dev, VkDeviceMemory mem, int remove);
|
||||
void vkb_mem_release(vkb_srv_table *dev, vkb_srv_mem *m);
|
||||
void vkb_mem_free_all(vkb_srv_table *dev);
|
||||
|
||||
/* emulation (server_emu*.c) */
|
||||
uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd, uint32_t *missing);
|
||||
void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32_t emu,
|
||||
VkDeviceCreateInfo *ci, vkb_arena *a);
|
||||
void vkb_emu_device_init(vkb_srv_table *dev, uint32_t emu);
|
||||
void vkb_emu_device_destroy(vkb_srv_table *dev);
|
||||
|
||||
#endif
|
||||
@@ -146,6 +146,8 @@ class MainActivity : ComponentActivity() {
|
||||
private var gameCores by mutableStateOf<Set<Int>>(emptySet())
|
||||
private var tuSysmem by mutableStateOf(false)
|
||||
private var zinkLazy by mutableStateOf(false)
|
||||
private var vkBridge by mutableStateOf(false)
|
||||
private val adrenoGpu by lazy { com.droiddeck.launcher.core.DeviceSupport.adreno() }
|
||||
private var noXalia by mutableStateOf(true)
|
||||
private var fastSync by mutableStateOf(false)
|
||||
private var syncFallback by mutableStateOf(true)
|
||||
@@ -554,6 +556,7 @@ class MainActivity : ComponentActivity() {
|
||||
FrontEndScreen(
|
||||
FrontEndState(
|
||||
installed = installed, ready = ready, available = available?.version, removalPending = removalPending, runtimeActionsBlocked = runtimeChangesBlocked(),
|
||||
vkBridge = vkBridge, adreno = adrenoGpu,
|
||||
shortcutPicker = shortcutPicker,
|
||||
shortcutLibraryScanning = shortcutLibraryScanning,
|
||||
gameSyncFolder = gameSyncFolder,
|
||||
@@ -681,6 +684,7 @@ class MainActivity : ComponentActivity() {
|
||||
onInstallPackage = { id -> installPackage(id) },
|
||||
onRemovePackage = { id -> removePackage(id) },
|
||||
onRuntime = { onRuntimeButton() },
|
||||
onVkBridge = { on -> SessionPrefs.setVkBridge(this, on); vkBridge = on },
|
||||
onFrameGenPick = { mode ->
|
||||
FrameGen.set(this, mode)
|
||||
frameGenLabel = FrameGen.label(this)
|
||||
@@ -1575,6 +1579,7 @@ class MainActivity : ComponentActivity() {
|
||||
gameCores = CpuCores.parse(SessionPrefs.gameCpus(this)).ifEmpty { CpuCores.all.toSet() }
|
||||
tuSysmem = SessionPrefs.tuSysmem(this)
|
||||
zinkLazy = SessionPrefs.zinkLazy(this)
|
||||
vkBridge = SessionPrefs.vkBridge(this)
|
||||
noXalia = SessionPrefs.noXalia(this)
|
||||
fastSync = SessionPrefs.fastSync(this)
|
||||
syncFallback = SessionPrefs.syncFallback(this)
|
||||
@@ -1677,7 +1682,7 @@ class MainActivity : ComponentActivity() {
|
||||
// The runtime draws with Turnip, an Adreno driver: on Mali, Xclipse or PowerVR the
|
||||
// compositor gets no usable Vulkan device and a session is sound over a black screen.
|
||||
// Said before the download, not after it; the user may still go ahead.
|
||||
if (installed == null && !com.droiddeck.launcher.core.DeviceSupport.graphicsAvailable()) { showNonAdreno = release; return }
|
||||
if (installed == null && !com.droiddeck.launcher.core.DeviceSupport.canDraw(this)) { showNonAdreno = release; return }
|
||||
install(release)
|
||||
}
|
||||
|
||||
@@ -1689,7 +1694,7 @@ class MainActivity : ComponentActivity() {
|
||||
showPhantomGate = true
|
||||
return false
|
||||
}
|
||||
val warn = installed == null && !com.droiddeck.launcher.core.DeviceSupport.graphicsAvailable()
|
||||
val warn = installed == null && !com.droiddeck.launcher.core.DeviceSupport.canDraw(this)
|
||||
if (warn && available != null) { showNonAdreno = available; return false }
|
||||
startActivity(intent)
|
||||
return true
|
||||
|
||||
@@ -17,6 +17,17 @@ object DeviceSupport {
|
||||
|
||||
internal fun graphicsAvailable(adreno: Boolean, powerVrReady: Boolean): Boolean = adreno || powerVrReady
|
||||
|
||||
/**
|
||||
* Whether the Linux side draws through the Vulkan bridge (tools/vkbridge, PR #517): asked for in
|
||||
* Setup, and only on a GPU that is neither an Adreno nor one the system-Vulkan path (PowerVR,
|
||||
* Xclipse) already handles. An Adreno keeps Turnip whatever the setting says.
|
||||
*/
|
||||
fun vkBridge(context: Context): Boolean =
|
||||
!adreno() && !SystemVulkanDriver.isAvailable() && com.droiddeck.launcher.session.SessionPrefs.vkBridge(context)
|
||||
|
||||
/** A session can draw: Adreno with Turnip, PowerVR/Xclipse on the system driver, or the bridge. */
|
||||
fun canDraw(context: Context): Boolean = graphicsAvailable() || vkBridge(context)
|
||||
|
||||
/** The chip as the device names it, for the card that explains the refusal. */
|
||||
fun gpuName(context: Context): String {
|
||||
val soc = if (Build.VERSION.SDK_INT >= 31) Build.SOC_MODEL.takeIf { it.isNotBlank() && it != Build.UNKNOWN } else null
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
package com.droiddeck.launcher.gpu
|
||||
|
||||
import android.content.Context
|
||||
import android.os.Build
|
||||
import android.os.PowerManager
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.core.SessionPart
|
||||
import java.io.File
|
||||
import java.io.FileWriter
|
||||
import java.text.SimpleDateFormat
|
||||
import java.util.Date
|
||||
import java.util.Locale
|
||||
|
||||
/**
|
||||
* Clocks and thermal state through a Mali bridge session, into the session folder
|
||||
* (vkbridge-clocks.log), for telling the bridge's overhead apart from the phone holding the chip
|
||||
* back: Samsung's SSRM lowers the CPU policies' scaling_max_freq when the device warms, so a
|
||||
* policy whose max is below its cpuinfo_max_freq is being clamped (upstream issue #64).
|
||||
*
|
||||
* Every [PERIOD_MS]: each CPU policy as cur/max(hardware max) MHz, the GPU clock from the first
|
||||
* Mali/MediaTek source the app may read, and Android's thermal status and headroom. Which GPU
|
||||
* sources were readable is logged once at the start - SELinux refuses apps most of them, each
|
||||
* vendor differently, and this is how the next run finds out which.
|
||||
*/
|
||||
class ClockLogComponent(private val logFile: File) : SessionPart() {
|
||||
@Volatile private var running = false
|
||||
private var thread: Thread? = null
|
||||
|
||||
override fun start() {
|
||||
running = true
|
||||
thread = Thread({ run() }, "clock-log").apply { isDaemon = true; start() }
|
||||
}
|
||||
|
||||
override fun stop() {
|
||||
running = false
|
||||
thread?.interrupt()
|
||||
thread = null
|
||||
}
|
||||
|
||||
private fun run() {
|
||||
val policies = File("/sys/devices/system/cpu/cpufreq").listFiles { f -> f.name.startsWith("policy") }
|
||||
?.sortedBy { it.name.removePrefix("policy").toIntOrNull() ?: 0 } ?: emptyList()
|
||||
val gpuCandidates = gpuSources()
|
||||
// The /proc status files hold several numbers: listed for whether they read, not taken as the clock.
|
||||
val gpu = gpuCandidates.firstOrNull { !it.startsWith("/proc/") && firstNumber(it) != null }
|
||||
val power = app().getSystemService(Context.POWER_SERVICE) as? PowerManager
|
||||
val time = SimpleDateFormat("HH:mm:ss", Locale.US)
|
||||
try {
|
||||
FileWriter(logFile, true).use { w ->
|
||||
w.write("== clocks: ${Build.MANUFACTURER} ${Build.MODEL} (${Build.HARDWARE}), every ${PERIOD_MS / 1000}s\n")
|
||||
w.write("cpu policies: ${policies.joinToString { p -> p.name + " " + (File(p, "related_cpus").readTextOrNull()?.trim() ?: "?") }}\n")
|
||||
for (source in gpuCandidates) {
|
||||
val f = File(source)
|
||||
val state = when {
|
||||
!f.exists() -> continue
|
||||
firstNumber(source) != null -> "readable"
|
||||
else -> "refused"
|
||||
}
|
||||
w.write("gpu source $source: $state\n")
|
||||
}
|
||||
w.write("gpu clock from: ${gpu ?: "nothing readable"}\n")
|
||||
w.flush()
|
||||
while (running && logFile.length() < MAX_BYTES) {
|
||||
val line = StringBuilder(time.format(Date()))
|
||||
for (p in policies) {
|
||||
val cur = firstNumber(File(p, "scaling_cur_freq").path)
|
||||
val max = firstNumber(File(p, "scaling_max_freq").path)
|
||||
val hw = firstNumber(File(p, "cpuinfo_max_freq").path)
|
||||
line.append(" ${p.name.removePrefix("policy").let { "p$it" }} ${mhz(cur)}/${mhz(max)}")
|
||||
if (hw != null && max != null && max < hw) line.append("(of ${mhz(hw)})")
|
||||
}
|
||||
gpu?.let { line.append(" | gpu ${mhz(firstNumber(it))} MHz") }
|
||||
if (power != null && Build.VERSION.SDK_INT >= 29) {
|
||||
line.append(" | thermal ${power.currentThermalStatus}")
|
||||
if (Build.VERSION.SDK_INT >= 30) {
|
||||
val h = power.getThermalHeadroom(10)
|
||||
if (!h.isNaN()) line.append(String.format(Locale.US, " headroom %.2f", h))
|
||||
}
|
||||
}
|
||||
w.write(line.append('\n').toString())
|
||||
w.flush()
|
||||
try { Thread.sleep(PERIOD_MS) } catch (e: InterruptedException) { break }
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "clock log stopped: $e")
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "SessionService"
|
||||
private const val PERIOD_MS = 2000L
|
||||
private const val MAX_BYTES = 4L shl 20
|
||||
|
||||
/** Mali (Exynos, Tensor, MediaTek) and MediaTek GED clock files, plus any GPU devfreq node. */
|
||||
private fun gpuSources(): List<String> {
|
||||
val list = mutableListOf(
|
||||
"/sys/kernel/ged/hal/current_freqency", "/sys/kernel/ged/hal/current_frequency",
|
||||
"/proc/gpufreqv2/gpufreq_status", "/proc/gpufreq/gpufreq_var_dump",
|
||||
"/sys/kernel/gpu/gpu_clock", "/sys/class/misc/mali0/device/cur_freq",
|
||||
"/sys/class/misc/mali0/device/clock",
|
||||
)
|
||||
File("/sys/class/devfreq").list()?.sorted()?.forEach { node ->
|
||||
if (node.contains("mali", true) || node.contains("gpu", true)) list.add("/sys/class/devfreq/$node/cur_freq")
|
||||
}
|
||||
return list.distinct()
|
||||
}
|
||||
|
||||
private fun File.readTextOrNull(): String? = runCatching { readText() }.getOrNull()
|
||||
|
||||
private fun firstNumber(path: String): Long? =
|
||||
runCatching { Regex("\\d+").find(File(path).readText())?.value?.toLong() }.getOrNull()
|
||||
|
||||
/** Hz, kHz or MHz to MHz; "?" when unread. */
|
||||
private fun mhz(raw: Long?): String = when {
|
||||
raw == null -> "?"
|
||||
raw > 10_000_000 -> (raw / 1_000_000).toString()
|
||||
raw > 10_000 -> (raw / 1_000).toString()
|
||||
else -> raw.toString()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -342,6 +342,13 @@ public final class TurnipDriver {
|
||||
if (forced.startsWith("a7")) return DRIVER_A7XX;
|
||||
}
|
||||
if (SystemVulkanDriver.isPowerVr()) return null;
|
||||
// Not an Adreno (Mali, Xclipse...): Turnip cannot open a GPU without KGSL. The compositor
|
||||
// runs on the phone's own driver, which has the dma-buf import it needs (the Mali bridge
|
||||
// depends on it too).
|
||||
if (!com.droiddeck.launcher.core.DeviceSupport.INSTANCE.adreno()) {
|
||||
Log.i(TAG, "no KGSL: the compositor uses the system Vulkan driver");
|
||||
return null;
|
||||
}
|
||||
String model = gpuModel();
|
||||
Log.i(TAG, "gpu model: " + (model == null ? "unknown" : model));
|
||||
if (model != null) {
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
package com.droiddeck.launcher.gpu
|
||||
|
||||
import android.os.Process
|
||||
import android.util.Log
|
||||
import com.droiddeck.launcher.core.HostProcess
|
||||
import com.droiddeck.launcher.core.SessionPart
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* The Vulkan bridge server (tools/vkbridge, app/src/main/cpp/vkbridge) for one session.
|
||||
*
|
||||
* On a GPU without Adreno's KGSL nothing inside the Linux runtime can reach the GPU: Turnip needs
|
||||
* KGSL, and the phone's own driver is a bionic library a glibc program cannot load. The server is
|
||||
* a bionic process the app starts here - executed from the native library directory like the
|
||||
* DirectAudio relay - which loads the system Vulkan loader and runs the Vulkan calls the
|
||||
* session's programs send it through the bridge ICD over a Unix socket. It is the app's child, so
|
||||
* it dies with the app (it also asks for that with PR_SET_PDEATHSIG).
|
||||
*
|
||||
* Started before the guest and waited for: the server runs a self-test first (which memory
|
||||
* sharing works on this GPU), and only then listens; a program that starts before the socket
|
||||
* exists would find no Vulkan driver.
|
||||
*/
|
||||
class VkBridgeComponent(private val socket: File, private val logFile: File) : SessionPart() {
|
||||
@Volatile private var pid = -1
|
||||
@Volatile private var exited = false
|
||||
|
||||
override fun start() {
|
||||
stop()
|
||||
val binary = File(app().applicationInfo.nativeLibraryDir, BINARY)
|
||||
if (!binary.isFile) {
|
||||
Log.e(TAG, "server missing at $binary; the session will have no Vulkan")
|
||||
return
|
||||
}
|
||||
socket.parentFile?.mkdirs()
|
||||
// Pipeline cache kept across sessions (Mali recompiles everything in a new process otherwise).
|
||||
val cacheDir = File(app().cacheDir, "vkbridge-pipelines").apply { mkdirs() }
|
||||
if (VkBridgeNative.start(app(), socket, logFile, cacheDir)) {
|
||||
Log.i(TAG, "server ready in the app's process at $socket")
|
||||
return
|
||||
}
|
||||
socket.delete()
|
||||
exited = false
|
||||
val cmd = listOf(binary.absolutePath, "--socket", socket.absolutePath, "--log", logFile.absolutePath,
|
||||
"--cache-dir", cacheDir.absolutePath)
|
||||
.joinToString(" ") { it.replace("\\", "\\\\").replace(" ", "\\ ") }
|
||||
val env = arrayOf("HOME=" + app().filesDir)
|
||||
pid = HostProcess.start(cmd, env, app().filesDir, { status ->
|
||||
exited = true
|
||||
Log.w(TAG, "server exited with status $status")
|
||||
runCatching { logFile.appendText("== vkbridge server exited with status $status\n") }
|
||||
}, { line -> Log.i(TAG, line) })
|
||||
// The self-test takes about a second; a cold driver can take longer.
|
||||
val deadline = System.currentTimeMillis() + 15_000L
|
||||
while (!socket.exists() && !exited && System.currentTimeMillis() < deadline) {
|
||||
try { Thread.sleep(50L) } catch (e: InterruptedException) { Thread.currentThread().interrupt(); break }
|
||||
}
|
||||
Log.i(TAG, if (socket.exists()) "server ready (pid $pid) at $socket" else "server NOT ready (pid $pid, exited=$exited); see $logFile")
|
||||
}
|
||||
|
||||
override fun stop() {
|
||||
// The in-app server outlives sessions: its socket stays.
|
||||
if (pid > 0) {
|
||||
Process.killProcess(pid)
|
||||
pid = -1
|
||||
}
|
||||
if (!VkBridgeNative.serving) socket.delete()
|
||||
}
|
||||
|
||||
override fun suspendPid(): Int = pid
|
||||
|
||||
companion object {
|
||||
private const val TAG = "VkBridge"
|
||||
/** The server, named as a library so Android extracts it and lets the app run it. */
|
||||
const val BINARY = "libvkbridge_server.so"
|
||||
/** Inside the runtime (staged by SessionFiles). */
|
||||
const val GUEST_ICD = "/usr/local/share/vkbridge/droidbridge_icd.json"
|
||||
const val GUEST_LIB = "/usr/local/lib/vkbridge/libvulkan_droidbridge.so"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package com.droiddeck.launcher.gpu
|
||||
|
||||
import android.content.Context
|
||||
import android.content.pm.ApplicationInfo
|
||||
import android.util.Log
|
||||
import java.io.File
|
||||
|
||||
/**
|
||||
* The bridge server inside the app's own process (libvkbridge_jni.so, server_main.c).
|
||||
*
|
||||
* Android chooses the GPU driver - Samsung's updatable one included - while the app starts up, and
|
||||
* only for the app's process: the server run as a separate executable got the plain /vendor driver,
|
||||
* which on the Tab S10+ lacked VK_EXT_robustness2 and more that the app itself sees. Started by the
|
||||
* first bridge session and kept for the app's life; later sessions only point its log at their
|
||||
* own folder. VkBridgeComponent falls back to the executable when this cannot start.
|
||||
*/
|
||||
object VkBridgeNative {
|
||||
private const val TAG = "VkBridge"
|
||||
|
||||
@Volatile private var loaded: Boolean? = null
|
||||
|
||||
/**
|
||||
* The packaged library, or - in a debuggable build only - files/vkbridge/dev/libvkbridge_jni.so
|
||||
* when present, so a rebuilt server can be tried with `adb push` + `run-as cp` and an app
|
||||
* restart instead of a new APK (the app targets SDK 28 and may load code from its files).
|
||||
*/
|
||||
private fun load(context: Context): Boolean {
|
||||
loaded?.let { return it }
|
||||
val ok = try {
|
||||
val dev = File(context.filesDir, "vkbridge/dev/libvkbridge_jni.so")
|
||||
val debuggable = context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE != 0
|
||||
if (debuggable && dev.isFile) {
|
||||
Log.w(TAG, "in-app server from the development override $dev")
|
||||
System.load(dev.absolutePath)
|
||||
} else {
|
||||
System.loadLibrary("vkbridge_jni")
|
||||
}
|
||||
true
|
||||
} catch (e: Throwable) {
|
||||
Log.w(TAG, "in-app server unavailable: $e")
|
||||
false
|
||||
}
|
||||
loaded = ok
|
||||
return ok
|
||||
}
|
||||
|
||||
/** Whether the in-app server is serving (its socket must then be left alone). */
|
||||
@Volatile var serving = false
|
||||
private set
|
||||
|
||||
/** Starts the server, or points its log at [log] when it already runs; false when it cannot serve. */
|
||||
fun start(context: Context, socket: File, log: File, cacheDir: File): Boolean {
|
||||
if (!load(context)) return false
|
||||
val ok = try {
|
||||
nativeStart(socket.absolutePath, log.absolutePath, cacheDir.absolutePath) == 1
|
||||
} catch (e: Throwable) {
|
||||
Log.w(TAG, "in-app server failed to start: $e")
|
||||
false
|
||||
}
|
||||
if (ok) serving = true
|
||||
return ok
|
||||
}
|
||||
|
||||
@JvmStatic private external fun nativeStart(socket: String, log: String, cacheDir: String): Int
|
||||
}
|
||||
@@ -229,6 +229,7 @@ object BwrapSpawner {
|
||||
* own choice of driver (VK_ICD_FILENAMES, MESA_LOADER_DRIVER_OVERRIDE) is left alone.
|
||||
*/
|
||||
private fun gpu(rootfs: String, root: File, env: MutableMap<String, String>): List<Bind>? {
|
||||
env["VKBRIDGE_SOCKET"]?.let { sock -> if (File(sock).exists()) return bridgeGpu(rootfs, root, env, sock) }
|
||||
val lib = File(rootfs, "usr/lib")
|
||||
val driver = File(lib, "libvulkan_freedreno.so")
|
||||
if (!driver.isFile || !File("/dev/kgsl-3d0").exists()) return null
|
||||
@@ -258,6 +259,32 @@ object BwrapSpawner {
|
||||
return binds
|
||||
}
|
||||
|
||||
/**
|
||||
* The GPU through the Mali bridge (tools/vkbridge), for a sandbox started from a bridge
|
||||
* session: the bridge ICD (it needs nothing but libc) and the server's socket, at the paths
|
||||
* the session uses. Unlike Turnip on KGSL it can also present to KWin's shared-memory
|
||||
* windows, so desktop apps get it too. The session's own VK_DRIVER_FILES points at the
|
||||
* runtime's copy of the manifest, which the sandbox cannot see; it is replaced here.
|
||||
*/
|
||||
private fun bridgeGpu(rootfs: String, root: File, env: MutableMap<String, String>, socket: String): List<Bind>? {
|
||||
val driver = File(rootfs, "usr/local/lib/vkbridge/libvulkan_droidbridge.so")
|
||||
if (!driver.isFile) { Log.w(TAG, "gpu: vkbridge session but no bridge ICD in the runtime"); return null }
|
||||
val binds = ArrayList<Bind>()
|
||||
binds.add(Bind(driver.canonicalPath, "$GPU_DIR/libvulkan_droidbridge.so"))
|
||||
val sockDir = File(socket).parent ?: return null
|
||||
binds.add(Bind(sockDir, sockDir))
|
||||
val icd = File(root.parentFile, "vkbridge_icd.json")
|
||||
icd.writeText("{\"file_format_version\": \"1.0.0\", \"ICD\": {\"library_path\": \"$GPU_DIR/libvulkan_droidbridge.so\", \"api_version\": \"1.3.247\"}}\n")
|
||||
binds.add(Bind(icd.path, "$GPU_DIR/vkbridge_icd.json"))
|
||||
env["VK_DRIVER_FILES"] = "$GPU_DIR/vkbridge_icd.json"
|
||||
env["VK_ICD_FILENAMES"] = "$GPU_DIR/vkbridge_icd.json"
|
||||
if (!env.containsKey("MESA_LOADER_DRIVER_OVERRIDE") && !env.containsKey("GALLIUM_DRIVER")) {
|
||||
env["MESA_LOADER_DRIVER_OVERRIDE"] = "zink"
|
||||
env["GALLIUM_DRIVER"] = "zink"
|
||||
}
|
||||
return binds
|
||||
}
|
||||
|
||||
/**
|
||||
* What every program in the session preloads (SessionFiles writes /etc/ld.so.preload): the
|
||||
* session shim - SysV shared memory for X11, the network calls Android refuses - and the
|
||||
|
||||
@@ -332,10 +332,40 @@ public final class LinuxRuntime {
|
||||
* may open) stands in: it appears as a render node with the sysfs entries libdrm reads, and our
|
||||
* Turnip build reports the same device numbers for it.
|
||||
*/
|
||||
/** Mali's kbase device, the stand-in render node on a Mali GPU (the Mali bridge's gamescope). */
|
||||
private static final String MALI_DEVICE = "/dev/mali0";
|
||||
|
||||
/**
|
||||
* The device that stands in for the GPU's render node: KGSL on an Adreno; with the Mali bridge
|
||||
* on, Mali's own device - nothing inside opens it for rendering (the bridge does that on the
|
||||
* Android side), but gamescope and libdrm need a render node to name before they offer
|
||||
* linux-dmabuf, and the bridge ICD reports this one's numbers. Null when there is none.
|
||||
*/
|
||||
public static String gpuStandIn(Context context) {
|
||||
if (new File(KGSL_DEVICE).exists()) return KGSL_DEVICE;
|
||||
if (com.droiddeck.launcher.core.DeviceSupport.INSTANCE.vkBridge(context) && new File(MALI_DEVICE).exists()) return MALI_DEVICE;
|
||||
return null;
|
||||
}
|
||||
|
||||
/** "major:minor" of a device node, or null. */
|
||||
public static String deviceNumbers(String path) {
|
||||
try {
|
||||
long dev = Os.stat(path).st_rdev;
|
||||
long major = ((dev >> 8) & 0xfff) | ((dev >> 32) & ~0xfffL);
|
||||
long minor = (dev & 0xff) | ((dev >> 12) & ~0xffL);
|
||||
return major + ":" + minor;
|
||||
} catch (ErrnoException e) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static void bindGpuNode(Context context, List<String> cmd) {
|
||||
String standIn = gpuStandIn(context);
|
||||
if (standIn == null) return;
|
||||
boolean kgsl = standIn.equals(KGSL_DEVICE);
|
||||
StructStat st;
|
||||
try {
|
||||
st = Os.stat(KGSL_DEVICE);
|
||||
st = Os.stat(standIn);
|
||||
} catch (ErrnoException e) {
|
||||
return;
|
||||
}
|
||||
@@ -355,7 +385,8 @@ public final class LinuxRuntime {
|
||||
Files.write(new File(drm, "dev").toPath(),
|
||||
(major + ":" + minor + "\n").getBytes(StandardCharsets.UTF_8));
|
||||
Files.write(new File(device, "uevent").toPath(),
|
||||
"DRIVER=kgsl-3d0\nMODALIAS=platform:kgsl-3d0\n".getBytes(StandardCharsets.UTF_8));
|
||||
(kgsl ? "DRIVER=kgsl-3d0\nMODALIAS=platform:kgsl-3d0\n" : "DRIVER=mali\nMODALIAS=platform:mali\n")
|
||||
.getBytes(StandardCharsets.UTF_8));
|
||||
File subsystem = new File(device, "subsystem");
|
||||
if (!Files.isSymbolicLink(subsystem.toPath())) {
|
||||
Os.symlink("/sys/bus/platform", subsystem.getPath());
|
||||
@@ -363,7 +394,7 @@ public final class LinuxRuntime {
|
||||
// What MangoHud names a GPU's driver by; msm_drm is how an Adreno's render node reads
|
||||
// on a mainline kernel, and the driver it reads the load of (bindAdrenoStats).
|
||||
File driver = new File(device, "driver");
|
||||
if (!Files.isSymbolicLink(driver.toPath())) {
|
||||
if (kgsl && !Files.isSymbolicLink(driver.toPath())) {
|
||||
Os.symlink("/sys/bus/platform/drivers/msm_drm", driver.getPath());
|
||||
}
|
||||
} catch (IOException | ErrnoException e) {
|
||||
@@ -371,7 +402,7 @@ public final class LinuxRuntime {
|
||||
}
|
||||
bind(cmd, new File(base, "sys").getPath() + ":/sys/dev/char");
|
||||
bind(cmd, dri.getPath() + ":/dev/dri");
|
||||
bind(cmd, KGSL_DEVICE + ":/dev/dri/" + node);
|
||||
bind(cmd, standIn + ":/dev/dri/" + node);
|
||||
bindDrmClass(base, cmd, node, major + ":" + minor);
|
||||
}
|
||||
|
||||
|
||||
@@ -143,6 +143,10 @@ object SessionFiles {
|
||||
} + listOf("libthunkaudit.so", "libvulkan-thunk.so").map { "x86_64/$it" to "usr/local/lib/droiddeck-fex/x86_64/$it" }
|
||||
val optional = (arrayOf(
|
||||
"usr/local/bin/gamescope" to "usr/local/bin/gamescope",
|
||||
// The Mali bridge's Linux side (tools/vkbridge): the ICD, its manifest and the self-test.
|
||||
"usr/local/lib/vkbridge/libvulkan_droidbridge.so" to "usr/local/lib/vkbridge/libvulkan_droidbridge.so",
|
||||
"usr/local/share/vkbridge/droidbridge_icd.json" to "usr/local/share/vkbridge/droidbridge_icd.json",
|
||||
"usr/local/bin/droiddeck-vkbridge-smoke" to "usr/local/bin/droiddeck-vkbridge-smoke",
|
||||
"usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime",
|
||||
"usr/local/share/licenses/uruntime/LICENSE" to "usr/local/share/licenses/uruntime/LICENSE",
|
||||
) + mangoapp + xclipse.map { it to it } + listOf("comet", "GalaxyCommunication.exe", "update-permissions.exe", "LICENSE", "version").map { "usr/local/lib/droiddeck-comet/$it" to "usr/local/lib/droiddeck-comet/$it" } + msitools.map { it to it } + fexPreloads).filter { (asset, _) ->
|
||||
|
||||
@@ -497,6 +497,18 @@ object SessionPrefs {
|
||||
*/
|
||||
fun zinkLazy(context: Context): Boolean = prefs(context).getBoolean("zinkLazy", true)
|
||||
|
||||
/**
|
||||
* The Mali bridge (experimental): the session's Vulkan goes through the app's bridge server to
|
||||
* the phone's own driver instead of Turnip (tools/vkbridge). Only offered, and only used, on a
|
||||
* GPU without Adreno's KGSL; off by default everywhere.
|
||||
*/
|
||||
@JvmStatic
|
||||
fun vkBridge(context: Context): Boolean = prefs(context).getBoolean("vkBridge", false)
|
||||
|
||||
fun setVkBridge(context: Context, on: Boolean) {
|
||||
prefs(context).edit().putBoolean("vkBridge", on).apply()
|
||||
}
|
||||
|
||||
fun setZinkLazy(context: Context, on: Boolean) {
|
||||
prefs(context).edit().putBoolean("zinkLazy", on).apply()
|
||||
}
|
||||
|
||||
@@ -372,6 +372,7 @@ class SessionService : Service() {
|
||||
val fastPathAt = guest.size
|
||||
|
||||
val pulse = startAudio(guest, sessionDir)
|
||||
startVkBridge(guest, sessionDir)
|
||||
|
||||
guest.add("BL_WIDTH=" + size.first)
|
||||
guest.add("BL_HEIGHT=" + size.second)
|
||||
@@ -629,10 +630,13 @@ class SessionService : Service() {
|
||||
// import falls back to. One driver for every session: the driver's shader cache is keyed on
|
||||
// its build, and with one per mode every emulator compiled its shaders twice.
|
||||
val linuxDriverId = SessionPrefs.linuxDriver(this)
|
||||
if (SystemVulkanDriver.usesDefault(linuxDriverId)) {
|
||||
// Mali bridge (PR #517) on: the bridge ICD is the driver (startVkBridge). Otherwise the system
|
||||
// PowerVR/Xclipse path (PR #570) or the imported/runtime Turnip, as before.
|
||||
val bridge = com.droiddeck.launcher.core.DeviceSupport.vkBridge(this)
|
||||
if (!bridge && SystemVulkanDriver.usesDefault(linuxDriverId)) {
|
||||
SystemVulkanDriver.addEnvironment(this, guest)
|
||||
}
|
||||
LinuxVulkanDriver.resolveIcdPath(this, linuxDriverId)
|
||||
(if (bridge) null else LinuxVulkanDriver.resolveIcdPath(this, linuxDriverId))
|
||||
?.let { guest.add(LinuxVulkanDriver.ENV + "=" + it) }
|
||||
// Turnip's own debug switches, for the runtime's driver and everything on it. The file in
|
||||
// Downloads holds the value verbatim ("sysmem", "sysmem,deck_emu"); with nothing there, an
|
||||
@@ -696,6 +700,35 @@ class SessionService : Service() {
|
||||
.takeIf { it.isNotEmpty() }?.let { guest.add("BL_GAME_CPUS=$it") }
|
||||
}
|
||||
|
||||
/**
|
||||
* The Mali bridge (Setup's experimental switch, non-Adreno GPUs only): the server that runs the
|
||||
* session's Vulkan calls on the phone's own driver, started before the guest. The session
|
||||
* script points the Vulkan loader at the bridge ICD when it sees BL_VKBRIDGE and runs the
|
||||
* bridge's self-test into the session log first; both sides log into the session folder.
|
||||
*/
|
||||
private fun startVkBridge(guest: MutableList<String>, sessionDir: File) {
|
||||
if (!com.droiddeck.launcher.core.DeviceSupport.vkBridge(this)) return
|
||||
// Under the files dir, which the session binds at its own path: one string for both sides.
|
||||
val socket = File(filesDir, "vkbridge/server.sock")
|
||||
val bridge = com.droiddeck.launcher.gpu.VkBridgeComponent(socket, File(sessionDir, "vkbridge-server.log"))
|
||||
bridge.attach(this)
|
||||
components.add(bridge)
|
||||
com.droiddeck.launcher.gpu.ClockLogComponent(File(sessionDir, "vkbridge-clocks.log")).let {
|
||||
it.attach(this)
|
||||
components.add(it)
|
||||
}
|
||||
guest.add("BL_VKBRIDGE=1")
|
||||
guest.add("VKBRIDGE_SOCKET=" + socket.path)
|
||||
guest.add("VKBRIDGE_CLIENT_LOG=" + File(sessionDir, "vkbridge-client.log").path)
|
||||
// The render node gamescope sees is Mali's device standing in (LinuxRuntime.bindGpuNode):
|
||||
// the ICD reports its numbers, and the session shim answers PRIME calls on it as on KGSL.
|
||||
LinuxRuntime.gpuStandIn(this)?.let { node ->
|
||||
guest.add("BL_DRM_STANDIN=$node")
|
||||
LinuxRuntime.deviceNumbers(node)?.let { guest.add("VKBRIDGE_DRM_RENDER=$it") }
|
||||
}
|
||||
Log.i(TAG, "vkbridge: on (${com.droiddeck.launcher.core.DeviceSupport.gpuName(this)}), socket $socket")
|
||||
}
|
||||
|
||||
/** PulseAudio, and the DirectAudio relay when a path needs it; returns the daemon for suspend and resume. */
|
||||
private fun startAudio(guest: MutableList<String>, sessionDir: File): PulseAudioComponent {
|
||||
// PulseAudio always: the client is a native Linux program and has no other way to make a
|
||||
|
||||
@@ -130,6 +130,10 @@ class FrontEndState(
|
||||
val oscMode: String = SessionPrefs.OSC_AUTO,
|
||||
val controller: com.droiddeck.launcher.input.ControllerPrefs.Settings? = null,
|
||||
val phantomProcessStatus: PhantomProcessStatus = PhantomProcessStatus.NOT_APPLICABLE,
|
||||
/** The GPU is an Adreno (Turnip); otherwise Setup offers the experimental Mali bridge. */
|
||||
val adreno: Boolean = true,
|
||||
/** Setup's "Mali bridge (experimental)" (SessionPrefs.vkBridge). */
|
||||
val vkBridge: Boolean = false,
|
||||
val showPhantomGate: Boolean = false,
|
||||
val orientation: Int = android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE,
|
||||
val launcherFullscreen: Boolean = true,
|
||||
@@ -187,6 +191,7 @@ class FrontEndActions(
|
||||
val onInstallPackage: (String) -> Unit,
|
||||
val onRemovePackage: (String) -> Unit,
|
||||
val onRuntime: () -> Unit,
|
||||
val onVkBridge: (Boolean) -> Unit = {},
|
||||
val onFrameGenPick: (FrameGen.Mode) -> Unit,
|
||||
val onImportLossless: () -> Unit,
|
||||
val onProtons: () -> Unit,
|
||||
|
||||
@@ -212,9 +212,17 @@ internal fun SetupPanel(
|
||||
when (gpu.support) {
|
||||
com.droiddeck.launcher.gpu.GpuInfo.Support.TESTED -> stringResource(R.string.setup_gpu_detail, gpu.displayName(ctx), gpuName)
|
||||
com.droiddeck.launcher.gpu.GpuInfo.Support.UNTESTED -> stringResource(R.string.setup_gpu_untested_detail, gpu.displayName(ctx), gpu.supportText(ctx).replaceFirstChar { it.lowercase() })
|
||||
else -> stringResource(R.string.setup_gpu_unsupported_detail, gpuName)
|
||||
else -> if (s.vkBridge) stringResource(R.string.setup_gpu_bridge_detail, gpuName)
|
||||
else stringResource(R.string.setup_gpu_unsupported_detail, gpuName)
|
||||
},
|
||||
divider = divider,
|
||||
// Not an Adreno: the experimental Vulkan bridge is the one way to draw.
|
||||
action = if (s.adreno) null else { {
|
||||
SecondaryButton(
|
||||
stringResource(if (s.vkBridge) R.string.setup_gpu_bridge_on else R.string.setup_gpu_bridge_off),
|
||||
enabled = !s.sessionRunning, compact = true, onClick = { a.onVkBridge(!s.vkBridge) },
|
||||
)
|
||||
} },
|
||||
)
|
||||
}
|
||||
val runtimeCheck: @Composable (Boolean) -> Unit = { divider ->
|
||||
|
||||
@@ -2322,4 +2322,7 @@
|
||||
<string name="gog_achievements_enable_store">Enable GOG achievements in Stores settings</string>
|
||||
<string name="gog_achievements_unavailable">Achievements unavailable; check session logs</string>
|
||||
<string name="achievement_unlocked">Achievement unlocked</string>
|
||||
<string name="setup_gpu_bridge_off">Mali bridge: off</string>
|
||||
<string name="setup_gpu_bridge_on">Mali bridge: on</string>
|
||||
<string name="setup_gpu_bridge_detail">%1$s is not an Adreno. The experimental Vulkan bridge is on: the session draws through the phone\'s own driver. Expect bugs; send the session logs.</string>
|
||||
</resources>
|
||||
Reference in new issue
Block a user