fix(scripts): the profile readers count a Windows wait as a wait and name the renderer's functions #1347

Open
dyst wants to merge 2 commits from dyst/Longshot:fix/profile-report-windows into main
Member

Type: fix · Risk: low · Tested on: Windows 11, RTX 3080 (a real HOS_PROFILE=1 profile; the game-free checks) · Needs: none

Why

On Windows, scripts/profile_report.py (#1279's report) points at the wrong code. Its "hottest" on each thread, and the code it says runs more in stutters, are mostly threads sleeping. The renderer's functions also show as mangled names. So a Windows profile sends you after idle loops instead of what the frame spends its time on. Fixes #1337.

How to reproduce

Seen on: Windows 11, RTX 3080, NVIDIA 621.14, main @ 8e9cfc3a
Settings and switches: HOS_PROFILE=1, then profile_report.py <profile folder> --maps <game folder>
Steps: read the report's At a glance
Expected: each thread's hottest functions are work, under readable names
Actual: sead::MainThread's hottest are _ZN5mkwvk12_GLOBAL__N_14waitEyy (6.7 %) and sleep_away (5.7 %), and the Presentation Thread's is a condition variable wait (7.8 %). "Running far more in stutters" names those waits.

What changed

prof.waiting now recognises Longshot's waits whatever their parameter list, and knows the ones it was missing. prof.load_symbols demangles a Windows map's names. Every reader built on prof.py gets both: profile_report.py, crit.py, hotlist.py, chain.py, vkprof.py.

  • scripts: prof.base_name() drops a name's closing parameter list, and a trailing const. It keeps (anonymous namespace) and operator(). waiting() matches WAIT_FRAMES against it. Before, endswith failed on any name nm -C or llvm-cxxfilt writes with parameters, on Linux too: even the listed condition_variable::wait never matched there.

  • scripts: WAIT_FRAMES gains the waits a Windows run showed counted as running. Of its 1.44 M samples with the leaf in a system module, these were counted as running:

    • sleep_away: 132,579 samples;
    • __libcpp_condvar_wait and __libcpp_condvar_timedwait: 137,869 together;
    • gpu_hang_watch_start's sleep: 14,415;
    • the replay's ::wait;
    • __libcpp_mutex_lock.
  • Work inside the system under Longshot's frames stays running: operator new, steady_clock::now, event_signal, discard_pages. That's why the rule is a list, not "a leaf in ntdll is a wait", as #1337 first suggested.

  • scripts: prof.demangler() finds llvm-cxxfilt (the toolchain's under LONGSHOT_MINGW, else on PATH, else c++filt). demangle_all() runs it once over a Windows map's _Z names in load_symbols. Without one, the names stay as the map has them.

  • tests: tests/test_prof_symbols.py checks:

    • the waits of that run, Linux's nm -C form, and work in the system staying running;
    • base_name's three shapes;
    • the demangling, with a stand-in demangler so it runs anywhere, and without one.

    It fails against main's prof.py.

Measurements

Verdict: pass. On a real Windows profile, the report's hottest functions and its stutter attribution go from waits to work, under readable names.

Hardware: Windows 11 Pro 22631, RTX 3080 (NVIDIA 621.14), Ryzen 9 3900X, 64 GB
Scene: a HOS_PROFILE=1 run of main @ 8e9cfc3a from kokiri-start (135 s of play, 1,902,180 samples, 76 stutters)
Method: profile_report.py <that folder> --maps <its game folder>, once with main's scripts/prof.py and once with this branch's, everything else the same (LONGSHOT_MINGW set to the Builder's llvm-mingw). The two reports' At a glance compared.
How to reproduce: any Windows HOS_PROFILE=1 folder, the report run with each prof.py

Before: main @ 544229a2 After: this PR @ 0934572f
sead::MainThread running 49 % 35 %
its hottest _ZN5mkwvk12_GLOBAL__N_14waitEyy 6.7 %, sleep_away 5.7 %, _ZN5mkwvk12guarded_copyEPvPKvy 4.2 % mkwvk::guarded_copy(void*, void const*, unsigned long long) 4.2 %, collect_in 2.3 %, spin_until_set 2.2 %
Presentation Thread running 13 % 5 %
its hottest __libcpp_condvar_timedwait 7.8 % collect_in 2.4 %
running far more in stutters the condition variable wait (42 % of stutter instants), the replay's wait (39 %) OptimizeChangeBanc's f_805aeea0 (12 %, 0 % otherwise), then BaseProcCreateAndDeleteThread
before: - **sead::MainThread:** running 49 % of the time; hottest: `longshot_vk:_ZN5mkwvk12_GLOBAL__N_14waitEyy` 6.7 % (0.59 ms a frame); `longshot:sleep_away` 5.7 % ...
after:  - **sead::MainThread:** running 35 % of the time; hottest: `longshot_vk:mkwvk::guarded_copy(void*, void const*, unsigned long long)` 4.2 % (0.37 ms a frame); `longshot:collect_in` 2.3 % ...

Flags and settings

None (LONGSHOT_MINGW, which the build already reads, is also where the demangler is looked for).

Testing

Tested:

  • Windows 11, the game-free checks that read the changed scripts (run_all.py test_link_skip test_prof_symbols test_profile_stream test_profiling_mode): three pass. test_profiling_mode fails on its first line with the same message on main @ 544229a2: void hos_prof_start(void) is in host/posix/prof.c twice. Its packed_format and report parts, run on their own, fail with the same TypeError on main and here. That's 4 checks, not the whole suite.
  • tests/test_prof_symbols.py fails against main's prof.py and passes here.
  • The real profile above, read by profile_report.py with each prof.py.

Not tested: a Linux profile. The same base_name match applies there, and the check covers nm -C's form, but no Linux profile was read here. The game is untouched.

Must be tested: None

Risks

What could break: a sample counted as a wait that runs, where its innermost Longshot frame's name ends with a listed name and its leaf is outside Longshot (a ::wait that spins inside the driver, say). It only affects the profile readers' numbers; the game is untouched.

Turning it off: revert the commit

Compatibility: Nothing changes

Issues

Fixes #1337

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).
  • 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).
  • 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.
  • A check under tests/ that reads changed source updated in this PR, not weakened.

🤖 Generated with Claude Code

**Type:** fix · **Risk:** low · **Tested on:** Windows 11, RTX 3080 (a real HOS_PROFILE=1 profile; the game-free checks) · **Needs:** none ## Why On Windows, `scripts/profile_report.py` (#1279's report) points at the wrong code. Its "hottest" on each thread, and the code it says runs more in stutters, are mostly threads sleeping. The renderer's functions also show as mangled names. So a Windows profile sends you after idle loops instead of what the frame spends its time on. Fixes #1337. ## How to reproduce **Seen on:** Windows 11, RTX 3080, NVIDIA 621.14, main @ 8e9cfc3a **Settings and switches:** `HOS_PROFILE=1`, then `profile_report.py <profile folder> --maps <game folder>` **Steps:** read the report's *At a glance* **Expected:** each thread's hottest functions are work, under readable names **Actual:** `sead::MainThread`'s hottest are `_ZN5mkwvk12_GLOBAL__N_14waitEyy` (6.7 %) and `sleep_away` (5.7 %), and the Presentation Thread's is a condition variable wait (7.8 %). "Running far more in stutters" names those waits. ## What changed `prof.waiting` now recognises Longshot's waits whatever their parameter list, and knows the ones it was missing. `prof.load_symbols` demangles a Windows map's names. Every reader built on `prof.py` gets both: `profile_report.py`, `crit.py`, `hotlist.py`, `chain.py`, `vkprof.py`. - scripts: `prof.base_name()` drops a name's closing parameter list, and a trailing `const`. It keeps `(anonymous namespace)` and `operator()`. `waiting()` matches `WAIT_FRAMES` against it. Before, `endswith` failed on any name `nm -C` or `llvm-cxxfilt` writes with parameters, on Linux too: even the listed `condition_variable::wait` never matched there. - scripts: `WAIT_FRAMES` gains the waits a Windows run showed counted as running. Of its 1.44 M samples with the leaf in a system module, these were counted as running: - `sleep_away`: 132,579 samples; - `__libcpp_condvar_wait` and `__libcpp_condvar_timedwait`: 137,869 together; - `gpu_hang_watch_start`'s sleep: 14,415; - the replay's `::wait`; - `__libcpp_mutex_lock`. - Work inside the system under Longshot's frames stays running: `operator new`, `steady_clock::now`, `event_signal`, `discard_pages`. That's why the rule is a list, not "a leaf in ntdll is a wait", as #1337 first suggested. - scripts: `prof.demangler()` finds `llvm-cxxfilt` (the toolchain's under `LONGSHOT_MINGW`, else on `PATH`, else `c++filt`). `demangle_all()` runs it once over a Windows map's `_Z` names in `load_symbols`. Without one, the names stay as the map has them. - tests: `tests/test_prof_symbols.py` checks: - the waits of that run, Linux's `nm -C` form, and work in the system staying running; - `base_name`'s three shapes; - the demangling, with a stand-in demangler so it runs anywhere, and without one. It fails against main's `prof.py`. ## Measurements **Verdict:** pass. On a real Windows profile, the report's hottest functions and its stutter attribution go from waits to work, under readable names. Hardware: Windows 11 Pro 22631, RTX 3080 (NVIDIA 621.14), Ryzen 9 3900X, 64 GB Scene: a `HOS_PROFILE=1` run of main @ 8e9cfc3a from `kokiri-start` (135 s of play, 1,902,180 samples, 76 stutters) Method: `profile_report.py <that folder> --maps <its game folder>`, once with main's `scripts/prof.py` and once with this branch's, everything else the same (`LONGSHOT_MINGW` set to the Builder's llvm-mingw). The two reports' *At a glance* compared. How to reproduce: any Windows `HOS_PROFILE=1` folder, the report run with each `prof.py` | | Before: main @ 544229a2 | After: this PR @ 0934572f | |---|---|---| | `sead::MainThread` running | 49 % | 35 % | | its hottest | `_ZN5mkwvk12_GLOBAL__N_14waitEyy` 6.7 %, `sleep_away` 5.7 %, `_ZN5mkwvk12guarded_copyEPvPKvy` 4.2 % | `mkwvk::guarded_copy(void*, void const*, unsigned long long)` 4.2 %, `collect_in` 2.3 %, `spin_until_set` 2.2 % | | Presentation Thread running | 13 % | 5 % | | its hottest | `__libcpp_condvar_timedwait` 7.8 % | `collect_in` 2.4 % | | running far more in stutters | the condition variable wait (42 % of stutter instants), the replay's `wait` (39 %) | OptimizeChangeBanc's `f_805aeea0` (12 %, 0 % otherwise), then BaseProcCreateAndDeleteThread | ``` before: - **sead::MainThread:** running 49 % of the time; hottest: `longshot_vk:_ZN5mkwvk12_GLOBAL__N_14waitEyy` 6.7 % (0.59 ms a frame); `longshot:sleep_away` 5.7 % ... after: - **sead::MainThread:** running 35 % of the time; hottest: `longshot_vk:mkwvk::guarded_copy(void*, void const*, unsigned long long)` 4.2 % (0.37 ms a frame); `longshot:collect_in` 2.3 % ... ``` ### Flags and settings None (`LONGSHOT_MINGW`, which the build already reads, is also where the demangler is looked for). ## Testing **Tested:** - Windows 11, the game-free checks that read the changed scripts (`run_all.py test_link_skip test_prof_symbols test_profile_stream test_profiling_mode`): three pass. `test_profiling_mode` fails on its first line with the same message on main @ 544229a2: `void hos_prof_start(void)` is in `host/posix/prof.c` twice. Its `packed_format` and `report` parts, run on their own, fail with the same `TypeError` on main and here. That's 4 checks, not the whole suite. - `tests/test_prof_symbols.py` fails against main's `prof.py` and passes here. - The real profile above, read by `profile_report.py` with each `prof.py`. **Not tested:** a Linux profile. The same `base_name` match applies there, and the check covers `nm -C`'s form, but no Linux profile was read here. The game is untouched. **Must be tested:** None ## Risks **What could break:** a sample counted as a wait that runs, where its innermost Longshot frame's name ends with a listed name and its leaf is outside Longshot (a `::wait` that spins inside the driver, say). It only affects the profile readers' numbers; the game is untouched. **Turning it off:** revert the commit **Compatibility:** Nothing changes ## Issues Fixes #1337 ## 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] 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). - [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. - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
fix(scripts): the profile readers count a Windows wait as a wait and name the renderer's functions
All checks were successful
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
CI / Conventional Commit title (pull_request) Successful in 7s
CI / Workflow lint (actionlint) (pull_request) Successful in 12s
Website / Website on Cloudflare (pull_request_target) Has been skipped
Guide screenshots / Guide images and local UI source review (pull_request) Successful in 13s
PR description / Description follows the template (pull_request_target) Successful in 8s
Third-party parts / As their notes say (pull_request) Successful in 16s
0934572f1f
On a Windows HOS_PROFILE=1 run (#1279), scripts/profile_report.py's "hottest" on each thread led with waits and
its stutter attribution named idle frames: prof.waiting matched the innermost Longshot frame against WAIT_FRAMES with
endswith, which a parameter list defeats (llvm-cxxfilt's and nm -C's names end in "(...)", so even the listed
condition_variable::wait never matched), and sleep_away, libc++'s condition variable waits and mutex lock, the
replay's ::wait and the hang watch were not listed. The renderer's names also stayed mangled: llvm-mingw's maps hold
Itanium names and prof.demangle reads MSVC's.

- prof.base_name drops a name's closing parameter list (keeping "(anonymous namespace)" and operator()), and
  waiting matches the list against it; the missing waits are listed. Work in the system under Longshot's frames
  (operator new, steady_clock::now, event_signal) is not in the list and stays running.
- load_symbols demangles a Windows map's Itanium names once, with the toolchain's llvm-cxxfilt (LONGSHOT_MINGW) or
  one on PATH; without one they stay as the map has them.
- tests/test_prof_symbols.py: the waits of that run, work in the system, Linux's nm -C names, base_name, and the
  demangling (with a stand-in demangler).

Fixes #1337

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
dyst changed title from WIP: fix(scripts): the profile readers count a Windows wait as a wait and name the renderer's functions to fix(scripts): the profile readers count a Windows wait as a wait and name the renderer's functions 2026-11-17 04:50:04 +00:00
Collaborator

Possibly related, for context:

  • PR #1321 fix(profiling): a Windows profile names its C++ code, counts its waits as waits, and gives a thread one row — Open overlapping Windows profiling wait and demangling fix
Possibly related, for context: - PR #1321 fix(profiling): a Windows profile names its C++ code, counts its waits as waits, and gives a thread one row — Open overlapping Windows profiling wait and demangling fix
fix(scripts): a lambda's frame is named as the function it is written in, so the hang watch's sleep is a wait
All checks were successful
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
CI / Conventional Commit title (pull_request) Successful in 7s
PR description / Description follows the template (pull_request_target) Successful in 8s
CI / Workflow lint (actionlint) (pull_request) Successful in 11s
Guide screenshots / Guide images and local UI source review (pull_request) Successful in 11s
Third-party parts / As their notes say (pull_request) Successful in 13s
3af0c93fa3
On the Windows HOS_PROFILE=1 run the fix was checked against (profile-20261116-211517), the hang watch's thread still
counted as running: 60,340 samples, 19.4% of the running samples, all in vk_replay.cpp. Its frame is the thread's lambda,
"mkwvk::gpu_hang_watch_start()::$_0::operator()() const" as llvm-cxxfilt writes it, and base_name took only the closing
parameter list off, so "...::$_0::operator()" never ended with the listed gpu_hang_watch_start. The test named the frame
"mkwvk::gpu_hang_watch_start()", which the run never has.

- base_name names a lambda's body (clang's ::$_<n>::operator(), GCC's ::{lambda(...)#<n>}::operator()) as the function
  it is written in.
- tests/test_prof_symbols.py: the hang watch as the run names it, both compilers' lambdas, and a lambda that does not
  wait staying running.

On that run, the samples in a system module counted as running go from 91,913 to 31,573; what is left is the work in the
system under Longshot's frames that stays running by design (event_signal, read_at, operator new, steady_clock::now).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Author
Member

Follow-up pushed: 3af0c93f.

After 0934572f, the hang watch's sleep still counted as running. On a later Windows HOS_PROFILE=1 run (base 8e9cfc3a, profile-20261116-211517) it was 60,340 samples, 19.4 % of the running ones, all charged to vk_replay.cpp. The frame the run has is the thread's lambda, mkwvk::gpu_hang_watch_start()::$_0::operator()() const. base_name took off only the closing (), which left ...::$_0::operator(), and that doesn't end with gpu_hang_watch_start. The check passed because it named the frame mkwvk::gpu_hang_watch_start(), which no run has.

  • scripts: base_name names a lambda's body as the function it's written in: clang's ::$_<n>::operator() and GCC's ::{lambda(...)#<n>}::operator().
  • tests: tests/test_prof_symbols.py checks the hang watch under the name the run gives it, both compilers' lambda forms, and a lambda that doesn't wait staying running. It fails against 0934572f's prof.py.

On that profile, the running samples with their leaf in a system module go from 91,913 to 31,573. What's left is work in the system under Longshot's frames, which stays running as this PR intends: event_signal, read_at, operator new, steady_clock::now.

Checks, Windows 11: test_prof_symbols, test_profile_stream and test_profile_path_key pass. test_profiling_mode fails as on main (the doubled hos_prof_start marker). test_prof_clock and test_prof_sampling need a g++ and a binary this machine doesn't have, and fail the same with and without this commit.

Follow-up pushed: 3af0c93f. After 0934572f, the hang watch's sleep still counted as running. On a later Windows `HOS_PROFILE=1` run (base 8e9cfc3a, `profile-20261116-211517`) it was 60,340 samples, 19.4 % of the running ones, all charged to `vk_replay.cpp`. The frame the run has is the thread's lambda, `mkwvk::gpu_hang_watch_start()::$_0::operator()() const`. `base_name` took off only the closing `()`, which left `...::$_0::operator()`, and that doesn't end with `gpu_hang_watch_start`. The check passed because it named the frame `mkwvk::gpu_hang_watch_start()`, which no run has. - scripts: `base_name` names a lambda's body as the function it's written in: clang's `::$_<n>::operator()` and GCC's `::{lambda(...)#<n>}::operator()`. - tests: `tests/test_prof_symbols.py` checks the hang watch under the name the run gives it, both compilers' lambda forms, and a lambda that doesn't wait staying running. It fails against 0934572f's `prof.py`. On that profile, the running samples with their leaf in a system module go from 91,913 to 31,573. What's left is work in the system under Longshot's frames, which stays running as this PR intends: `event_signal`, `read_at`, `operator new`, `steady_clock::now`. Checks, Windows 11: `test_prof_symbols`, `test_profile_stream` and `test_profile_path_key` pass. `test_profiling_mode` fails as on main (the doubled `hos_prof_start` marker). `test_prof_clock` and `test_prof_sampling` need a `g++` and a binary this machine doesn't have, and fail the same with and without this commit.
TrashPanda approved these changes 2026-11-17 07:11:51 +00:00
TrashPanda left a comment

A Windows profile counts Longshot's waits as waits, and names the renderer's functions. I read head 3af0c93f. It applies onto current main.

base_name drops a parameter list and a trailing const, and names a lambda as the function it is written in, so the hang watch's sleep matches gpu_hang_watch_start. The wait list also gains sleep_away, libc++'s condition waits and mutex lock, and a frame whose name ends in ::wait. Work under a Longshot frame, such as operator new or steady_clock::now, stays running. A Windows map's _Z names are demangled once, through LONGSHOT_MINGW or llvm-cxxfilt on the path, and the old MSVC reader still handles a ?name@ symbol. On an RTX 3080 profile, the main thread's hottest line goes from the mangled fence wait to mkwvk::guarded_copy, and the stutter list names game code instead of those waits.

This is the prof.py change to take. #1321 does the same demangle and the same waits, and also gives each thread one row in the Threads table. Do not land both copies of prof.py. Rebase #1321 and keep that row change.

Nothing further has to be run before this merges.

A Windows profile counts Longshot's waits as waits, and names the renderer's functions. I read head `3af0c93f`. It applies onto current main. `base_name` drops a parameter list and a trailing `const`, and names a lambda as the function it is written in, so the hang watch's sleep matches `gpu_hang_watch_start`. The wait list also gains `sleep_away`, libc++'s condition waits and mutex lock, and a frame whose name ends in `::wait`. Work under a Longshot frame, such as `operator new` or `steady_clock::now`, stays running. A Windows map's `_Z` names are demangled once, through `LONGSHOT_MINGW` or `llvm-cxxfilt` on the path, and the old MSVC reader still handles a `?name@` symbol. On an RTX 3080 profile, the main thread's hottest line goes from the mangled fence wait to `mkwvk::guarded_copy`, and the stutter list names game code instead of those waits. This is the prof.py change to take. #1321 does the same demangle and the same waits, and also gives each thread one row in the Threads table. Do not land both copies of `prof.py`. Rebase #1321 and keep that row change. Nothing further has to be run before this merges.
All checks were successful
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
CI / Conventional Commit title (pull_request) Successful in 7s
PR description / Description follows the template (pull_request_target) Successful in 8s
CI / Workflow lint (actionlint) (pull_request) Successful in 11s
Guide screenshots / Guide images and local UI source review (pull_request) Successful in 11s
Third-party parts / As their notes say (pull_request) Successful in 13s
This pull request doesn't have enough approvals yet. 0 of 1 approvals granted.
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/profile-report-windows:dyst-fix/profile-report-windows'
git switch 'dyst-fix/profile-report-windows'
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
3 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!1347
No description provided.