fix(vk): make the GPU's writes visible to the host's reads at each submission's end #1031

Open
jcabarca wants to merge 2 commits from jcabarca/Longshot:fix/vk-host-read-barrier into main
Contributor

Type: fix · Risk: low · Tested on: Windows, AMD Radeon RX 9070 XT · Needs: none

Why

The game reads what the GPU wrote into its memory (copies to buffers, queries, readbacks) once the timeline semaphore reaches the submission, but a host wait only makes device writes visible to the device: no command buffer had a memory dependency into HOST_READ, so on a GPU whose caches are not flushed by chance the game could read stale bytes (synchronization.adoc, Fences and Semaphore Signaling: a fence's or a semaphore signal's access scope covers device access only).

How to reproduce

Seen on: not seen in the game: found by reading submit_recording() and the parallel segment jobs in gpu/vk/vk_replay.cpp; on AMD and NVIDIA desktop drivers the end-of-submission cache flush usually hides it
Settings and switches: defaults
Steps: game-free: python -I -B tests/test_host_read_barrier.py --source <main checkout> (the test from this PR); it reads vk_replay.cpp
Expected: every replay command buffer ends with a barrier from ALL_COMMANDS/MEMORY_WRITE to HOST/HOST_READ
Actual: on main there is no such barrier; the test fails with "no memory dependency into the host's reads at a recording's end"

What changed

Each replay command buffer now ends with one global memory barrier into the host's reads, so what the GPU wrote is visible to the game once its wait on the timeline returns.

  • vk: new host_read_barrier() in gpu/vk/vk_replay.cpp: one VkMemoryBarrier2 from VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT / VK_ACCESS_2_MEMORY_WRITE_BIT to VK_PIPELINE_STAGE_2_HOST_BIT / VK_ACCESS_2_HOST_READ_BIT, recorded with vkCmdPipelineBarrier2.
  • vk: submit_recording() calls it on r.cmd before vkEndCommandBuffer.
  • vk: the parallel segment job in replay_handle() calls it on its command buffer before vkEndCommandBuffer.
  • tests: tests/test_host_read_barrier.py (new).

The bug, step by step:

  1. The GPU writes into memory the game reads back: buffer copies, query results, readbacks.
  2. submit_recording() signals the timeline semaphore when the command buffer completes; the game's side waits on that value from the host and then reads the memory.
  3. A semaphore signal's first access scope "includes all memory access performed by the device", and its second is empty (synchronization.adoc, Semaphore Signaling). The host wait adds no host access either: the spec's note on fences says "Signaling a fence and waiting on the host does not guarantee that the results of memory accesses will be visible to the host, as the access scope of a memory dependency defined by a fence only includes device access. A memory barrier or other memory dependency must be used to guarantee this."
  4. Nothing in the command buffers made the writes visible to HOST_READ, so the read in step 2 was not ordered against them by any Vulkan rule.
  5. The new barrier at the end of each command buffer makes every earlier write available and visible to the host's reads; the semaphore signal then orders it before the host's wait returns.

The Vulkan rules for the new call, from validusage.json:

  • VUID-VkMemoryBarrier2-dstAccessMask-03916: "If dstAccessMask includes VK_ACCESS_2_HOST_READ_BIT, dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT": met, dstStageMask is HOST.
  • VUID-vkCmdPipelineBarrier2-synchronization2-03848: "The synchronization2 feature must be enabled": met, create_device already requires synchronization2 (vk_main.cpp, as on main) and the replay already records vkCmdPipelineBarrier2.
  • VUID-vkCmdPipelineBarrier2-commandBuffer-recording: "commandBuffer must be in the recording state": met, it is called before vkEndCommandBuffer.
  • VUID-vkCmdPipelineBarrier2-None-07889 and the other render-pass rules: not applicable, both calls come after the last pass is ended (end_pass) or a full barrier, outside any render pass instance.

Before (submit_recording() in vk_replay.cpp):

    gprof_submitted(r.slot, uploads);
    gpu_time_end(r);
    vkEndCommandBuffer(r.upload);
    vkEndCommandBuffer(r.cmd);

After:

