Build the clang lane with clang and libc++ 20 - #1064
Merged
Merged
Conversation
tools/localci built every lane with Ninja's default of CPUs + 2, and ASan builds of the largest translation units need several GB each. On a 16.7 GB, 24-CPU Docker VM the asan lane was killed with "Killed signal terminated program cc1plus", which reads like a compile error. The asan lane now builds with one job per 2 GB of the container's memory, never more than its CPUs; on that VM it chose 7. The gcc and clang lanes keep Ninja's default. The lane prints the count it chose, run.sh passes DIDI_LOCALCI_JOBS through, and that overrides any lane. Fixes #1050
blackboard_write, blackboard_patch, blackboard_clear and the four task calls built their answers from the board in memory before saving it, and never read the saved board back, so a save the file did not keep would still have read as done. Each now saves through saveAndReadBack, which reloads the file and checks its revision, and takes its revision, metadata, value and task from what was stored. blackboard_write also returns the value now at its path, and a clear confirms the path it removed is gone. The seven move from exempt to observed in tests/observed_post_state.json. The live harness compares each answer with the board file as Godot's own JSON reader parses it, through a new board_file witness. Reporting a revision one higher than the file holds fails the harness on blackboard_write.revision. Part of #1019. Fifteen tools remain on it.
The harness copied tests/godot_smoke whole, including the .didi/ runtime state the Python suites leave there. A local run then started from that state, and a suite running at the same time held a byte-range lock in it that failed the copy before the first assertion. The copy now leaves out .didi/ and .godot/. Neither exists in a CI checkout. With a lock held on a file in the source .didi/, the old copy fails with "locked a portion of the file" and the harness now passes on 4.7.2, with no .didi/ from the source in its fixture. Fixes #1036
The lane used Ubuntu 24.04's default clang and libc++ 18. libc++ 18 has no floating-point std::from_chars, so argument_normalization.cpp did not compile there, while the macOS runner's libc++ built it. Ubuntu 24.04 ships clang-20 and libc++-20-dev in its own archive, and a three-line probe in the lane image parses a double through from_chars with them. The image installs those, and the lane configures with clang-20. A build volume whose cached compiler the image no longer has is reconfigured on its own, because CMake does not read CC and CXX again over an existing cache. run.sh also passes DIDI_LOCALCI_RECONFIGURE, which lane.sh documented and never received. Fixes #1026
github-actions
Bot
added
documentation
9 of 16 tasks
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Description
The
clanglane intools/localcicould not build main. It used Ubuntu 24.04's default clang and libc++ 18, and libc++ 18 has no floating-pointstd::from_chars, whichsrc/mcp/argument_normalization.cppuses. The macOS runner's Apple libc++ builds it, so the stand-in no longer resembled what it stands in for.clang-20andlibc++-20-dev(20.1.2) in its own archive, so no outside repository is needed. The image installs those, and the lane configures withclang-20/clang++-20. A three-line probe in the lane image parses3.25throughstd::from_charswith them./usr/bin/clang++, and CMake does not readCCandCXXagain over an existing cache. The lane now reconfigures when the cached compiler is no longer in the image.lane.shdocumentsDIDI_LOCALCI_RECONFIGURE=1as the way to force a fresh configure, andrun.shnever passed it into the container, so it could not be used. It is passed now, besideDIDI_LOCALCI_JOBSfrom Bound the asan lane's build jobs by the container's memory聽#1061.tools/localci/README.mdstates the version and why.No product code changes. I did not add a
strtodfallback, as the issue asked.Related Issues
Fixes #1026
Stacked on #1063, which merges first.
Type of Change
Checklist
tests/covering new functionality. Tooling only; verified by the lane run below.tests/run_godot_integration.ps1on Godot 4.5.1. Not touched.didi --dump-tool-manifestfrom the same build, preserves the Phase 4/5/6 contracts, and keeps reserved runtime debugger tools marked unimplemented. Not touched.docs/SURFACE_AMENDMENTS.md. No new tool.docs/BUILD_QUEUE.mdsaysIN PROGRESS, orCOMPLETE (#<this pull request>). Not a queue item.docs/andREADME.md.tools/localci/README.md.Verification
bash tools/localci/run.sh clangagainst the existing clang build volume:== the cached compiler /usr/bin/clang++ is gone; configuring from scratch, then a clean build of main with clang 20 and libc++ 20.didi_tests:Results: 937 passed, 0 failed.ctest's Python half reported eight errors. All eight aregit -C /work ... returned non-zero exit status 128fromtest_check_release_archiveandtest_field_trial, which happens whenever the lane runs from a.worktrees/worktree: its.gitis a file pointing outside the container. The gcc lane shows the same eight from the same worktree. From a main checkout they pass.