Skip to content

Test: Drag the current Windows window pin on every edge, judged by edge markers (#17, #353) - #684

Merged
b-re-w merged 25 commits into
developfrom
feat/17-windows-resize-ci
Nov 16, 2026
Merged

b-re-w merged 25 commits into
developfrom
feat/17-windows-resize-ci

Conversation

@b-re-w

@b-re-w b-re-w commented Nov 13, 2026 •

Copy link
Copy Markdown
Member

Drags the Windows window at the current pin on every edge, from another process, and judges every frame by edge markers (#17, #353, FR-19.8.4).

What it does

  • resize-probe.c drags hand-check's right, bottom and left edges and its bottom right corner at 16, 8 and 1 ms mouse rates, and runs the window states (maximise, restore, the left half of the work area, back). It does this on Windows Server 2022 and 2025, at 100% and 200%, with resize frames on the CPU (the default) and on the GPU (DXC_RASTER_RESIZE=0).
  • hand-check draws a marker scene (DXC_RESIZE_MARKER=1). Every frame is judged against the window's own border: a marker that does not reach it is an area not drawn, and a marker of the wrong width or a ruler line off its grid is a stretched picture. Holes, black, torn and stale frames and the drag lag are checked as well.
  • resize-control.c is a negative control, a window that is 50 ms late on purpose. It must FAIL every drag. If it passes anywhere, the probe could not tell late from prompt on that runner, and the job fails.
  • hand-check on the CPU path must PASS every drag and every state, and every CPU step must be blitted and validated.
  • The old test-windows-resize-probe.yml is folded into test-windows-resize-metrics.yml as the probe job. It drags the hand-check that the same run's windows job built, so what is dragged is always the window code at this commit's pin.

How it runs now

This branch is merged with today's develop. Development CI is one manual dispatch of ci.yml:

  • ci.yml's plan job runs scripts/ci-suites.sh on the dispatch's suites input. test_windows_resize is in all (the default), so every complete dispatch drags the pin; fast leaves it out. Its only condition is the plan's (if: needs.plan.outputs.test_windows_resize == 'true', needs: plan).
  • test_windows_resize calls test-windows-resize-metrics.yml (workflow_call only, no trigger of its own) with metrics: ${{ needs.plan.outputs.measure == 'true' }}. ci-suites.sh prints measure=true when measure is asked for (alone, which also selects this job, or as all,measure) and measure=false otherwise. The old test_windows_resize_metrics and test_windows_resize_probe names are gone from every list and are refused as unknown. The workflow's metrics input (default false) splits it in two:
    • Gate, always runs: requested, compose, windows (hand-check build, scripted resize, real drags and their checks) and probe. None of them, nor any step they are judged on, reads metrics.
    • Measurements, only with metrics: true: the macos job, the paced and GPU scripted runs and their summaries, the CPU resize frame draw bench, and the probe's "Report the drags" and "Report memory" tables.
  • In that run, these jobs prove this PR: "Compose and skiko for mingwX64 (built on Linux)" -> the windows job (builds hand-check, artifact hand-check-windows-kn) -> "Real drags of every edge from the resize probe at 100% and 200% (Windows, windows-2022)" and "(Windows, windows-2025)".
  • The gate is the last step of each probe job, "The probe can tell late from prompt, and the CPU path shows no fault". The artifacts are resize-probe-logs-*, resize-probe-frames-* and resize-probe-kit-windows.
  • scripts/tests/windows-resize-probe.test.sh checks that ci.yml calls the suite with no condition but the plan's, that ci-suites.sh puts it in all, that the suite has no other trigger, that the probe job and the jobs and steps it needs cannot be skipped or be allowed to fail, and that the measuring parts are behind metrics.

The window states and fork #223: judged by rate

Drags use the CPU resize path inside the move-size loop, so fork #223 does not touch them, and every drag stays strict: each kn-new-* drag must be verdict PASS with every resize-proof step blitted and validated, kn-old-* must take the GPU path, and every control-late-* must FAIL with no step under 45 ms late.

The window states are different. Fork #223 shows the previous picture for one composed frame after some size changes outside a drag: on every restore and snap at the current pin (1.11.1-ext.3, b97666a8), on about 2.6% of them (6.4% at worst) at ext.4 (a13a6289, fork #232). A strict zero would fail every dispatch at ext.3 and about one in three at ext.4.

So kn-new-states is judged by rate, as the fork's own probe does:

  • the kit runs it 25 times at each scale (run-probe-v2.ps1 -StatesRuns 25), 100 size changes per runner and scale, about 10 to 15 more minutes per runner;
  • resize-probe.c counts the faulty frames after each of the 4 changes and prints resize-probe: states changes=4 faulty=N faulty_frames=a,b,c,d; the per-run verdict line is unchanged;
  • the gate fails when more than 10% of the size changes had a faulty frame, or when fewer than 100 were counted (a probe that did not finish).

Leader-provisional decision, 2026-11-15. Alternative not taken: keep the states at zero and leave the job red until fork #223 is fixed. Revisit when #223 closes; it goes back to zero once the fork's window has one surface that takes the size and the picture in one step.

…ut DirectComposition

The criterion said WM_SIZE returns after ResizeBuffers, the Skia draw,
Present and a DirectComposition Commit. The window has no DirectComposition:
during a size change it hides the GPU child, draws the frame with Skia's
raster backend into a DIB and copies it into the top-level window's
redirection surface with BitBlt before WM_SIZE returns, and with
DXC_RASTER_RESIZE=0 it presents on the GPU and waits with DwmFlush.
The measure of the criterion (no frame at another size) is unchanged.

Refs #353
…mes from prompt ones

On CI hand-check passes with resize frames on the CPU and on the GPU
alike, so the probe has never shown it can tell a late frame from a
prompt one, and Windows 11 26H2 may hold a window's new size back until
its content is ready, which would hide lateness on its own.

- resize-control.c: a negative control built like the GPU resize path
  (redirected top level, child with a copy-model swapchain, refit, draw,
  Present, DwmFlush inside WM_SIZE) that presents every new size
  DXC_RESIZE_PRESENT_DELAY_MS (50) late during a drag. It draws a ruler,
  so a stretched or misplaced picture moves.
- resize-probe.c: the Windows version with its UBR as the first line
  (resize-os-version.h, shared with the control); a stale check (the
  content's left zone must stay where it was at rest; FR-19.8 criterion 4
  counts a stretched or old frame as a failure); the lag of the window's
  edge behind the cursor per frame and per drag, in px and ms; the window
  is put on the primary monitor's work area by the probe itself when it
  is not there (--place-after, default 20 s), at whatever size it settles.
- run-probe-v2.ps1: drags the control at each rate too, writes the OS
  line at the top of each application log, and writes summary.md, where a
  renderer's result is INCONCLUSIVE (no discrimination) at a rate where
  the control passes.
- The probe workflow runs on windows-2022 (20348) and windows-2025
  (26100), checks the control was late, and puts each runner's table in
  the job summary.

Refs #353
…he backdrop

On windows-2025 the console window the control opened sat beside it,
above the probe's backdrop, and the probe stopped with "the backdrop does
not show beside the window" for five of six control drags.

Refs #353
…nge (#353)

Brings feat/resize-probe-discrimination (PR #354) onto this branch: the
negative control resize-control.c (the GPU path's arrangement, 50 ms late
per step, with a ruler), the OS version line, the probe's lag and stale
frame checks, and the probe matrix on windows-2022 and windows-2025.

docs/SPEC.md is kept at develop's version. #354's Docs commit (439b643)
rewrites the Windows sentence of FR-19.8 criterion 4; that change waits for
the owner and is not part of this merge.
…e (FR-19.8, #17)

With DXC_RESIZE_MARKER=1 hand-check shows a scene the Windows resize
probe can judge absolutely: a light field, a 2 dp green column down the
left and right edges, a 2 dp green row along the bottom edge, and a dark
2 dp ruler line every 24 dp between the columns. A marker that does not
reach the window's border is an area that was not drawn, and a marker of
another width or a ruler line off its grid is a stretched picture, so a
trailing strip with nothing drawn can no longer read as a narrower window.

Covers FR-19.8 criterion 4 (every frame shown during a resize is drawn at
that moment's size) on the application side. The scene is built from
Row, Column and Box with Width, Weight and Background, nothing the window
code has to know about, so no fork change is needed for it.
… change (#353)

The negative control now draws hand-check's marker scene in pixels (green
left, right and bottom markers, a ruler every 24 px) instead of a blue
band, so the marker checks are proven against a window known to be late.
It is late on every WM_SIZE once it is on screen, not only inside a drag,
so maximise, restore and a size set from outside are judged by the same
control.
…d keep the frames (#17, #164)

resize-probe:
- --markers: at rest it measures how far the left, right and bottom
  markers are from the window's border, how wide they are, and the
  ruler's grid. In every frame after, each marker must be there, no
  further from the border than at rest and as wide, and every ruler line
  on its grid. A gap (an area not drawn, including a trailing strip the
  border moved in on) or a stretch fails the run, where before such a
  frame read as a narrower window.
- --edge right|bottom|left|corner|states: the bottom edge, the left edge
  (the window moves right first, so the drag goes outward and never meets
  the minimum size), the bottom right corner, and the window states:
  maximise, restore, the left half of the work area as snapping sets it
  (SetWindowPos, so no snap assist covers the backdrop), and back.
  --no-animation turns the maximise animation off for that run.
- --frames DIR: the frame at rest, ten frames spread through the drag,
  the first six faulty frames and the first frame after, cropped to the
  window plus 16 px.
- Every frame is copied once from a box around everywhere the window can
  be in the run; the strip, the columns and the markers read that copy.

run-probe-v2.ps1 drags every edge at three rates and the window states
once, for each app and path, with hand-check's marker scene on, and
resize-contact-sheet.ps1 turns the frames into PNG files, a contact sheet
per drag and one sheet with a frame of each, for the owner's look.

Covers FR-19.8 criterion 4 (no frame at another size than the window's,
measured from the screen by another process) and criterion 2 (pictures at
100% and 200%).
…trol and the CPU path (#17, #353)

The probe's drags move from "Windows resize probe test" into the Resize
metrics workflow as the probe job, which takes hand-check from the
windows job of the same run. It no longer drags the hand-check of run
38807049709, built before the multi-window window code and due to expire,
and test-windows-resize-probe.yml is retired (KNOWN_HEAVY and
needs-macos.sh follow).

The workflow's path filter now holds renderer/scripts/build-compose.sh,
where WINDOW_REVISION is set (the line #367 carried), the hand-check
fixture and every probe and kit script, so moving the window pin drags
the window it builds.

The probe job runs on Server 2022 and 2025, at 100% and 200%. It fails
when the 50 ms late control passes any drag (the probe could not tell
late from prompt there), and when hand-check's CPU path shows any fault,
markers included. The GPU path is reported. Frames and contact sheets
are the resize-probe-frames artifact.

scripts/tests/windows-resize-probe.test.sh checks the wiring, and
compiles the probe's colour tests where a C compiler is present.

Covers FR-19.8 criteria 2 and 4.
b-re-w and others added 4 commits November 13, 2026 17:17
….4, #17)

The marker scene put the ruler in the body row with Weight(1). The
renderer's weighted stack measures a weighted child at least as wide as
its minimum intrinsic width, which for 160 fixed 24 dp periods is
3840 dp, so the ruler took the whole row and the right marker was laid
out past the window and clipped. Every hand-check drag in Resize
metrics run 43367303462 ended as ERROR at rest: the probe found only
the left marker.

The body is now a box: a plain ruler row (no weight, so periods past
the width get no room) with a 2 dp lead so the lines stay at 24 dp,
and over it a row spaced between its ends holding the 2 dp left and
right markers. The geometry matches what resize-control draws.

The probe test checks that the scene weights only the body in the
column, spaces the side markers between the ends, and draws them over
the ruler.
….8.4, #17)

With one green run on a row, both scans found the same run and the
message printed it as both the left and the right marker
("left marker 8..9, right marker 8..9"). It now says there is only
one marker, where it is, and which side is missing.
…n (FR-19.8.4, #17)

The middle marker row sat at 50% of the client's height, the height a
right or left drag presses at, and the runner's capture holds the cursor.
Ahead of a growing window the cursor read as the window's last pixel, so
the distance from the border to the cursor counted as a marker gap (16 px
more each frame while the window waited, up to 160 px); inside a
shrinking window its outline read as an off-grid ruler line (stretch) or
covered the right marker (missing). The saved frames of run 43392446274
show the markers flush and the ruler on its grid on the other two rows
in every one of those frames. Bottom and corner drags press below the
rows, which is why they passed.

The rows move to 30%, 40% and 70%.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
…size-ci

# Conflicts:
#	.github/workflows/test-windows-resize-metrics.yml
#	.github/workflows/test-windows-resize-probe.yml
… path (#17)

The merge with develop kept ci.yml calling test-windows-resize-probe.yml,
which this branch folds into the probe job of test-windows-resize-metrics.yml,
so a dispatch would fail to start. The probe test now checks the path that
replaces the old pull_request filter: ci.yml calls the resize metrics suite
with no condition, the suite has no trigger but workflow_call, and the probe
job cannot be skipped or fail without failing the run (FR-19.8.4).
…-19.8.4, #17)

The probe job now runs the kn-new-states sequence (maximise, restore,
left-half snap, back, on the CPU raster path) 25 times at each scale,
100 size changes per runner and scale, and fails when more than 10% of
them had a faulty frame or when fewer than 100 were counted.
resize-probe.c attributes each faulty frame to the state change it
follows and prints "resize-probe: states changes=N faulty=M
faulty_frames=..." before the unchanged verdict line.

The reason: the fork's Windows window still shows the previous picture
for one composed frame after some restores and snaps (fork #223): on
every such change at the 1.11.1-ext.3 pin, on about 2.6% (6.4% worst
run) at the pending ext.4 pin. A strict zero fails every dispatch at
ext.3 and about one in three at ext.4. The fork's own probe gates the
same fault at 10%. It goes back to zero once #223 gives the window one
surface that takes size and picture in one step.

Every drag stays strict: kn-new drag labels must be verdict PASS, every
resize-proof step blitted and validated, kn-old must take the GPU path,
control-late must FAIL with no step under 45 ms late.
@b-re-w

b-re-w commented Nov 15, 2026

Copy link
Copy Markdown
Member Author

Leader-provisional decision 2026-11-15: states judged by rate (fail above 10 % of size changes), drags strict; alternative not taken: keep states at zero and leave the job red until fork #223 is fixed; revisit when #223 closes.

Implemented in 1c50c05: kn-new-states runs 25 times per scale (100 size changes), the probe prints a per-change fault count, and the gate fails above 10% or on a short count. Every drag, GPU path and negative control assertion is unchanged.

…imings on request (FR-19.8.4, #17)

The resize workflow takes a metrics input (boolean, default false). The
jobs the window-pin drag probe needs (requested, compose, windows) and
probe itself always run, with every asserting step unconditional. The
parts that only measure and report timings run only with metrics: the
paced and GPU scripted runs and their summaries, the CPU resize frame
draw bench, the probe's drag and memory tables, and the macOS job.

ci.yml calls it as test_windows_resize (it is no longer only metrics)
with metrics: true until suite selection lands on develop.

windows-resize-probe.test.sh now pins that the gate jobs and their
judged steps carry no condition, that the measuring parts read
inputs.metrics, and that ci.yml calls the workflow with no if or needs.

Why: the probe is the gate every dispatch must run; timings are
measurements that cost runner time and fail nothing.
…ze timings behind measure (#17)

The suite selection on develop listed test_windows_resize_metrics and
test_windows_resize_probe under measure, outside all. This branch folds
both into one ci.yml job, test_windows_resize, whose probe gates and
whose timings run only with its metrics input.

- ci-suites.sh names test_windows_resize in jobs=, so all selects it.
  measure= now holds only that job, and asking for measure also prints
  measure=true (false otherwise), the switch for the timings.
- ci.yml's plan exposes measure, and test_windows_resize passes
  metrics: ${{ needs.plan.outputs.measure == 'true' }}.
- ci-suites.test.sh: all runs it with measure false, fast leaves it
  out, measure runs it with measure true, all,measure both, the old
  names are unknown, and ci.yml wires the metrics input to the plan.
- windows-resize-probe.test.sh (FR-19.8.4): the ci.yml job may carry
  exactly the plan's if and needs: plan, and all must select it.
…Windows build job

The last line of the release link step lists .pdata section headers for the
log. Under pipefail a grep with no match exits 1, so the job failed after all
three release links had passed, and the probe that needs it was skipped (batch
run 43666750736). The lines before it already end in || true; this one did
not.
…with

The window pin's restore and snap work (fork #232) ends each resize-proof line
with when the step ran, " at <ms> ms". The Windows build job's check, and the
summary's count, matched the line up to its end, so every step counted as a
step that presented or left the child visible, and the job failed with all 94
steps correct (batch run 43744965586); the probe that needs it was skipped.

Both places accept the line with or without the time.
@b-re-w
b-re-w marked this pull request as ready for review November 16, 2026 05:50
@b-re-w
b-re-w merged commit bb9cddb into develop Nov 16, 2026
@b-re-w
b-re-w deleted the feat/17-windows-resize-ci branch November 16, 2026 05:50
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant