Julia: @recompile_invalidations precompile crash 'invalid instruction mnemonic exit' ProcessSignaled(11)

Julia: CxxWrap + CUDA invalidations, and @recompile_invalidations precompile crash ProcessSignaled(11)

TL;DR

These are two separate problems. The invalidations live upstream inside CxxWrap itself (a broad nextind definition for its StdString type and an Integer fallback in CxxWrap.jl), so they cannot be fixed from your own package; the realistic levers are load order, not co-loading the two packages in one precompile image, and an upstream report carrying the SnoopCompile tree. The crash is a different failure: PTX-style inline assembly (an exit instruction) reaching the host assembler during the precompile workload means CUDA kernel work is being triggered inside @recompile_invalidations. Isolate the workload per package, keep kernel execution out of precompilation, and only then judge whether the workaround helps.

Verbatim error

invalid instruction mnemonic 'exit' (LLVM, on an inline-asm exit line)
ERROR: LoadError: The package failed to precompile (ProcessSignaled(11))
raised while precompiling a PrecompileTools module whose workload wraps using CUDA and using CxxWrap in @recompile_invalidations, Julia 1.13

Steps

1. Split the counts before changing anything. With SnoopCompile, record invalidation trees for three fresh sessions: CxxWrap alone, CUDA alone, and both together. Success check: the both-together tree is dominated by definitions inside CxxWrap (StdString nextind, the CxxWrap.jl Integer fallback), which confirms the remaining invalidations are upstream and not caused by your methods.
2. Stop trying to fix upstream invalidations locally. Do not add methods to CxxWrap types or pirate its functions from your package; that trades invalidations for ambiguity and breakage. Success check: your own package's portion of the tree is the part you already removed, and the rest is filed upstream with the tree attached.
3. Test load order and co-loading. Compare startup invalidation counts for CxxWrap-then-CUDA versus CUDA-then-CxxWrap, and measure whether your application actually needs both in the same session and precompile image. Success check: you have a measured count per order instead of a guess, and a decision on co-loading based on it.
4. Isolate the precompile crash. Build two minimal healing modules, one wrapping only using CUDA and one wrapping only using CxxWrap in @recompile_invalidations, in a clean environment. Success check: exactly one of them reproduces the ProcessSignaled(11) crash, which names the package whose workload trips it.
5. Keep GPU kernel work out of the healing workload. If the CUDA-only module crashes, retry with CUDA available but not functional (no device initialised) during precompilation, and remove any workload statements that launch kernels. The exit mnemonic is a PTX instruction; it should never reach the host assembler, and it gets there when kernel compilation or launch work runs at precompile time. Success check: the module precompiles without the LLVM mnemonic error.
6. Rebuild the combined healing module only after both single-package versions pass, and re-measure invalidations in a fresh session. Success check: precompilation completes and the post-load invalidation count is lower than the unhealed baseline from step 1; otherwise drop the workaround and rely on the load-order decision from step 3.

When this applies

• Julia 1.13 (compiled/v1.13 paths) with CxxWrap and CUDA.jl loaded in the same session
• SnoopCompile trees dominated by CxxWrap StdLib StdString nextind or the CxxWrap.jl Integer definition
• A PrecompileTools healing module that fails to precompile with ProcessSignaled(11)

When this does not apply

• Invalidations caused by your own broad method definitions (fix those directly)
• CUDA precompilation failures with no CxxWrap involvement
• Runtime CUDA kernel launch errors after a successful precompile

Variant phrasings

Several thousand method invalidations after loading CxxWrap with CUDA

Same upstream pattern; start at step 1 and confirm the tree really is dominated by CxxWrap-internal definitions before assuming your package is at fault.

Healing package fails to precompile with an LLVM mnemonic error

Same crash shape even if the named healing package differs; isolate per package starting at step 4.

Why it happens

CxxWrap defines very general methods for its wrapped C++ string and integer types. When a second large package loads afterwards and defines or extends overlapping generic functions, those broad definitions are invalidated in bulk, and the count lands on whoever defined the broad method, which here is CxxWrap itself. Separately, @recompile_invalidations replays invalidated method bodies during precompilation; if that replay triggers CUDA kernel compilation work, device-side assembly can leak into a host compilation step that cannot accept it, and the precompile worker dies with signal 11.

Edge cases

• No GPU on the precompiling machine: a crash that only reproduces with a device present points even harder at kernel work inside the workload.
• Counts vary between runs: invalidation totals depend on load order and what else the session loaded, so always compare in fresh sessions with identical package sets.
• Upstream fixes move fast in this area: after any CxxWrap or CUDA upgrade, redo step 1 before assuming the workaround is still needed.

Provenance

Resolved from the public thread: https://discourse.julialang.org/t/method-invalidations-with-cxxwrap-cuda/140011

In the Julia Discourse thread 'Method Invalidations with CxxWrap + CUDA' (Oct 13, 2026, zero replies at scouting): loading CxxWrap with CUDA leaves about 2,000 invalidations after the author removed about 1,000 of their own; a SnoopCompile tree shows CxxWrap src/StdLib/StdString.jl nextind at 1,931 invalidations (40.1%) and src/CxxWrap.jl Integer at 1,110 (23.05%); a PrecompileTools module wrapping both loads in @recompile_invalidations then fails to precompile with an LLVM 'invalid instruction mnemonic' report on an inline-asm exit line and ProcessSignaled(11), on Julia 1.13. Source: https://discourse.julialang.org/t/method-invalidations-with-cxxwrap-cuda/140011