diff options
Diffstat (limited to 'tools/guest-diag/gl_frames.c')
| -rw-r--r-- | tools/guest-diag/gl_frames.c | 237 |
1 files changed, 237 insertions, 0 deletions
diff --git a/tools/guest-diag/gl_frames.c b/tools/guest-diag/gl_frames.c new file mode 100644 index 0000000..d442d66 --- /dev/null +++ b/tools/guest-diag/gl_frames.c @@ -0,0 +1,237 @@ +// SPDX-License-Identifier: BSD-3-Clause +/* + * gl_frames.c - render animated frames with direct GL (GLX pbuffer) on the + * guest's NVIDIA vGPU and publish them into the ivshmem (kvmfr) BAR so the + * host can see what the GL client actually rendered. + * + * This is the GL sibling of tools/cuda-ab/frame_producer.cu: the transport + * (guest GPU -> guest sysmem -> ivshmem -> host frame_reader.py) is identical, + * but the pixels come from the direct-GL client channel instead of CUDA. + * The pbuffer avoids the X window draw path that wedges the X server. + * + * Layout at BAR offset 0x100000 (same as frame_producer.cu): + * struct frame_hdr { magic, version, width, height, stride, format, seq } + * then width*height*4 bytes of RGBA8. + * + * Usage: sudo ./gl_frames [frames] [width] [height] [fps] + * Prints: FRAME seq=<n> ms=<render+readback ms> + */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdint.h> +#include <time.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <glob.h> +#include <math.h> +#include <X11/Xlib.h> +#include <GL/glx.h> +#include <GL/gl.h> + +#define FRAME_OFFSET 0x100000UL +#define HDR_MAGIC 0x4b564d46u /* "FMVK" little-endian-ish */ +#define BAR_BYTES (128UL << 20) +#define BAR_PATH_DEF "/sys/bus/pci/devices/0000:00:04.0/resource2" + +struct frame_hdr { + uint32_t magic; + uint32_t version; + uint32_t width; + uint32_t height; + uint32_t stride; + uint32_t format; /* 0 = RGBA8 */ + uint32_t seq; + uint32_t reserved; + uint64_t timestamp_ns; +}; + +/* + * The ivshmem kvmfr device moves with the QEMU topology (it was 00:03.0 in an + * older launch, 00:04.0 in the current one). Discover the 128 MiB BAR instead + * of hardcoding a slot; GL_FRAMES_BAR overrides for debugging. + */ +static const char *find_bar(char *buf, size_t len) +{ + glob_t g; + size_t i; + const char *hit = NULL; + + if (glob("/sys/bus/pci/devices/*/resource2", 0, NULL, &g) != 0) + return NULL; + for (i = 0; i < g.gl_pathc; i++) { + struct stat st; + + if (stat(g.gl_pathv[i], &st) == 0 && + (unsigned long long)st.st_size == BAR_BYTES) { + snprintf(buf, len, "%s", g.gl_pathv[i]); + hit = buf; + break; + } + } + globfree(&g); + return hit; +} + +static uint64_t now_ns(void) +{ + struct timespec ts; + + clock_gettime(CLOCK_MONOTONIC, &ts); + return (uint64_t)ts.tv_sec * 1000000000ull + ts.tv_nsec; +} + +static void draw_frame(int f, int w, int h) +{ + float a = (float)f * 0.15f; + int i; + + glViewport(0, 0, w, h); + glClearColor(0.05f, 0.05f, 0.10f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + for (i = 0; i < 8; i++) { + float t = a + (float)i * 0.78539816339f; + + glBegin(GL_TRIANGLES); + glColor3f(1.0f, 0.2f + 0.09f * i, 0.1f); + glVertex2f(0.0f, 0.0f); + glColor3f(0.1f, 0.9f, 0.3f); + glVertex2f(0.75f * cosf(t), 0.75f * sinf(t)); + glColor3f(0.2f, 0.3f, 1.0f); + glVertex2f(0.55f * cosf(t + 0.5f), + 0.55f * sinf(t + 0.5f)); + glEnd(); + } + glFinish(); +} + +int main(int argc, char **argv) +{ + int frames = argc > 1 ? atoi(argv[1]) : 30; + int w = argc > 2 ? atoi(argv[2]) : 640; + int h = argc > 3 ? atoi(argv[3]) : 480; + int fps = argc > 4 ? atoi(argv[4]) : 5; + static int attribs[] = { + GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT, + GLX_RENDER_TYPE, GLX_RGBA_BIT, + GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, + GLX_ALPHA_SIZE, 8, + None + }; + GLXFBConfig *fb; + GLXPbuffer pb; + XVisualInfo *vi; + GLXContext ctx; + Display *d; + int scr, n = 0, fd, i; + unsigned char *bar, *px; + struct frame_hdr *hdr; + volatile uint32_t *seqp; + + char found[256]; + const char *bar_path = getenv("GL_FRAMES_BAR"); + + setvbuf(stdout, NULL, _IONBF, 0); + if (!bar_path) + bar_path = find_bar(found, sizeof(found)); + if (!bar_path) + bar_path = BAR_PATH_DEF; + printf("BAR %s\n", bar_path); + fd = open(bar_path, O_RDWR | O_SYNC); + if (fd < 0) { + printf("OPEN_FAIL %s\n", bar_path); + return 1; + } + bar = (unsigned char *)mmap(NULL, BAR_BYTES, PROT_READ | PROT_WRITE, + MAP_SHARED, fd, 0); + if (bar == MAP_FAILED) { + printf("MMAP_FAIL\n"); + return 1; + } + hdr = (struct frame_hdr *)(bar + FRAME_OFFSET); + seqp = &hdr->seq; + + d = XOpenDisplay(NULL); + if (!d) { + printf("NODISPLAY\n"); + return 2; + } + scr = DefaultScreen(d); + fb = glXChooseFBConfig(d, scr, attribs, &n); + if (!fb || n < 1) { + printf("NOFBCONFIG\n"); + return 3; + } + pb = glXCreatePbuffer(d, fb[0], (int[]){ + GLX_PBUFFER_WIDTH, w, GLX_PBUFFER_HEIGHT, h, None }); + if (!pb) { + printf("NOPBUFFER\n"); + return 4; + } + vi = glXGetVisualFromFBConfig(d, fb[0]); + ctx = glXCreateContext(d, vi, NULL, True); + if (!ctx) { + printf("NOCTX\n"); + return 5; + } + if (!glXMakeCurrent(d, pb, ctx)) { + printf("MAKECURRENT_FAIL\n"); + return 6; + } + printf("GL %s | %s\n", (const char *)glGetString(GL_VENDOR), + (const char *)glGetString(GL_RENDERER)); + + px = (unsigned char *)malloc((size_t)w * h * 4); + if (!px) { + printf("HOST_ALLOC_FAIL\n"); + return 7; + } + + hdr->magic = HDR_MAGIC; + hdr->version = 1; + hdr->width = (uint32_t)w; + hdr->height = (uint32_t)h; + hdr->stride = (uint32_t)w * 4; + hdr->format = 0; + + for (i = 0; i < frames; i++) { + uint64_t t0 = now_ns(); + uint32_t seq; + + draw_frame(i, w, h); + glReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, px); + if (glGetError() != GL_NO_ERROR) + printf("GL_ERROR frame=%d\n", i); + memcpy(bar + FRAME_OFFSET + sizeof(struct frame_hdr), px, + (size_t)w * h * 4); + hdr->timestamp_ns = now_ns(); + __sync_synchronize(); + seq = (uint32_t)(i + 1); + *seqp = seq; + __sync_synchronize(); + printf("FRAME seq=%u ms=%.1f px0=%02x%02x%02x%02x\n", seq, + (double)(now_ns() - t0) / 1e6, + px[0], px[1], px[2], px[3]); + if (fps > 0) + usleep((useconds_t)(1000000 / fps)); + } + printf("FRAME_DONE frames=%d %dx%d\n", frames, w, h); + + glXMakeCurrent(d, None, NULL); + glXDestroyContext(d, ctx); + glXDestroyPbuffer(d, pb); + XCloseDisplay(d); + free(px); + munmap(bar, BAR_BYTES); + close(fd); + return 0; +} |