/// The game reads what the GPU wrote into its memory once the timeline reaches the submission; waiting on the host makes
/// it visible to the device only (a fence's or a semaphore's access scope is device access), so each recording ends with
/// a memory dependency into the host's reads
void host_read_barrier(VkCommandBuffer cmd) {
    VkMemoryBarrier2 b{VK_STRUCTURE_TYPE_MEMORY_BARRIER_2};
    b.srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, b.srcAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT;
    b.dstStageMask = VK_PIPELINE_STAGE_2_HOST_BIT, b.dstAccessMask = VK_ACCESS_2_HOST_READ_BIT;
    VkDependencyInfo d{VK_STRUCTURE_TYPE_DEPENDENCY_INFO};
    d.memoryBarrierCount = 1, d.pMemoryBarriers = &b;
    vkCmdPipelineBarrier2(cmd, &d);
}
...
    gprof_submitted(r.slot, uploads);
    gpu_time_end(r);
    host_read_barrier(r.cmd);
    vkEndCommandBuffer(r.upload);
    vkEndCommandBuffer(r.cmd);

The parallel segment job, after:

                texture_segment_worker(-1);
                host_read_barrier(c);
                vkEndCommandBuffer(j->r->upload);
                vkEndCommandBuffer(j->r->cmd);

Measurements

Verdict: it fixes the bug: tests/test_host_read_barrier.py fails on main and passes with this PR, in both interleaved runs. No speed change is measured: one global barrier per command buffer, at its end.

Hardware: AMD Radeon RX 9070 XT, Windows; the test itself is game-free (it reads source, it does not use the GPU); Python 3.12
Scene: none, game-free
Method: tests/test_host_read_barrier.py from this PR with --source set to each side's checkout, 2 runs each, interleaved (main, PR, main, PR); the result is pass/fail, so the median is the result both runs gave
How to reproduce: python -I -B tests/test_host_read_barrier.py --source <checkout> for each side

Before: main @ cefce0d1 After: this PR @ 7e71e972
tests/test_host_read_barrier.py, run 1 fails passes
tests/test_host_read_barrier.py, run 2 fails passes
Median fails passes
run 1, main @ cefce0d1:
no memory dependency into the host's reads at a recording's end: a host wait leaves GPU writes unseen
exit 1
run 1, this PR @ 7e71e972:
replay command buffers end with a dependency into host reads: ok
exit 0
run 2, main @ cefce0d1:
no memory dependency into the host's reads at a recording's end: a host wait leaves GPU writes unseen
exit 1
run 2, this PR @ 7e71e972:
replay command buffers end with a dependency into host reads: ok
exit 0

What the test checks:

  • host_read_barrier() exists in vk_replay.cpp and records ALL_COMMANDS / MEMORY_WRITE to HOST / HOST_READ with vkCmdPipelineBarrier2.
  • submit_recording() calls host_read_barrier(r.cmd) before vkEndCommandBuffer(r.cmd).
  • The parallel segment job calls host_read_barrier(c) between record_segment(c, j->g) and vkEndCommandBuffer(j->r->cmd).

Flags and settings

None.

Testing

Tested: on this branch, Windows, Python 3.12: test_host_read_barrier passes (fails on main), and test_capture_readback_visibility, the other check that reads the readback path, passes in all 16 of its cases.

Built and played: this commit builds on Windows (llvm-mingw back end) and on Linux (longshot_vk.so, without and with AMD FSR 4). Played on Windows, AMD Radeon RX 9070 XT: the game runs normally.

Not tested: a game scene where stale reads showed: none is known (AMD and NVIDIA desktop drivers flush at the end of a submission). Linux was built, not run.

Must be tested: None.

Risks

What could break: one more barrier per command buffer; it waits for all earlier work at the very end, where the semaphore signal already does, so no frame-time change is expected.

Turning it off: revert the commit.

Compatibility: Nothing changes.

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). (no issue fits)
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • 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). (the checks that read the changed code, on this PR, Windows: test_host_read_barrier, test_capture_readback_visibility pass)
  • 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.

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • A game-free test added for the fix, failing on main and passing here. (tests/test_host_read_barrier.py)
  • A check under tests/ that reads changed source updated in this PR, not weakened. (tests/test_host_read_barrier.py added; no check removed)
  • Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (built on Windows with llvm-mingw and on Linux, longshot_vk.so without and with AMD FSR 4; no OS-specific code or paths)
