2 commits

Author	SHA1	Message	Date
Daniel Han	827d25931b	Stop 19 test files racing on one PowerShell startup cache (#9371) ... * Stop 19 test files racing on one PowerShell startup cache Backend CI run 32341628757 on `1c3dde199` finished `284 failed, 8498 passed`. Every one of the 284 was a pwsh subprocess ending `died with <Signals.SIGABRT: 6>`, across 19 files that all read as Windows-installer regressions. None of them were. 222 of the aborts land inside a two-second window, 88 at 07:09:30 and 133 at 07:09:31, which is a mass kill of every live pwsh rather than independent per-test flakiness. The cause ------------------------------------------------------------------------ Every `-NonInteractive` startup reads and rewrites an ~83 KB `$XDG_CACHE_HOME/powershell/StartupProfileData-NonInteractive`, and XDG_CACHE_HOME defaults to `$HOME/.cache`. Under `-n 4` all four xdist workers share one HOME, so the whole job's pwsh processes race on one file and a startup that deserialises a half-written one dies before it reaches our script. `Stack overflow.` is .NET's failfast, which cannot unwind a blown stack, so it prints one line and calls abort(); that is the SIGABRT (PowerShell/PowerShell#24461). Measured twice, independently, 4000 startups per arm: run 1 shared cache dir 7/4000 died {-11: 3, -6: 4} private cache dirs 0/4000 run 2 shared cache dir 11/4000 died {-11: 10, -6: 1} private cache dirs 0/4000 Three distinct crash shapes appeared, and each names the torn file rather than our scripts: `Stack overflow.`, `System.IO.FileLoadException: The given assembly name`, and `System.ArgumentException: String cannot have zero length.` 18 deaths in 8000 shared startups, 0 in 8000 private. CI agrees from the other direction. Of the pwsh-heavy files in that run, exactly one had zero failures, tests/test_windows_amd_gpu_scan_fallback.py, and it is the only one that hands its child a private HOME, across roughly 80 startups where the run's own rate predicts about 16 failures. What is NOT established ------------------------------------------------------------------------ Neither experiment reproduces CI's rate. Roughly 20% of pwsh startups died there against 0.2 to 0.3% here, and at CI's actual `-n 4` on this box I measured 0/1200 in both arms: the race needed 48-way concurrency before it appeared at all. The likely reason is that four workers on a 4-core runner are in real contention while four threads on a 192-core box almost never overlap in the critical section, but that is reasoning and not a measurement, so treat the mechanism as proven and the magnitude as unexplained. That is also why this does not stop at removing the shared file. Three layers, in order ------------------------------------------------------------------------ 1. Remove the contended resource. One cache directory per xdist worker, fresh per session. Workers run their tests one at a time, so within a worker the startups stay sequential and the cache still does its job warm; across workers the directories are disjoint and there is nothing left to race on. Fresh rather than a stable path, because a cache torn by an earlier run would otherwise poison every later session on the same box. 2. Retry a run that produced no verdict. Three attempts, unslept, because the trigger is process startup rather than a resource that frees up. 3. Attribute what is left. A crash raises PwshInterpreterCrash naming the interpreter. Layer 1 is the fix; 2 and 3 exist because of the unexplained magnitude above. Deliberately NOT done: bounding pwsh concurrency with a lock, or giving up `-n 4`. The workflow records 806.1s to 219.7s from that flag, and the contended resource can be removed rather than rationed. The rule that keeps this honest ------------------------------------------------------------------------ A signal is not a verdict, so retrying it papers over nothing: the script never ran to its end. A normal exit is returned untouched on the first attempt whatever its code, so a pwsh that runs and gives the WRONG answer still fails with its own message. Getting that second half wrong would turn this into a way to retry real regressions into green, which is worse than the bug it fixes, so both directions are executed in tests/studio/test_pwsh_interpreter_crash_attribution.py against a real SIGABRT rather than reviewed. Mutation-tested: relaxing the crash test from `returncode < 0` to `returncode != 0` fails test_a_clean_run_with_the_wrong_answer_still_fails_with_its_own_message and test_a_clean_run_is_not_retried, which are exactly the two that guard that direction. This also generalises `_run_pwsh` from tests/studio/test_install_phase_timing.py, added earlier today for a second, signal-free shape: pwsh printing its "The PowerShell process will exit" banner and exiting normally with empty stdout. That one cannot be seen in the exit status, so it stays a text match. Verified ------------------------------------------------------------------------ tests/python/test_windows_xformers_installer.py, tests/studio/test_install_phase_timing.py, tests/studio/install/ and the new guard: 2635 passed, 3 skipped. Guard alone: 5 passed. * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Drop the subprocess import the pwsh conversion left behind Source lint's import-hoist check is right: every subprocess.run in test_windows_xformers_installer.py became run_pwsh, so `import subprocess` has no references left except the one inside a comment explaining why run_pwsh is used instead. Its wording names the shape exactly -- "was used before, now unused (references re-pointed)" -- which is what a mechanical call-site rewrite leaves behind. Swept the other 18 converted files the same way with an AST pass rather than by eye. This was the only real one: the remaining hits are `from __future__ import annotations`, which every such scan reports, and a PropertyMock in test_rocm_support.py that is present on main unchanged. 42 passed. * Suppress the core dump on the forged SIGABRT tests/test_deliberate_crashes_suppress_cores.py caught this: the abort child had no PR_SET_DUMPABLE=0, so each of these aborts piped a multi-MB core to apport before the child could be reaped. The guard is right and its message names the fix. The child still exits -6 and PR_GET_DUMPABLE reads 0, so all five verdicts are unchanged. Linux-only and non-fatal elsewhere: Windows has no CDLL(None) and pipes no core, so arming it there would trade a no-op for a lost test. --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: danielhanchen <unslothai@gmail.com>	2026-08-20 04:22:41 -07:00
Daniel Han	9bfa18cdb0	Windows: unblock the consumer install on clean and no-winget machines (#7549) ... * Windows: unblock the consumer install on clean and no-winget machines Four independent things stop a clean Windows box today. git was a hard Exit-SetupFailure in setup.ps1, justified as required by pip for git+https:// deps and by npm. Neither holds on the consumer path: the unsloth-zoo git+https URL is only used under STUDIO_LOCAL_INSTALL, node is a pinned nodejs.org prebuilt that never touches system npm, and the frontend lockfile has no VCS dependencies. It stays fatal for --local, where it really is needed. Ensure-VCRedist was winget-only, so on hosts without winget (LTSC, Server, managed corporate images) it silently did nothing while the install reported success, and torch then failed to import on a missing VCRUNTIME140.dll. Adds a direct aka.ms/vs/17/release/vc_redist.<arch>.exe download with /quiet /norestart, accepting exit codes 0 and 3010. The redistributable stays required: it is the runtime the prebuilt llama-server and torch link against, not the MSVC compiler, which is already detection-only. Windows on ARM has no PyTorch at all. Measured with uv against download.pytorch.org/whl/cpu and PyPI for aarch64-pc-windows-msvc / cp313: torch, torchvision and torchaudio all resolve to nothing, wheels exist only for win_amd64 and the manylinux targets. The installer burned three uv retries on an unsatisfiable resolution and reported a bare 'Failed to install PyTorch (exit code 1)'. Now it says what is actually wrong and points at --no-torch, which works because llama.cpp does publish windows-arm64-cpu. install_node_prebuilt.py hit '[WinError 5] Access is denied' on os.replace of the freshly extracted directory during a FRESH install, which is a scanner or indexer holding handles for a moment. Retries only winerror 5, 32 and 145 with capped exponential backoff; any other OSError still raises immediately. * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Give the ARM64 dead end a recovery that works for web installs The only remedy printed was .\install.ps1 --no-torch, but the documented path is irm | iex, where no file exists and flags cannot be forwarded. Name the env var the script already honours at line 145. * Windows on ARM: drop torchaudio, do not abort the install The fail-fast was based on a wrong premise. Counted against download.pytorch.org/whl/cpu: torch has 42 win_arm64 wheels and torchvision 60; only torchaudio has none. PyTorch has shipped Arm-native Windows builds since April 2025, so aborting blocked a platform that mostly works. Drop the one unsatisfiable pin instead. Decide from the interpreter uv will resolve for, not the PowerShell host: an x64 CPython under emulation gets working win_amd64 wheels on an ARM64 box, and powershell.exe inherits PROCESSOR_ARCHITECTURE from its parent. * Carry the ARM64 torchaudio omission into studio setup Dropping it from the first PyTorch command was not enough: install.ps1 then runs studio setup with SKIP_STUDIO_BASE=1 and setup.ps1 reinstalls the bare trio from the CPU index, so the ARM64 path still aborted. Apply the same interpreter-based test there. An unreadable platform keeps the full trio. * Build the torch spec list outside the verbose branch The ARM64 guard landed inside `if ($script:UnslothVerbose)`, so on the default path $_torchTrio was never assigned and the splat expanded to nothing: uv ran as `uv pip install --index-url ...` with no package, exit 2, straight to Exit-SetupFailure. That broke the ordinary Windows install. Hoist it above the branch and use substep, which prints on both paths. Realign the two parity guards to the splat form; they asserted the pre-refactor literal command and were the actual cause of the red parity legs. Both halves are still checked: the bounded list is built, and it reaches the install. * Tighten the comments on the Windows install path * Windows install: honour the ARM64 torchaudio skip everywhere and keep git for source builds Hoist the venv-interpreter platform probe above every torch branch in studio/setup.ps1 so the win_arm64 torchaudio omission applies to the ROCm, CPU and CUDA/custom paths. A pinned index whose leaf is not cpu routed an ARM64 host into the CUDA/custom branch, which still asked for torchaudio. Require git again when a llama.cpp source build is opted into up front (UNSLOTH_LLAMA_FORCE_COMPILE, UNSLOTH_LLAMA_PR / PR_FORCE, a non-upstream source). Those paths git clone in phase 4, so setup used to report git as not required, install the build toolchain, then fail at the clone. A local llama.cpp dir overrides them, and the automatic source fallback after a failed prebuilt download stays non-fatal. Also tighten the comments across the changed install paths. * Install the x64 VC++ runtime unconditionally in the direct-download fallback The winget branch always installs Microsoft.VCRedist.2015+.x64, but the direct-download fallback picked the package from PROCESSOR_ARCHITECTURE, which reports the architecture of the running PowerShell process rather than the interpreter that will load the DLLs. Find-CompatiblePython in install.ps1 selects an interpreter on version and non-Conda status alone, with no architecture predicate, so a native ARM64 shell can settle on an emulated x64 Python whose win_amd64 torch and prebuilt llama-server need the x64 runtime, while the fallback had just installed the ARM64-only package. Ensure-VCRedist also runs well before the venv exists, so the interpreter cannot be probed at that point. Microsoft ships the x64 redistributable as an Arm64X superset that carries both ARM64 and x64 binaries, so it is correct on both machines and the manual instruction printed on failure already pointed at it. * Windows on ARM: prefer an x64 Python interpreter An ARM64 host cannot complete the install with a native ARM64 interpreter. pyarrow, pulled in by unsloth -> datasets, has never published a win_arm64 wheel on any version, and neither has hf-transfer, a direct dependency. Both therefore fall back to a source build: pyarrow dies in scikit-build-core CMake configuration and hf-transfer dies in openssl-sys for want of perl, several minutes into a run that looked healthy. torch and torchvision are not the problem, they have win_arm64 wheels and install fine. Windows 11 on ARM runs x64 binaries under emulation and both packages ship win_amd64 wheels, so an x64 interpreter installs cleanly. Find-CompatiblePython accepted an interpreter on version and non-Conda status alone. It now ranks candidates by architecture on ARM64 hosts and returns an x64 one when present, asking each interpreter for its own sysconfig.get_platform() rather than guessing from its path. Host architecture comes from PROCESSOR_ARCHITEW6432 and OSArchitecture as well as PROCESSOR_ARCHITECTURE, which describes only the current process and reads AMD64 in an emulated shell. This is a preference, not a requirement. If only ARM64 is found, x64 is bootstrapped through winget --architecture x64 or the python.org fallback, and if neither works the installer names pyarrow and hf-transfer up front instead of failing later on a CMake or Rust error. The ARM64 torchaudio skip stays live for that path. Non-ARM hosts return on the first match exactly as before, with no extra interpreter probing. * Windows install: three correctness fixes on the ARM64 and git-less paths Ensure-VCRedist never reached its x64 download on an ARM64 machine that already had the arm64 redistributable: Test-VCRedistInstalled accepted System32\vcruntime140_1.dll regardless of architecture, and there that file can be the pure-ARM64 package. An ARM64 PE cannot load into an emulated x64 process, so the x64 Python this branch now prefers would have been left without a usable runtime. The x64 registry entry is the only x64-specific proof, and Microsoft registers Runtimes\{x86|x64|arm64} per architecture, so vc_redist.x64.exe still writes Runtimes\x64 on an ARM64 host and the check cannot loop. The DLL probe stays for x64 hosts. Phase 1 demanded git for any non-blank UNSLOTH_LLAMA_PR_FORCE, but the promotion that actually turns it into a source build requires a positive integer, so PR_FORCE=0 or a non-numeric value aborted a git-less consumer install for a build that never runs. Both sites now use the same predicate. The automatic fallback after a failed prebuilt llama.cpp download reached git clone with no git check anywhere in between, and Invoke-SetupCommand returns 0 for a command-not-found, so a git-less host did not stop there: it continued into an empty directory and reported a cmake configure failure instead. Git is now resolved where the source build is decided, with a last winget attempt, and a missing git degrades exactly like a missing cmake rather than aborting, since the opt-in source triggers already required git in Phase 1. Also tightened the comments across the changed Windows install code, keeping the reasons on the guards that prevent a specific failure. * Rank ARM64 Python candidates by minor version before architecture The x64 preference filtered the whole candidate list on architecture, which outranks the version preference the candidates were collected in. With UNSLOTH_PYTHON=3.12 on a Windows ARM64 box holding an ARM64 3.12 and an x64 3.13, it returned the x64 3.13: the explicit pin was silently broken, and because a x64 interpreter was found the caller never ran Install-X64Python to fetch an x64 3.12. With no pin it was worse still, since an x64 3.11 outranked a newer ARM64 3.13 and defeated the newest-first fallback. Walk $minors in order and take the x64 build of the best minor available, falling back to that minor's ARM64 build so the caller bootstraps x64 for the version actually requested. x64 still wins within a minor, and non-ARM hosts are untouched. * Windows install: see every registered Python, order git before the toolchain Find-CompatiblePython only ever probed `py -3.X`, which runs the launcher's preferred build for that minor. On an ARM64 box that is the native ARM64 interpreter, so a same-minor x64 install that is registered with the launcher but neither preferred nor on PATH never became a candidate. The x64 preference then lost to ARM64, and Install-X64Python re-downloaded an x64 CPython that was already on the machine; when that download is unavailable the install continues on ARM64 and source-builds pyarrow and hf-transfer, which publish no win_arm64 wheels. Enumerate `py -0p` on ARM64 hosts and probe each listed path. The `-3.12-64` suffix cannot be used for this: it has meant "not 32-bit" since 3.11 and does not distinguish arm64 from amd64. studio/setup.ps1 ran Ensure-BuildToolsForLlamaSourceBuild before checking git in Phase 4. That helper calls Exit-SetupFailure when Visual Studio Build Tools cannot be installed, so on a clean no-winget box the git degraded path added by this PR was unreachable and a standalone update aborted instead of finishing in limited mode; where winget does exist it spent a multi-GB Build Tools download on a clone that could never run. Check and install git first, skip the toolchain helper when git is still missing, and report the git branch before the cmake branch so the message names the real cause. _swap_into_place retried the forward rename for about 16 seconds but rolled back with a bare os.replace. A scanner holding the backup for the same WinError 5/32 then left no install_dir at all and stranded the working runtime in .old-*, and its exception replaced the original failure. The rollback now uses the same backoff and logs instead of masking the error it is recovering from. * Installer: use an already installed x64 Python on ARM64 when none can be downloaded Find-CompatiblePython ranks x64 within one minor and returns the native build when that minor is ARM64-only, leaving Install-X64Python to bootstrap x64. On an offline or winget-less box that bootstrap fails, and the retry went through the same resolver, so an x64 build of a lower-priority supported minor already on the machine was never picked up and setup continued on ARM64 Python, where pyarrow and hf-transfer have no wheels. Add an -X64Only mode that returns the best installed x64 interpreter or nothing, and call it as the last resort in Install-X64Python. The version-first preference is unchanged: x64 of the requested minor is still bootstrapped first. * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Tighten comments in the Windows ARM64 installer changes * Setup: require Git for a source build behind an unbuilt local llama.cpp dir UNSLOTH_LOCAL_LLAMA_CPP_DIR only overrides the source-build opt-ins once the directory holds a reusable llama-server.exe. Pointing it at the canonical install location with nothing built there falls through to the normal install, so the Phase 1 gate now probes the same layout candidates as the Phase 4 reuse check before dropping the requirement. * Setup: require Git when UNSLOTH_LLAMA_TAG=master forces a source build * Tighten comments in the Windows installer changes * Setup: negotiate TLS 1.2 for the direct VC++ runtime download --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: danielhanchen <unslothai@gmail.com>	2026-07-28 22:24:40 -07:00