feat(dev): LONGSHOT_TRACY=1 builds the game and the renderer with the Tracy profiler's zones, localhost only #1543

Merged
HumanBean merged 3 commits from HumanBean/Longshot:feat/tracy into main 2026-11-18 03:06:59 +00:00
Owner

Type: feat · Risk: low · Tested on: Linux, RTX 3090 (NVIDIA 620.70) · Needs: Windows, any GPU (a build with the option on)

TL;DR

Finding where a frame's time goes took a sampler, wait records and a per-frame CSV put together by hand, and that misled us several times. This PR adds a developer's build option, LONGSHOT_TRACY=1, that builds the game and the renderer with the Tracy profiler: every thread, wait, lock, NVN call and renderer stage on one timeline. A player's build is unchanged: with the option off nothing of Tracy is compiled. It ran in two played sessions (89 s, 29.7 million zones), which showed the main thread of a Market frame spending about 10 of 18.6 ms in one job-loop wait.

Breakdown

  • Who it helps: developers looking for what limits the frame rate or causes a freeze; no player's build has it.
  • What was wrong: there was no single timeline of threads, waits and renderer stages; the existing tools had to be combined by hand.
  • What changes: a build made with LONGSHOT_TRACY=1 carries Tracy's client (127.0.0.1 only, nothing announced on the network) and zones in the host and the renderer.
  • What does not change: every build without the option: no Tracy code, the same flags and objects (11 of 12 touched sources compile to byte-identical objects; the twelfth differs only in __LINE__ constants).
  • How it was checked: two play sessions with a capture each, headless smoke captures, the game-free checks (none fails that passes on main), an object-by-object comparison with the option off.
  • What is still open: the zones in the lifted game code are not working yet (off by default, see Testing); Windows was never compiled with the option; AMD and Intel not run; the viewer GUI not used (only tracy-capture and tracy-csvexport).
  • Risk: low: the option is off by default and every zone site is inside #ifdef TRACY_ENABLE.

Why

The frame rate in Castle Town's market is limited on the CPU side and there are half-second freezes in play. The tools we had (the profiling mode's sampler, HOS_CHAIN's wait and wake records, the frame trace) each show one part, and putting them together by hand gave wrong answers more than once. Tracy shows all of it on one timeline, live or from a file. No issue in the tracker asks for this (searched the open issues for "tracy" and "profil").

What changed

A build option, a vendored client, one wrapper header and zones at the places that matter; nothing else in the build moves.

  • third_party: third_party/tracy is Tracy 0.15.0's public/ folder and LICENSE, unmodified, with its PROVENANCE.md (tag v0.15.0, commit f2a4f25, archive and tree hashes). 0.15.0 is the version of the AUR's tracy viewer: the protocol is locked to the version.
  • build (nx2/build.py): LONGSHOT_TRACY=1 compiles public/TracyClient.cpp into the game's executable alone, which exports Tracy's C API (___tracy_*); longshot_vk.so calls that one client, so the process has exactly one. Defines: TRACY_ONLY_LOCALHOST, TRACY_NO_BROADCAST, TRACY_ON_DEMAND, TRACY_NO_CRASH_HANDLER, TRACY_NO_CODE_TRANSFER, TRACY_MANUAL_LIFETIME (the game's main starts the client, so the crash window's helper process has none), TRACY_FIBERS. The lifted game code is not compiled again. On Windows the executable's import library is what the renderer's DLL links: written, never built.
  • host/hos_tracy.h: the only header a call site includes (C and C++): scoped zones, waits in their own colour, zone text, frame marks, plots, thread names, fibers, and "lock wait" zones for every SRW lock and critical section of a file that has to wait. Every use in the sources is inside #ifdef TRACY_ENABLE, because many checks compile one function cut from a source file.
  • host: frame marks at nvnQueuePresentTexture; guest waits and signals in host/nn_os_sync.c (events, semaphores, queues, WaitAny, condition variables, mutexes, with the object's guest address and the guest caller); sleeps, yields, virtual-core waits, kernel waits, joins and fiber switches in host/hos_thread.c; the NVN calls that work or wait on a game thread in host/nvn_native.c; thread names where the host already names threads.
  • renderer: each render-thread job, the replay's parts and submits, per-draw zones (draw, build_descriptors, bind_descriptors, program_for; RX_VK_TRACY_DRAWS=0 leaves them out), memory sync and captures, texture create and upload, pipeline builds, the workers, the recorder's idle time, the present; plots of the frame time and, with the frame trace on, its main columns.
  • the game's own code (nx2/tracy_funcs.py, nx2/tracy_funcs.txt, host/hos_tracy_game.c; Linux): listed lifted functions become zones at the link, by rewriting the symbol table of a copy of the chunk's object (no translation, no compile), and the indirect calls of the two job loops become zones by compiling one chunk again (about 20 s). Recorded only with HOS_TRACY_GAME=1 and not working yet: see Testing.
  • docs: docs/development/tracy.md (build, capture, what each zone is, the privacy rule), linked from docs/development.md.
  • tests: tests/test_tracy_funcs.py (the list, the object patch on two small C files, the calls header, and that no zone macro sits outside #ifdef TRACY_ENABLE); tests/test_shader_stamp_cache.py gets the new build globals.

A capture holds the game's function names and timings: it is made from the game and never leaves the PC. The doc says so, and the client cannot be reached from another machine.

Measurements

Verdict: the option off costs nothing (same objects). The option on, while a capture is taken, costs frame rate; these are first numbers, not a controlled A/B, which is still to do.

Hardware: Linux, RTX 3090, NVIDIA 620.70, Ryzen 9 7900X.
Scene: played sessions at 2560x1440 with DLSS Quality; headless smoke runs at 2048x1152 in Kokiri Forest.
Method: the played sessions' frame counts and file sizes from tracy-capture; the headless runs' vk: ... fps log lines and the captures' frame counts.

Without Tracy Tracy build, capturing
played session 2 (alone on the PC, 6 cores), RX_VK_TRACY_DRAWS=0 about 70 fps 53.8 fps; 89 s, 5,039 frames, 29.7 million zones, 299 MB file
played session 1 (another game and 9,200 pipeline builds beside it), RX_VK_TRACY_DRAWS=0 90 s, 2,741 frames, 16.8 million zones, 198 MB file
headless smoke, per-draw zones on, Tracy's sampler on 65 fps before the capture (same build, not capturing) 15 to 19 fps; 20 s, 4.86 million zones (243,000 a second), 558,627 samples, 45 MB file

Option off, object by object (the base build's own compile commands, main @ 310e7c9d against this branch): hos_thread.c, nn_os_sync.c, nvn_native.c, hos_svc.c, hos_mem.c, posix/win32_posix.c, vk_replay.cpp, vk_memory.cpp, vk_texture.cpp, vk_jobs.cpp, vk_framegen.cpp: the same object, byte for byte. vk_draw.cpp: the same size and code; four __LINE__ constants of its SKIP_HERE macro differ, because lines moved.

Build time with the option on, as a pack over a base: 27 s to 1 min 21 s (the host's and the renderer's own files, Tracy's client, one lifted chunk for the job loops' calls, the links).

Flags and settings

Three: a build option and two run-time switches that exist only in a build made with it.

Flag What it is Before this PR After this PR Effect Helps / doesn't help / untested Recommendation
LONGSHOT_TRACY=1 build option (nx2/build.py) did not exist off builds the game and renderer with Tracy's client and zones Linux run; Windows untested off: a developer's build only
RX_VK_TRACY_DRAWS switch did not exist on (in a Tracy build) =0 leaves the four per-draw zones out of a capture about a quarter of the zones on; =0 for long captures
HOS_TRACY_GAME switch did not exist off =1 records the lifted game code's zones (funcs, calls: one kind) not working yet off until fixed
LONGSHOT_TRACY_FUNCS=<file> build option did not exist unset adds a list of lifted functions to make zones of untested unset

Testing

Tested: Linux, RTX 3090, NVIDIA 620.70, Ryzen 9 7900X. Two played sessions on the first version of this branch with tracy-capture on 127.0.0.1:8086 (numbers above): the capture connected at once, tracy-csvexport read both files, no error line in either log. Headless smoke runs of the current code with the game's zones off: a 20 s capture with 61 zone names from the host and the renderer, every game and renderer thread by its name (the job workers, the actor executors, the render, recorder and presenter threads), a fiber's row, and Tracy's sampler's samples as an ordinary user (perf_event_paranoid 2). Game-free checks: tests/run_all.py --changed 382 pass, 36 fail, and the same 36 fail on a clean checkout of main @ 310e7c9d on this PC (I ran them there: test_switch_table.py and 35 others); tests/test_tracy_funcs.py and scripts/check_third_party.py pass.

Not tested: the last small change (the game's zones off by default, the order check) was built in the step before it, not after; a capture with the viewer GUI (not installed here); a capture longer than 90 s; whether the sampler's symbols of the lifted functions resolve (the 20 s smoke capture ended before any symbol was resolved); AMD and Intel GPUs.

Not working: the game-code zones (HOS_TRACY_GAME=1). With the listed functions and the job loops' calls both on, Tracy stops the capture a few milliseconds in ("Invalid order of zone begin and end events"): a 0.0 s capture. With the functions alone a 20 s capture is fine; with the calls alone it records and tracy-capture crashes while saving. Fibers were ruled out (no fiber switch happens inside such a zone). A check that names the zone ending out of turn is in; the fix follows on this branch.

Must be tested:

  • Windows, any GPU: build with LONGSHOT_TRACY=1 (llvm-mingw), expecting the game and longshot_vk.dll to link (the DLL against the executable's import library longshot_tracy.lib) and the game to start; then tracy-capture -o run.tracy, expecting zones from both modules (Test Farm: @Beanstalk windows, a build with LONGSHOT_TRACY=1 and a start of the game).
  • Windows and Linux, any GPU: an ordinary build (the option off), expecting it to build and play as main does (Test Farm: @Beanstalk the usual comparison against main).

Risks

What could break: nothing in a build without the option, as far as the object comparison shows. In a Tracy build: a capture slows the game; a zone that ends out of turn stops the capture (the game goes on).

Turning it off: do not set LONGSHOT_TRACY; in a Tracy build, do not connect a viewer.

Compatibility: Nothing changes for a player: no save, option, cache or MKWVK_API_VERSION change. vk_shader.cpp is untouched, so the shader caches' stamp is the same.

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched).
  • Tested on my own PC where it runs (in the game, for a change the game runs), as Testing's Tested says; what
    can't be run by hand is in Testing's Not testable by hand, with why.
  • Measurements has a verdict, or one line saying why there is nothing to measure. (first numbers only: a controlled on/off comparison is still to do)
  • Nothing gets worse that I know of: any cost (speed, latency, memory, a setup that worked before) is measured and
    in Risks.
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named). (only --changed was run: 36 failures, the same 36 on main on this PC; not yet all named here)
  • No game files, dumps, build output or generated files.
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. (Tracy is BSD 3-clause)

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value.
  • A check under tests/ that reads changed source updated in this PR, not weakened.
  • Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (Windows not built: a Must be tested item)
  • Docs updated.

🤖 Generated with Claude Code

**Type:** feat · **Risk:** low · **Tested on:** Linux, RTX 3090 (NVIDIA 620.70) · **Needs:** Windows, any GPU (a build with the option on) ## TL;DR Finding where a frame's time goes took a sampler, wait records and a per-frame CSV put together by hand, and that misled us several times. This PR adds a developer's build option, `LONGSHOT_TRACY=1`, that builds the game and the renderer with the Tracy profiler: every thread, wait, lock, NVN call and renderer stage on one timeline. A player's build is unchanged: with the option off nothing of Tracy is compiled. It ran in two played sessions (89 s, 29.7 million zones), which showed the main thread of a Market frame spending about 10 of 18.6 ms in one job-loop wait. ## Breakdown - **Who it helps:** developers looking for what limits the frame rate or causes a freeze; no player's build has it. - **What was wrong:** there was no single timeline of threads, waits and renderer stages; the existing tools had to be combined by hand. - **What changes:** a build made with `LONGSHOT_TRACY=1` carries Tracy's client (127.0.0.1 only, nothing announced on the network) and zones in the host and the renderer. - **What does not change:** every build without the option: no Tracy code, the same flags and objects (11 of 12 touched sources compile to byte-identical objects; the twelfth differs only in `__LINE__` constants). - **How it was checked:** two play sessions with a capture each, headless smoke captures, the game-free checks (none fails that passes on `main`), an object-by-object comparison with the option off. - **What is still open:** the zones in the lifted game code are not working yet (off by default, see Testing); Windows was never compiled with the option; AMD and Intel not run; the viewer GUI not used (only `tracy-capture` and `tracy-csvexport`). - **Risk:** low: the option is off by default and every zone site is inside `#ifdef TRACY_ENABLE`. ## Why The frame rate in Castle Town's market is limited on the CPU side and there are half-second freezes in play. The tools we had (the profiling mode's sampler, `HOS_CHAIN`'s wait and wake records, the frame trace) each show one part, and putting them together by hand gave wrong answers more than once. Tracy shows all of it on one timeline, live or from a file. No issue in the tracker asks for this (searched the open issues for "tracy" and "profil"). ## What changed A build option, a vendored client, one wrapper header and zones at the places that matter; nothing else in the build moves. - third_party: `third_party/tracy` is Tracy 0.15.0's `public/` folder and LICENSE, unmodified, with its `PROVENANCE.md` (tag v0.15.0, commit f2a4f25, archive and tree hashes). 0.15.0 is the version of the AUR's `tracy` viewer: the protocol is locked to the version. - build (`nx2/build.py`): `LONGSHOT_TRACY=1` compiles `public/TracyClient.cpp` into the game's executable alone, which exports Tracy's C API (`___tracy_*`); `longshot_vk.so` calls that one client, so the process has exactly one. Defines: `TRACY_ONLY_LOCALHOST`, `TRACY_NO_BROADCAST`, `TRACY_ON_DEMAND`, `TRACY_NO_CRASH_HANDLER`, `TRACY_NO_CODE_TRANSFER`, `TRACY_MANUAL_LIFETIME` (the game's `main` starts the client, so the crash window's helper process has none), `TRACY_FIBERS`. The lifted game code is not compiled again. On Windows the executable's import library is what the renderer's DLL links: written, never built. - `host/hos_tracy.h`: the only header a call site includes (C and C++): scoped zones, waits in their own colour, zone text, frame marks, plots, thread names, fibers, and "lock wait" zones for every SRW lock and critical section of a file that has to wait. Every use in the sources is inside `#ifdef TRACY_ENABLE`, because many checks compile one function cut from a source file. - host: frame marks at `nvnQueuePresentTexture`; guest waits and signals in `host/nn_os_sync.c` (events, semaphores, queues, WaitAny, condition variables, mutexes, with the object's guest address and the guest caller); sleeps, yields, virtual-core waits, kernel waits, joins and fiber switches in `host/hos_thread.c`; the NVN calls that work or wait on a game thread in `host/nvn_native.c`; thread names where the host already names threads. - renderer: each render-thread job, the replay's parts and submits, per-draw zones (`draw`, `build_descriptors`, `bind_descriptors`, `program_for`; `RX_VK_TRACY_DRAWS=0` leaves them out), memory sync and captures, texture create and upload, pipeline builds, the workers, the recorder's idle time, the present; plots of the frame time and, with the frame trace on, its main columns. - the game's own code (`nx2/tracy_funcs.py`, `nx2/tracy_funcs.txt`, `host/hos_tracy_game.c`; Linux): listed lifted functions become zones at the link, by rewriting the symbol table of a copy of the chunk's object (no translation, no compile), and the indirect calls of the two job loops become zones by compiling one chunk again (about 20 s). **Recorded only with `HOS_TRACY_GAME=1` and not working yet**: see Testing. - docs: `docs/development/tracy.md` (build, capture, what each zone is, the privacy rule), linked from `docs/development.md`. - tests: `tests/test_tracy_funcs.py` (the list, the object patch on two small C files, the calls header, and that no zone macro sits outside `#ifdef TRACY_ENABLE`); `tests/test_shader_stamp_cache.py` gets the new build globals. A capture holds the game's function names and timings: it is made from the game and never leaves the PC. The doc says so, and the client cannot be reached from another machine. ## Measurements **Verdict:** the option off costs nothing (same objects). The option on, while a capture is taken, costs frame rate; these are first numbers, not a controlled A/B, which is still to do. Hardware: Linux, RTX 3090, NVIDIA 620.70, Ryzen 9 7900X. Scene: played sessions at 2560x1440 with DLSS Quality; headless smoke runs at 2048x1152 in Kokiri Forest. Method: the played sessions' frame counts and file sizes from `tracy-capture`; the headless runs' `vk: ... fps` log lines and the captures' frame counts. | | Without Tracy | Tracy build, capturing | |---|---|---| | played session 2 (alone on the PC, 6 cores), `RX_VK_TRACY_DRAWS=0` | about 70 fps | 53.8 fps; 89 s, 5,039 frames, 29.7 million zones, 299 MB file | | played session 1 (another game and 9,200 pipeline builds beside it), `RX_VK_TRACY_DRAWS=0` | | 90 s, 2,741 frames, 16.8 million zones, 198 MB file | | headless smoke, per-draw zones on, Tracy's sampler on | 65 fps before the capture (same build, not capturing) | 15 to 19 fps; 20 s, 4.86 million zones (243,000 a second), 558,627 samples, 45 MB file | Option off, object by object (the base build's own compile commands, `main` @ 310e7c9d against this branch): `hos_thread.c`, `nn_os_sync.c`, `nvn_native.c`, `hos_svc.c`, `hos_mem.c`, `posix/win32_posix.c`, `vk_replay.cpp`, `vk_memory.cpp`, `vk_texture.cpp`, `vk_jobs.cpp`, `vk_framegen.cpp`: the same object, byte for byte. `vk_draw.cpp`: the same size and code; four `__LINE__` constants of its `SKIP_HERE` macro differ, because lines moved. Build time with the option on, as a pack over a base: 27 s to 1 min 21 s (the host's and the renderer's own files, Tracy's client, one lifted chunk for the job loops' calls, the links). ### Flags and settings Three: a build option and two run-time switches that exist only in a build made with it. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `LONGSHOT_TRACY=1` | build option (`nx2/build.py`) | did not exist | off | builds the game and renderer with Tracy's client and zones | Linux run; Windows untested | off: a developer's build only | | `RX_VK_TRACY_DRAWS` | switch | did not exist | on (in a Tracy build) | `=0` leaves the four per-draw zones out of a capture | about a quarter of the zones | on; `=0` for long captures | | `HOS_TRACY_GAME` | switch | did not exist | off | `=1` records the lifted game code's zones (`funcs`, `calls`: one kind) | not working yet | off until fixed | | `LONGSHOT_TRACY_FUNCS=<file>` | build option | did not exist | unset | adds a list of lifted functions to make zones of | untested | unset | ## Testing **Tested:** Linux, RTX 3090, NVIDIA 620.70, Ryzen 9 7900X. Two played sessions on the first version of this branch with `tracy-capture` on 127.0.0.1:8086 (numbers above): the capture connected at once, `tracy-csvexport` read both files, no error line in either log. Headless smoke runs of the current code with the game's zones off: a 20 s capture with 61 zone names from the host and the renderer, every game and renderer thread by its name (the job workers, the actor executors, the render, recorder and presenter threads), a fiber's row, and Tracy's sampler's samples as an ordinary user (`perf_event_paranoid` 2). Game-free checks: `tests/run_all.py --changed` 382 pass, 36 fail, and the same 36 fail on a clean checkout of `main` @ 310e7c9d on this PC (I ran them there: `test_switch_table.py` and 35 others); `tests/test_tracy_funcs.py` and `scripts/check_third_party.py` pass. **Not tested:** the last small change (the game's zones off by default, the order check) was built in the step before it, not after; a capture with the viewer GUI (not installed here); a capture longer than 90 s; whether the sampler's symbols of the lifted functions resolve (the 20 s smoke capture ended before any symbol was resolved); AMD and Intel GPUs. **Not working:** the game-code zones (`HOS_TRACY_GAME=1`). With the listed functions and the job loops' calls both on, Tracy stops the capture a few milliseconds in ("Invalid order of zone begin and end events"): a 0.0 s capture. With the functions alone a 20 s capture is fine; with the calls alone it records and `tracy-capture` crashes while saving. Fibers were ruled out (no fiber switch happens inside such a zone). A check that names the zone ending out of turn is in; the fix follows on this branch. **Must be tested:** - Windows, any GPU: build with `LONGSHOT_TRACY=1` (llvm-mingw), expecting the game and `longshot_vk.dll` to link (the DLL against the executable's import library `longshot_tracy.lib`) and the game to start; then `tracy-capture -o run.tracy`, expecting zones from both modules (Test Farm: @Beanstalk windows, a build with LONGSHOT_TRACY=1 and a start of the game). - Windows and Linux, any GPU: an ordinary build (the option off), expecting it to build and play as `main` does (Test Farm: @Beanstalk the usual comparison against main). ## Risks **What could break:** nothing in a build without the option, as far as the object comparison shows. In a Tracy build: a capture slows the game; a zone that ends out of turn stops the capture (the game goes on). **Turning it off:** do not set `LONGSHOT_TRACY`; in a Tracy build, do not connect a viewer. **Compatibility:** Nothing changes for a player: no save, option, cache or `MKWVK_API_VERSION` change. `vk_shader.cpp` is untouched, so the shader caches' stamp is the same. ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). - [x] Tested on my own PC where it runs (in the game, for a change the game runs), as Testing's Tested says; what can't be run by hand is in Testing's Not testable by hand, with why. - [ ] Measurements has a verdict, or one line saying why there is nothing to measure. (first numbers only: a controlled on/off comparison is still to do) - [x] Nothing gets worse that I know of: any cost (speed, latency, memory, a setup that worked before) is measured and in Risks. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [ ] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). (only `--changed` was run: 36 failures, the same 36 on `main` on this PC; not yet all named here) - [x] No game files, dumps, build output or generated files. - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). - [x] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. (Tracy is BSD 3-clause) ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [x] Switches documented (docs/development.md; the README for a menu row) and shipped at their recommended value. - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. - [ ] Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (Windows not built: a Must be tested item) - [x] Docs updated. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Fable 5.2 <[email protected]>
The host's waits, locks and NVN calls, the renderer's stages and (opt-in at run time, HOS_TRACY_GAME=1) listed lifted
game functions and the job loops' indirect calls are Tracy zones. Every zone site is inside #ifdef TRACY_ENABLE: a
build without the option compiles nothing of Tracy.

Co-Authored-By: Claude Fable 5.2 <[email protected]>
docs: the Tracy profiler build (docs/development/tracy.md)
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
Website / Website on Cloudflare (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 8s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 13s
CI / Workflow lint (actionlint) (pull_request) Successful in 14s
Third-party parts / As their notes say (pull_request) Successful in 15s
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Failing after 7s
ce4cac1e54
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Author
Owner

Tested in game: RTX 3090, NVIDIA 620.70, Ryzen 9 7900X, Linux: two played sessions (Castle Town's market among the places) on the first version of this branch with tracy-capture on 127.0.0.1:8086, 89 s and 90 s, 29.7 and 16.8 million zones, no error line in either log; then headless smoke runs of the current code in Kokiri Forest with a 20 s capture: 61 zone names from the host and the renderer, the threads by name, the sampler's samples. The game-code zones (HOS_TRACY_GAME=1, off by default) do not work yet: Tracy stops the capture with 'Invalid order of zone begin and end events'.

Tested in game: RTX 3090, NVIDIA 620.70, Ryzen 9 7900X, Linux: two played sessions (Castle Town's market among the places) on the first version of this branch with tracy-capture on 127.0.0.1:8086, 89 s and 90 s, 29.7 and 16.8 million zones, no error line in either log; then headless smoke runs of the current code in Kokiri Forest with a 20 s capture: 61 zone names from the host and the renderer, the threads by name, the sampler's samples. The game-code zones (HOS_TRACY_GAME=1, off by default) do not work yet: Tracy stops the capture with 'Invalid order of zone begin and end events'.
HumanBean changed title from WIP: feat(dev): LONGSHOT_TRACY=1 builds the game and the renderer with the Tracy profiler's zones, localhost only to feat(dev): LONGSHOT_TRACY=1 builds the game and the renderer with the Tracy profiler's zones, localhost only 2026-11-18 03:06:50 +00:00
HumanBean deleted branch feat/tracy 2026-11-18 03:07:00 +00:00
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!1543
No description provided.