Skip to content

Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.

CI: site-lane changes skip the app build on staging too; ui_idle_redraw checks CPU between frames

islandmed055e251f0d6a
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ff7af2e4..bf8d1644 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,9 +38,11 @@ concurrency:
# The release packages are built by packages.yml (on pushes to main), the Flatpak check for pull requests is flatpak.yml.
jobs:
- # Pushes and pull requests that change only the website (not its phone page, website/link, which is built into the
- # app), docs no build or test reads (docs/guide and docs/supporters.txt are built in), note fragments or release
- # paperwork skip the build and test jobs; their required checks then pass as skipped.
+ # Site-lane changes (every file on tools/ci/site_lane.txt) skip the build and test jobs on every event, the merge
+ # queue's staging dispatch too (diffed against main); the Trademarks job always runs. Pushes and pull requests that
+ # change only the website (not its phone page, website/link, which is built into the app), docs no build or test
+ # reads (docs/guide and docs/supporters.txt are built in), note fragments or release paperwork skip them as well;
+ # their required checks then pass as skipped.
# `full`: the slow platform checks (VFX Reference Platform containers, Blender add-on in Blender) run on main, in the
# merge queue's batch run (scripts/merge-queue.sh), on a dispatch with full=true and on a pull request labelled full-ci; other branch runs skip them.
changes:
@@ -70,9 +72,19 @@ jobs:
base=$BASE
[ "$EVENT" = push ] && base=$BEFORE
code=true
- if [ "$EVENT" != workflow_dispatch ] && [ -n "$base" ] && [ "$base" != 0000000000000000000000000000000000000000 ]; then
+ # A dispatch (the merge queue's staging batch, scripts/merge-queue.sh) is diffed against main.
+ [ "$EVENT" = workflow_dispatch ] && base=main
+ if [ -n "$base" ] && [ "$base" != 0000000000000000000000000000000000000000 ]; then
# (the compare API lists at most 300 files: more than that counts as a code change)
- if files=$(gh api "repos/$REPO/compare/$base...$HEAD" --jq '.files | if length >= 300 then error("many") else .[].filename end'); then
+ files=$(gh api "repos/$REPO/compare/$base...$HEAD" --jq '.files | if length >= 300 then error("many") else .[].filename end') || files=""
+ # Site lane: every file on tools/ci/site_lane.txt (the list ~/Work/.sf/lane.sh reads too), read from the base,
+ # never from the change itself (a pull request can't widen it for its own run).
+ lane=$(gh api "repos/$REPO/contents/tools/ci/site_lane.txt?ref=$base" -H 'Accept: application/vnd.github.raw') &&
+ lane=$(grep -v '^#' <<< "$lane") || lane=""
+ if [ -n "$files" ] && [ -n "$lane" ] && ! grep -qvE -f <(echo "$lane") <<< "$files"; then
+ echo "::notice::site lane only (tools/ci/site_lane.txt): no build or tests"
+ code=false
+ elif [ -n "$files" ] && [ "$EVENT" != workflow_dispatch ]; then
code=false
while IFS= read -r f; do
case "$f" in
diff --git a/src/app/App.cpp b/src/app/App.cpp
index d5e9a485..01873c77 100644
--- a/src/app/App.cpp
+++ b/src/app/App.cpp
@@ -863,6 +863,9 @@ int App::run() {
const double started = seconds();
uint64_t framesDrawn = 0, wakeUps = 0, framesAtMeasure = 0, wakesAtMeasure = 0;
double cpuAtMeasure = 0.0; // processor time of every thread (the driver's included)
+ // ...of which the frames drawn while measuring: the idle check is about the time between them (software OpenGL,
+ // CI's Windows runners, spends about 0.4 s of processor time on one frame: two such frames were "10% idle CPU").
+ double cpuInFrames = 0.0, cpuFrameStart = 0.0;
bool measuring = false;
// Input while measuring (a pointer crossing the window on a shared desktop) restarts the count once it has
// passed: idle means no input. After kMeasureGiveUp seconds it counts whatever comes (the test's timeout).
@@ -916,12 +919,16 @@ int App::run() {
framesAtMeasure = framesDrawn;
wakesAtMeasure = wakeUps;
cpuAtMeasure = processCpuSeconds();
+ cpuInFrames = 0.0;
} else if (measuring && t0 >= measureFrom + options_.measureIdle) {
const double fps = double(framesDrawn - framesAtMeasure) / double(options_.measureIdle);
- const double cpu = 100.0 * (processCpuSeconds() - cpuAtMeasure) / double(options_.measureIdle);
- std::printf("Idle: %llu frames, %llu wake-ups in %.1f s: %.2f fps, CPU %.1f%% of one core (%s redraw)\n",
+ const double cpuAll = 100.0 * (processCpuSeconds() - cpuAtMeasure) / double(options_.measureIdle);
+ const double cpuFrames = 100.0 * cpuInFrames / double(options_.measureIdle);
+ const double cpu = std::max(0.0, cpuAll - cpuFrames); // between frames
+ std::printf("Idle: %llu frames, %llu wake-ups in %.1f s: %.2f fps, CPU %.1f%% of one core between frames"
+ " (+%.1f%% drawing them) (%s redraw)\n",
(unsigned long long)(framesDrawn - framesAtMeasure), (unsigned long long)(wakeUps - wakesAtMeasure),
- double(options_.measureIdle), fps, cpu, continuous ? "continuous" : "on-demand");
+ double(options_.measureIdle), fps, cpu, cpuFrames, continuous ? "continuous" : "on-demand");
if (measureRestarts > 0) std::printf(" (restarted %d times after input)\n", measureRestarts);
std::fflush(stdout);
// Idle is 0 fps; a pointer crossing the window draws about a second's worth. Every frame is 60+.
@@ -1151,6 +1158,7 @@ int App::run() {
draw = false; // minimised: the next event (restore) draws again
continue;
}
+ if (measuring) cpuFrameStart = processCpuSeconds();
updateCameraAspect();
// The SpaceMouse moves the view by its held axes every frame (frame-rate independent); while it does,
// spaceMouseMoving() is true and a loop that waits for events when idle must keep drawing.
@@ -1226,6 +1234,7 @@ int App::run() {
phase[5] - phase[4], phase[6] - phase[5]);
if (phases == 7 && perftrace::on()) tracePerfFrame(phase); // Help > Record a performance trace
++framesDrawn;
+ if (measuring) cpuInFrames += processCpuSeconds() - cpuFrameStart;
{
const double frameNow = seconds();
static double lastSwap = 0.0;
diff --git a/tests/flaky.md b/tests/flaky.md
index 5f89c6e2..12b2eb44 100644
--- a/tests/flaky.md
+++ b/tests/flaky.md
@@ -7,3 +7,12 @@ deletes it; remove its lines once fixed.
| date | test | machine | commit |
|---|---|---|---|
| 2026-11-04 | sculptforge_tests_9of16 | PC (WSL, RTX 3060), ctest -j10 | 76e4be24 |
+| 2026-11-06 | ui_idle_redraw (failed its rerun too) | CI Windows (2/4), software OpenGL, runs 42231997469 + 42243212500 | 8c070932, 3959b469 |
+
+## Owned
+
+- **ui_idle_redraw**, CI Windows (fix/ci-site-lane): not a spin. Both failing batches changed only the site (the app
+ was byte-identical to green main f4a05960); every failure drew 1-2 frames and woke 16 times in 4 s, as idle should.
+ The CPU check counted every thread over the whole window, and one software-OpenGL frame (llvmpipe's threads) costs
+ ~0.4 s of processor time on that runner: 2 frames = 10-16% "idle CPU" over the 10% cap. `--measure-idle` now
+ checks the CPU between frames and prints the frames' share apart. Remove these lines after a week of green Windows.
diff --git a/tools/ci/site_lane.txt b/tools/ci/site_lane.txt
new file mode 100644
index 00000000..0b8d2d40
--- /dev/null
+++ b/tools/ci/site_lane.txt
@@ -0,0 +1,14 @@
+# Site lane: a change whose every file matches one of these (extended regexes, one per line, '#' lines ignored) is
+# site-only. It deploys from main (pages.yml) and skips the app build and tests in CI (ci.yml, job Changes), on
+# staging too; ~/Work/.sf/lane.sh routes it to sitegate.sh instead of the PC suite.
+# (website/link and docs/supporters.txt are built into the app too: it picks them up at the next release, whose
+# build and PC suite test them.)
+^website/
+^README\.md$
+^THIRD_PARTY_NOTICES\.md$
+^docs/brand\.md$
+^docs/supporters\.txt$
+^tools/brand/
+^tools/guide/build_site\.py$
+^tools/marks_media_[a-z]+\.(json|txt)$
+^changes/site-