**Type:** fix · **Risk:** low · **Tested on:** Windows, AMD Radeon RX 9070 XT · **Needs:** none ## Why The game reads what the GPU wrote into its memory (copies to buffers, queries, readbacks) once the timeline semaphore reaches the submission, but a host wait only makes device writes visible to the device: no command buffer had a memory dependency into `HOST_READ`, so on a GPU whose caches are not flushed by chance the game could read stale bytes (synchronization.adoc, Fences and Semaphore Signaling: a fence's or a semaphore signal's access scope covers device access only). ## How to reproduce **Seen on:** not seen in the game: found by reading `submit_recording()` and the parallel segment jobs in `gpu/vk/vk_replay.cpp`; on AMD and NVIDIA desktop drivers the end-of-submission cache flush usually hides it **Settings and switches:** defaults **Steps:** game-free: `python -I -B tests/test_host_read_barrier.py --source <main checkout>` (the test from this PR); it reads `vk_replay.cpp` **Expected:** every replay command buffer ends with a barrier from `ALL_COMMANDS`/`MEMORY_WRITE` to `HOST`/`HOST_READ` **Actual:** on main there is no such barrier; the test fails with "no memory dependency into the host's reads at a recording's end" ## What changed Each replay command buffer now ends with one global memory barrier into the host's reads, so what the GPU wrote is visible to the game once its wait on the timeline returns. - vk: new `host_read_barrier()` in `gpu/vk/vk_replay.cpp`: one `VkMemoryBarrier2` from `VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT` / `VK_ACCESS_2_MEMORY_WRITE_BIT` to `VK_PIPELINE_STAGE_2_HOST_BIT` / `VK_ACCESS_2_HOST_READ_BIT`, recorded with `vkCmdPipelineBarrier2`. - vk: `submit_recording()` calls it on `r.cmd` before `vkEndCommandBuffer`. - vk: the parallel segment job in `replay_handle()` calls it on its command buffer before `vkEndCommandBuffer`. - tests: `tests/test_host_read_barrier.py` (new). The bug, step by step: 1. The GPU writes into memory the game reads back: buffer copies, query results, readbacks. 2. `submit_recording()` signals the timeline semaphore when the command buffer completes; the game's side waits on that value from the host and then reads the memory. 3. A semaphore signal's first access scope "includes all memory access performed by the device", and its second is empty (synchronization.adoc, Semaphore Signaling). The host wait adds no host access either: the spec's note on fences says "Signaling a fence and waiting on the host does not guarantee that the results of memory accesses will be visible to the host, as the access scope of a memory dependency defined by a fence only includes device access. A memory barrier or other memory dependency must be used to guarantee this." 4. Nothing in the command buffers made the writes visible to `HOST_READ`, so the read in step 2 was not ordered against them by any Vulkan rule. 5. The new barrier at the end of each command buffer makes every earlier write available and visible to the host's reads; the semaphore signal then orders it before the host's wait returns. The Vulkan rules for the new call, from `validusage.json`: - VUID-VkMemoryBarrier2-dstAccessMask-03916: "If dstAccessMask includes VK_ACCESS_2_HOST_READ_BIT, dstStageMask must include VK_PIPELINE_STAGE_2_HOST_BIT": met, `dstStageMask` is `HOST`. - VUID-vkCmdPipelineBarrier2-synchronization2-03848: "The synchronization2 feature must be enabled": met, `create_device` already requires `synchronization2` (`vk_main.cpp`, as on main) and the replay already records `vkCmdPipelineBarrier2`. - VUID-vkCmdPipelineBarrier2-commandBuffer-recording: "commandBuffer must be in the recording state": met, it is called before `vkEndCommandBuffer`. - VUID-vkCmdPipelineBarrier2-None-07889 and the other render-pass rules: not applicable, both calls come after the last pass is ended (`end_pass`) or a full barrier, outside any render pass instance. Before (`submit_recording()` in `vk_replay.cpp`): ```cpp gprof_submitted(r.slot, uploads); gpu_time_end(r); vkEndCommandBuffer(r.upload); vkEndCommandBuffer(r.cmd); ``` After: ```cpp /// The game reads what the GPU wrote into its memory once the timeline reaches the submission; waiting on the host makes /// it visible to the device only (a fence's or a semaphore's access scope is device access), so each recording ends with /// a memory dependency into the host's reads void host_read_barrier(VkCommandBuffer cmd) { VkMemoryBarrier2 b{VK_STRUCTURE_TYPE_MEMORY_BARRIER_2}; b.srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, b.srcAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT; b.dstStageMask = VK_PIPELINE_STAGE_2_HOST_BIT, b.dstAccessMask = VK_ACCESS_2_HOST_READ_BIT; VkDependencyInfo d{VK_STRUCTURE_TYPE_DEPENDENCY_INFO}; d.memoryBarrierCount = 1, d.pMemoryBarriers = &b; vkCmdPipelineBarrier2(cmd, &d); } ... gprof_submitted(r.slot, uploads); gpu_time_end(r); host_read_barrier(r.cmd); vkEndCommandBuffer(r.upload); vkEndCommandBuffer(r.cmd); ``` The parallel segment job, after: ```cpp texture_segment_worker(-1); host_read_barrier(c); vkEndCommandBuffer(j->r->upload); vkEndCommandBuffer(j->r->cmd); ``` ## Measurements **Verdict:** it fixes the bug: `tests/test_host_read_barrier.py` fails on main and passes with this PR, in both interleaved runs. No speed change is measured: one global barrier per command buffer, at its end. Hardware: AMD Radeon RX 9070 XT, Windows; the test itself is game-free (it reads source, it does not use the GPU); Python 3.12 Scene: none, game-free Method: `tests/test_host_read_barrier.py` from this PR with `--source` set to each side's checkout, 2 runs each, interleaved (main, PR, main, PR); the result is pass/fail, so the median is the result both runs gave How to reproduce: `python -I -B tests/test_host_read_barrier.py --source <checkout>` for each side | | Before: main @ cefce0d1 | After: this PR @ 7e71e972 | |---|---|---| | `tests/test_host_read_barrier.py`, run 1 | fails | passes | | `tests/test_host_read_barrier.py`, run 2 | fails | passes | | Median | fails | passes | ``` run 1, main @ cefce0d1: no memory dependency into the host's reads at a recording's end: a host wait leaves GPU writes unseen exit 1 run 1, this PR @ 7e71e972: replay command buffers end with a dependency into host reads: ok exit 0 run 2, main @ cefce0d1: no memory dependency into the host's reads at a recording's end: a host wait leaves GPU writes unseen exit 1 run 2, this PR @ 7e71e972: replay command buffers end with a dependency into host reads: ok exit 0 ``` What the test checks: - `host_read_barrier()` exists in `vk_replay.cpp` and records `ALL_COMMANDS` / `MEMORY_WRITE` to `HOST` / `HOST_READ` with `vkCmdPipelineBarrier2`. - `submit_recording()` calls `host_read_barrier(r.cmd)` before `vkEndCommandBuffer(r.cmd)`. - The parallel segment job calls `host_read_barrier(c)` between `record_segment(c, j->g)` and `vkEndCommandBuffer(j->r->cmd)`. ### Flags and settings None. ## Testing **Tested:** on this branch, Windows, Python 3.12: `test_host_read_barrier` passes (fails on main), and `test_capture_readback_visibility`, the other check that reads the readback path, passes in all 16 of its cases. **Built and played:** this commit builds on Windows (llvm-mingw back end) and on Linux (`longshot_vk.so`, without and with AMD FSR 4). Played on Windows, AMD Radeon RX 9070 XT: the game runs normally. **Not tested:** a game scene where stale reads showed: none is known (AMD and NVIDIA desktop drivers flush at the end of a submission). Linux was built, not run. **Must be tested:** None. ## Risks **What could break:** one more barrier per command buffer; it waits for all earlier work at the very end, where the semaphore signal already does, so no frame-time change is expected. **Turning it off:** revert the commit. **Compatibility:** Nothing changes. ## 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). (no issue fits) - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [x] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). (the checks that read the changed code, on this PR, Windows: `test_host_read_barrier`, `test_capture_readback_visibility` pass) - [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. ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [x] A game-free test added for the fix, failing on `main` and passing here. (`tests/test_host_read_barrier.py`) - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. (`tests/test_host_read_barrier.py` added; no check removed) - [x] Host code builds on both Windows (llvm-mingw) and Linux, with UTF-8 paths. (built on Windows with llvm-mingw and on Linux, `longshot_vk.so` without and with AMD FSR 4; no OS-specific code or paths)
fix(vk): make the GPU's writes visible to the host's reads at each submission's end
Some checks failed
Website / Website on Cloudflare (pull_request_target) Has been skipped
PR description / Description follows the template (pull_request_target) Successful in 3s
CI / Conventional Commit title (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been cancelled
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been cancelled
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been cancelled
CI / Workflow lint (actionlint) (pull_request) Has been cancelled
Guide screenshots / Guide images and local UI source review (pull_request) Has been cancelled
Third-party parts / As their notes say (pull_request) Has been cancelled
Third-party parts / The same as upstream (pull_request) Has been cancelled
7e71e972d7
A host wait on the timeline covers device access only; without a dependency into HOST_READ the game could read stale bytes.

Assisted-by: GitHub Copilot
Author
Contributor

Tested in game: Windows 11 IoT Enterprise LTSC 24H2 (build 26100.9711), AMD Radeon RX 9070 XT, AMD Software: Adrenalin Edition 26.10.1: played with this change; the game runs normally, no stale readbacks, rendering errors or crashes seen.

Tested in game: Windows 11 IoT Enterprise LTSC 24H2 (build 26100.9711), AMD Radeon RX 9070 XT, AMD Software: Adrenalin Edition 26.10.1: played with this change; the game runs normally, no stale readbacks, rendering errors or crashes seen.
jcabarca changed title from WIP: fix(vk): make the GPU's writes visible to the host's reads at each submission's end to fix(vk): make the GPU's writes visible to the host's reads at each submission's end 2026-11-16 04:10:43 +00:00
Member

Code-only review of 7e71e972d7; informational findings, with final approval left to another reviewer.

No introduced correctness defect found in the barrier placement or scopes. The serial path records the dependency after its last GPU commands; the parallel path does so after record_segment ends rendering. Upload/init command buffers precede the replay command buffer in submission order, so they do not each need their own duplicate barrier. The recorder wrapper copies the barrier structures before the helper's stack frame ends. The device-write → host-read dependency is consistent with the Vulkan synchronization rules.

Testing limitation: tests/test_host_read_barrier.py checks source strings, not the dependency actually passed to Vulkan. For example, changing d.memoryBarrierCount = 1 to 0 would leave every checked string present while removing the memory dependency. A stubbed call-capture test of the helper should check the count, masks and pointed-to barrier, and reject that mutation. Treat the existing before/after pass as a structural regression check, not a reproduced stale-read failure. The author does separately report Windows RX 9070 XT gameplay and Windows/Linux builds; Linux gameplay and frame-time cost are not demonstrated.

Merge coordination: the early-read work and capture visibility work alter related completion/readback paths; these are complementary, not duplicates of this dependency. Preserve the barrier after the final GPU write if recording-end ownership moves.

Read the full diff, submission/parallel recording paths, recorder packing and host-memory choices, prior feedback and related diffs. No tests, builds or game runs performed during this review.

Code-only review of 7e71e972d720957bf8683669af2ff2a1a211a595; informational findings, with final approval left to another reviewer. No introduced correctness defect found in the barrier placement or scopes. The serial path records the dependency after its last GPU commands; the parallel path does so after `record_segment` ends rendering. Upload/init command buffers precede the replay command buffer in submission order, so they do not each need their own duplicate barrier. The recorder wrapper copies the barrier structures before the helper's stack frame ends. The device-write → host-read dependency is consistent with the [Vulkan synchronization rules](https://docs.vulkan.org/spec/latest/chapters/synchronization.html#synchronization-fences-waiting). Testing limitation: `tests/test_host_read_barrier.py` checks source strings, not the dependency actually passed to Vulkan. For example, changing `d.memoryBarrierCount = 1` to `0` would leave every checked string present while removing the memory dependency. A stubbed call-capture test of the helper should check the count, masks and pointed-to barrier, and reject that mutation. Treat the existing before/after pass as a structural regression check, not a reproduced stale-read failure. The author does separately report Windows RX 9070 XT gameplay and Windows/Linux builds; Linux gameplay and frame-time cost are not demonstrated. Merge coordination: [the early-read work](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/977) and [capture visibility work](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/759) alter related completion/readback paths; these are complementary, not duplicates of this dependency. Preserve the barrier after the final GPU write if recording-end ownership moves. Read the full diff, submission/parallel recording paths, recorder packing and host-memory choices, prior feedback and related diffs. No tests, builds or game runs performed during this review.
Merge branch 'main' into fix/vk-host-read-barrier
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 7s
f721f2c441
Some checks are pending
CI / Conventional Commit title (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Blocked by required conditions
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Blocked by required conditions
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Blocked by required conditions
CI / Workflow lint (actionlint) (pull_request) Blocked by required conditions
Guide screenshots / Guide images and local UI source review (pull_request) Blocked by required conditions
Third-party parts / As their notes say (pull_request) Blocked by required conditions
Third-party parts / The same as upstream (pull_request) Blocked by required conditions
Website / Website on Cloudflare (pull_request) Blocked by required conditions
PR description / Description follows the template (pull_request_target) Successful in 7s
This pull request doesn't have enough approvals yet. 0 of 1 approvals granted.
Some workflows are waiting to be reviewed.
This branch is out-of-date with the base branch
You are not authorized to merge this pull request.
View command line instructions

Checkout

From your project repository, check out a new branch and test the changes.
git fetch -u 'fix/vk-host-read-barrier:jcabarca-fix/vk-host-read-barrier'
git switch 'jcabarca-fix/vk-host-read-barrier'
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
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!1031
No description provided.