Skip to content

Run PRK and PDIRK stages serially inside another threaded region - #4940

Open
singhharsh1708 wants to merge 6 commits into
SciML:masterfrom
singhharsh1708:core-threaded-nested
Open

singhharsh1708 wants to merge 6 commits into
SciML:masterfrom
singhharsh1708:core-threaded-nested

Conversation

@singhharsh1708

@singhharsh1708 singhharsh1708 commented Oct 27, 2026 •

Copy link
Copy Markdown
Member

KuttaPRK2p5 and PDIRK44, which default to threading = true, now run their stages serially when the solve is already inside a threaded region, instead of throwing "@threads :static cannot be used concurrently or nested". OrdinaryDiffEqCore's _threaded_execute gets the same jl_in_threaded_region check that #4929 adds to the extrapolation methods' own helper.

Called from inside Threads.@threads (:static or :dynamic), both methods throw on master, in place and out of place; here they run and give the same u as the serial solve. The new PRK testset fails on master with 1 and with 4 threads and passes here. Core QA, PRK Core and PDIRK Core pass. PDIRK has no [sources], so its tests use the registered Core and are not a test of this change; I checked it with a local environment instead.

OrdinaryDiffEqCore goes to 4.20.2, the same version as #4921, #4931 and #4932.

Risk assessment

  • Risk: medium-low (ML2: a fallback in OrdinaryDiffEqCore's _threaded_execute, taken only when the solve is already inside a threaded region, where it threw before).
  • Blast radius: KuttaPRK2p5 and PDIRK44 with threading = true (their default), the only callers of _threaded_execute; outside a threaded region they still use @threads :static. No public API change; Core goes to 4.20.2.
  • Evidence: both methods throw on master inside Threads.@threads (:static and :dynamic), in place and out of place; here they match the serial u. The new PRK testset fails on master at 1 and 4 threads and passes here; Core QA, PRK Core and PDIRK Core pass. The remaining red checks also fail on master.
  • Independent review: Antigravity CLI 1.5.10 (model gemini-4-carbon-high) rated it medium-low (ML8), unknown confidence: MERGE with no blocking findings (Run PRK and PDIRK stages serially inside another threaded region #4940 (comment))

AI Disclosure: Claude assisted with this change.

@singhharsh1708

Copy link
Copy Markdown
Member Author

🤖 Automated comment from an AI agent running as @singhharsh1708, not written or reviewed by the account holder.

Independent review (Codex CLI 0.163.0, model gpt-6.1-sol, reasoning effort high): CHANGES, risk medium-low (ML8). Reviewed head: 09cfafa8548872f2a59e76007bbfe17a4aeee2e1.

Full review

VERDICT: CHANGES
PR: #4940
Round: 1
Head: 09cfafa
Base: 45ff46a
Slot: 1
Reviewer: Codex CLI 0.163.0 / gpt-6.1-sol
Session: 01a19787-ffa7-7413-b9bf-f4f65b834d22
Reviewed: 2026-11-01T14:42:19Z
Summary: The PR serializes internally threaded work when another threaded region is active, fixing the reproduced PRK exception. Targeted PRK and PDIRK checks pass, but the regression is disconnected from CI and the implementation introduces a non-public runtime dependency.

Risk

medium-low (ML8: changes a shared threading helper; targeted runs establish preserved results and reproduce the original exception.)

Risk assessment

  • Risk: medium-low (ML8: shared threading behavior changes, with successful manual regression and equivalence checks.)
  • Blast radius: Bool/BaseThreads execution through Core’s @threaded, including PRK, PDIRK, optional threaded SDC, and AdaptiveRadau stepping/interpolation work.
  • Evidence: Changed PRK test passes all six assertions on head and errors on the copied base test. An additional PDIRK probe passes 17 checks. Seven CI jobs fail; six failure signatures match captured master failures.
  • Verdict: CHANGES
  • Round: 1
  • Blocking priorities: P2
  • Merge: needs changes (connect regression coverage to CI and remove the non-public runtime dependency)

Blocking findings

  1. [P2] Wire the new regression into the test target - confirmed by running. At lib/OrdinaryDiffEqPRK/test/prk_convergence.jl:21, the new test is added to a file that lib/OrdinaryDiffEqPRK/test/runtests.jl never includes; repository-wide searches found no other inclusion. Additionally, directly including it in the declared test environment exits before assertions with ArgumentError: Package ODEProblemLibrary not found in current path. Thus the green PRK CI jobs do not protect this threading fix. Include this file and declare its missing test dependency, or move the regression into an included test file. The regression itself works when its environment is repaired temporarily.

  2. [P2] Avoid the undocumented Julia runtime entry point - suspected from reading. lib/OrdinaryDiffEqCore/src/misc_utils.jl:127 directly calls jl_in_threaded_region. This is an undocumented runtime C symbol, absent from the installed public headers, rather than a supported public threading API. It violates the review’s public-API requirement; passing on Julia 1.13.1 does not establish a compatibility contract. Implement the behavior through documented nestable scheduling, such as Threads.@threads :dynamic, or obtain a public detection API upstream. Julia documents both its public API boundary and thread scheduling options.

Non-blocking findings

None.

What I ran

Commands below substitute $JRUN, $BASE_WORKTREE, and $PROBE for the supplied runner, supplied base checkout, and temporary PDIRK probe respectively. All Julia processes ran sequentially through the supplied wrapper: Julia 1.13.1, four Julia threads, one OpenBLAS thread, isolated temporary directories.

  • Git inspection, exit 0:

    git rev-parse HEAD
    git merge-base origin/master HEAD
    git diff origin/master...HEAD
    git log -1 --format=%B
    git diff --check
    git status --short

    Head and merge-base matched the requested SHAs. Head remained clean; no source files changed. The commit has no agent trailers.

  • Initial head test, exit 1:

    "$JRUN" --project=lib/OrdinaryDiffEqPRK -e 'using TestEnv; TestEnv.activate(); using Test, SafeTestsets; println("Julia ", VERSION); include("lib/OrdinaryDiffEqPRK/test/prk_convergence.jl")'

    Tail: ArgumentError: Package ODEProblemLibrary not found in current path.

  • Corrected temporary test environment, run identically from head and base:

    "$JRUN" --project=lib/OrdinaryDiffEqPRK -e 'using TestEnv; TestEnv.activate(); using Pkg; Pkg.add("ODEProblemLibrary"); using Test, SafeTestsets; println("Julia ", VERSION); import OrdinaryDiffEqCore; println("Core version ", pkgversion(OrdinaryDiffEqCore)); include("lib/OrdinaryDiffEqPRK/test/prk_convergence.jl")'

    Head: exit 0, Core 4.19.1:

    Explicit Solver Convergence Tests (out-of-place) | 2 passed
    Explicit Solver Convergence Tests (in-place)     | 2 passed
    Threaded stages inside another threaded loop    | 2 passed
    

    Before the base run, I copied the PR’s changed test into the supplied merge-base worktree and verified identical contents:

    cp lib/OrdinaryDiffEqPRK/test/prk_convergence.jl "$BASE_WORKTREE/lib/OrdinaryDiffEqPRK/test/prk_convergence.jl"
    cmp lib/OrdinaryDiffEqPRK/test/prk_convergence.jl "$BASE_WORKTREE/lib/OrdinaryDiffEqPRK/test/prk_convergence.jl"

    Both commands exited 0. Base test: exit 1, Core 4.19.0:

    Existing convergence assertions: 4 passed
    nested task error: `@threads :static` cannot be used concurrently or nested
    Threaded stages inside another threaded loop | 1 errored
    
  • Additional head probe, exit 0:

    "$JRUN" --project=lib/OrdinaryDiffEqPRK "$PROBE"

    The probe developed local PDIRK into a temporary TestEnv environment and asserted that local head Core loaded. It checked in-place/out-of-place problems, true/BaseThreads(), static/dynamic outer loops, exact serial equivalence, successful return codes, and convergence against exp(-1).

    PDIRK nested execution            | 16 passed
    convergence orders = [3.8663143999829117, 3.930599369225435]
    PDIRK nested analytic convergence | 1 passed
    
  • Inspected supplied CI results and failure excerpts for PR sublibraries, PR downstream tests, and PR main tests. Compared against master sublibraries, master downstream tests, and master main tests.

    Matching signatures cover SciMLSensitivity Core2/Core4, AD tape recording, both GPU deprecation-warning failures, and NonlinearSolve’s Newton line-search exception. ModelingToolkit InterfaceI’s reversed-equation assertion has no matching failure in the supplied master excerpts; its attribution remains unresolved.

What I did not verify

  • Julia 1.10 or other platforms locally.
  • Nested FIRK/AdaptiveRadau and SDC execution, or Polyester execution.
  • GPU, additional AD, MPI, package-wide, or heavy downstream suites.
  • The cause of the unmatched ModelingToolkit CI failure.

AUTHOR_GRADE: {"task":"bugfix","score":3,"difficulty":2,"rounds":1,"author_harness":"unknown","author_model":"unknown","note":"The small threading fix passes targeted PRK and PDIRK checks, and the copied regression fails on base. Substantive repairs remain because the regression is disconnected from CI and the implementation relies on a non-public runtime symbol."}


🤖 Posted by an AI agent · harness: Claude Code · model: claude-opus-5-5 (coordinating gpt-6.1-sol reviewers)
Review: unreviewed
Session: 01a19787-ffa7-7413-b9bf-f4f65b834d22

@ChrisRackauckas

Copy link
Copy Markdown
Member

🤖 Automated comment from an AI agent running as @ChrisRackauckas — not written or reviewed by Chris.

PR: #4940

Reviewed head: 1c61b6f
Raw SHA-256: 89e5908a1010cec3b39a21fa8c36c185afb425f7efe34b0106f176c6da383cbb
Source SHA-256: a41c90541d4e18d23b07c33f8de2f2999db04030d8358847f38c0500e40f3160
Source: standard-review-v1 (harness-log)
Reviewer session: 01a1d257-53e3-7382-ac1e-956a412a6a16
Slot: 1
Confidence: unknown
Own risk fixed before author rating/discussion: yes

Risk assessment

  • Risk: medium-low (ML8)
  • Verdict: CHANGES
  • Reviewed head: 1c61b6f

Review report

VERDICT: CHANGES
Round: 1
Head: 1c61b6f
Slot: 1
CI: CI is not green (regress:SciMLSensitivity.jl/Core4/1 / Downstream Tests - Core4)
Session: 01a1d257-53e3-7382-ac1e-956a412a6a16

Risk

medium-low (ML8: changes shared stage-threading execution for PRK, PDIRK and optional FIRK/SDC paths; adds a nested-threading regression test, but runtime verification is outstanding).

Blocking findings

  • Verdict: CHANGES
  • Round: 1
  • Blocking priorities: P2, P2
  • Deferred P2 issues: None supplied.

This is a needs-verification verdict. No numerical regression or other code correctness failure was confirmed by running.

  1. [P2] Required runtime evidence is unavailable — lib/OrdinaryDiffEqCore/src/misc_utils.jl:127 and lib/OrdinaryDiffEqPRK/test/runtests.jl:26. The affected suite and targeted probes could not start within the supplied resource limits. Consequently, I did not establish that the added test fails with the original helper and passes with this change, or that the fallback preserves analytic accuracy. Run the PRK functional/QA suite and the baseline, scheduling, exception and analytic-convergence probes before accepting this review. This is a verification gap, not a reproduced defect in the implementation.

  2. [P2] Reported downstream regression remains unresolved — .github/workflows/Downstream.yml:23. The supplied CI status identifies SciMLSensitivity/Core4 as a regression. I did not retrieve CI logs or reproduce it under this blind review's input restrictions, so I cannot attribute it to this diff or establish that it is pre-existing. The owning head must resolve it or provide a matching clean-default-branch comparison. Filing a deferred issue alone does not establish the required absence of test regressions.

Non-blocking findings

None identified from static inspection. The new equality assertion checks scheduling equivalence; no numerical formulas or existing assertions are changed.

What I ran

AI reviewer: codex-cli 0.164.0, model gpt-6.1-sol. The Session field gives the actual local session ID; no conversation URL is available.

  • git diff origin/master...HEAD, surrounding implementations, affected tests and repository test configuration; git diff --check origin/master...HEAD exited 0. Final git status --short was empty and HEAD matched the requested SHA. Neither root AGENTS.md nor root CLAUDE.md exists in this checkout; I used the supplied instructions.
  • git log -1 --format='%B': the newest commit contains no Agent-Harness or Agent-Model trailers, so both author attribution fields below are unknown.
  • julia --version: julia version 1.13.2.
  • uv run --locked python --version: Python 3.15.0, with the warning that --locked has no effect outside a project. No project-locked Python environment was verified.
  • A resource gate sampled Julia process trees, MemAvailable and /proc/loadavg, requiring fewer than five Julia roots, at least 16 GiB available memory and load below 32. It exited 75 after 3604 seconds, without launching Julia tests: Verification unavailable: resource limits did not permit a Julia test worker within one hour. The runtime's layered JULIA_DEPOT_PATH was preserved.

What I did not verify

The PRK functional and QA suites, existing convergence tests, and prepared targeted probes were not executed. Those probes cover both state representations, Bool/BaseThreads options, nested static/dynamic loops, exceptions, analytic fifth-order convergence, and the added regression test with the original helper restored only in memory. Dependency instantiation also remained unexecuted. I did not verify SciMLSensitivity/Core4 against the default branch, other supported Julia versions, or a locked dependency environment. Scratch preparation did not modify the checkout. No PR body, discussion, author rating or earlier review was inspected.

AUTHOR_GRADE: {"task":"bugfix","score":3,"difficulty":2,"rounds":1,"author_harness":"unknown","author_model":"unknown","note":"The diff is focused and adds a nested-threading regression test. Runtime correctness and failing-before/passing-after evidence were not verified because resource admission failed for one hour; the supplied downstream CI regression remains unresolved."}

Head link: 1c61b6f


🤖 Posted by an AI agent — harness: codex-cli 0.164.0 · model: gpt-6.1-sol
Conversation: local session 01a1d257-53e3-7382-ac1e-956a412a6a16 (no session URL)

@singhharsh1708

Copy link
Copy Markdown
Member Author

The jl_in_threaded_region point is the one answered earlier in this thread, nothing new there. Core4 has been green on master since 11-04 and that run predates it, so I merged master to re-run.

@ChrisRackauckas

Copy link
Copy Markdown
Member

🤖 Automated comment from an AI agent running as @ChrisRackauckas — not written or reviewed by Chris.

@singhharsh1708 The PR body has no risk assessment. Please add this block, filled in for this change, so the review at 58f1a5a1 can be rated:

## Risk assessment
- **Risk:** low | medium-low | medium | medium-high | high (<criterion ID>: <why>)
- **Blast radius:** code paths touched, public API or not, downstream packages
- **Evidence:** failing-before/passing-after test output, CI runs

Criteria: risk policy. The remaining red checks on this head also fail on the base branch (AD, GPU, Core and ProbNumDiffEq), so they do not block the review.


🤖 Posted by an AI agent — harness: Claude Code 2.1.325 · model: claude-sonnet-5-5
Conversation: local session 3878b54e-28f2-4a01-a176-a8f5468d1997 (no session URL)

@ChrisRackauckas

Copy link
Copy Markdown
Member

🤖 Automated comment from an AI agent running as @ChrisRackauckas — not written or reviewed by Chris.

PR: #4940

Reviewed head: 58f1a5a
Raw SHA-256: 1955a5aae8cbd4e43faff12e406c4190baf81230d95f66bbe2d1e5aa08628e27
Source SHA-256: 5fc157a62d0e214118075172262690209c79b0c1eacafea058ba49f4fc2273ae
Source: standard-review-v1 (harness-log)
Reviewer session: f4bb9bb3-5d94-42ba-a74e-9b38e6d7bacb
Slot: 1
Confidence: unknown
Own risk fixed before author rating/discussion: yes
Redaction: ran (substitutions=0)

Risk assessment

  • Risk: medium-low (ML8)
  • Verdict: MERGE
  • Reviewed head: 58f1a5a

Review report

VERDICT: MERGE
Round: 5
Head: 58f1a5a
Slot: 1
CI: CI unreadable; review only; merge gates unchanged
Session: f4bb9bb3-5d94-42ba-a74e-9b38e6d7bacb
Reviewer: Antigravity CLI 1.5.10; model: gemini-4-carbon-high

Risk

medium-low (ML8: shared stage-threading helper in OrdinaryDiffEqCore falls back to serial foreach when jl_in_threaded_region != 0, affecting peripheral parallel-stage solvers KuttaPRK2p5, PDIRK44, and opt-in SDC/AdaptiveRadau while leaving main-lane solvers and top-level numerical results bit-for-bit unchanged; includes a failing-before nested-threading regression test)

Blocking findings

None. The delta since 1c61b6f1325634cc5a22a8cb0bd8a02b48b8f2b8 consists solely of clean merges of upstream/master (d8632e680 and 58f1a5a1d), leaving the three-file PR diff against origin/master (928fe0f60e43efbffd249fb22ecb99aebe2be9fd) identical. Both prior Round 1 blockers are addressed so far as code and local execution can establish: the affected functional, convergence, QA, cross-subpackage, and negative-control checks now ran and passed on the build host, while the earlier head's CI status is superseded by two upstream/master merges and the current head's supplied CI unreadable; review only; merge gates unchanged status (merge gates still enforce final-head CI separately).

  • Blocking priorities: none

Non-blocking findings

  1. Concurrent Threads.@spawn solves outside a @threads region can still race into Threads.@threads :static — lib/OrdinaryDiffEqCore/src/misc_utils.jl:127-131 (confirmed by running).
    • Observed evidence: Threads.@spawn does not call jl_enter_threaded_region, so ccall(:jl_in_threaded_region, Cint, ()) remains 0 until one task enters Threads.@threads :static. Launching 8 concurrent Threads.@spawn solve(prob, KuttaPRK2p5(threading = true); dt = 0.005) tasks outside any @threads block reproduced TaskFailedException wrapping `@threads :static` cannot be used concurrently or nested at lib/OrdinaryDiffEqCore/src/misc_utils.jl:131 (scratch/spawn_detail.log), when two tasks both observed jl_in_threaded_region == 0 at line 127 before either entered threading_run. This behavior is pre-existing on origin/master (not a regression) and outside the PR's nested-@threads / EnsembleThreads() scope, where the outer @threads holds jl_in_threaded_region != 0 across all iterations.
    • Suggested fix: Every caller of OrdinaryDiffEqCore.@threaded (OrdinaryDiffEqPRK, OrdinaryDiffEqPDIRK, OrdinaryDiffEqSDC, OrdinaryDiffEqFIRK) indexes stage buffers by loop variable rather than Threads.threadid() (unlike OrdinaryDiffEqExtrapolation's separate _threaded_foreach). Switching Threads.@threads :static to Threads.@threads :dynamic in _threaded_execute (optionally retaining the foreach fast path when already inside a threaded region) would also make concurrent Threads.@spawn callers safe without relying on C runtime internals.

What I ran

Reviewed independently on the build host without reading the PR body, comments, author risk rating, or sibling reviews. Neither AGENTS.md nor CLAUDE.md exists in the repository checkout. All runs preserved the supplied layered JULIA_DEPOT_PATH, exported the job-local TMPDIR, ran inside memory-capped user scopes (JULIA_NUM_THREADS=4, JULIA_NUM_PRECOMPILE_TASKS=4, OPENBLAS_NUM_THREADS=1), and kept scratch environments/logs under scratch/.

  • Git, formatting, and spelling checks:
    • git diff origin/master...HEAD, git diff --check origin/master...HEAD (exit 0), and comparison of git diff <merge-base>..1c61b6f13 vs git diff <merge-base>..HEAD (identical 3-file diff: lib/OrdinaryDiffEqCore/Project.toml, lib/OrdinaryDiffEqCore/src/misc_utils.jl, lib/OrdinaryDiffEqPRK/test/runtests.jl). git log -1 --format='%B' HEAD contains no Agent-Harness or Agent-Model trailers.
    • typos lib/OrdinaryDiffEqCore/Project.toml lib/OrdinaryDiffEqCore/src/misc_utils.jl lib/OrdinaryDiffEqPRK/test/runtests.jl: exit 0.
    • JULIA_NUM_THREADS=1 julia --startup-file=no --project=@runic -m Runic --check lib/OrdinaryDiffEqCore/src/misc_utils.jl lib/OrdinaryDiffEqPRK/test/runtests.jl: exit 0.
    • Final git status --porcelain=v1 is empty.
  • Interpreters:
    • uv run --locked python --version: Python 3.15.0 (with warning: --locked has no effect when used outside of a project; no uv.lock or Python project exists in the checkout).
    • julia --version: julia version 1.13.2 (also probed 1.10.12 via +lts and 1.12.7 via +1.12).
  • C runtime symbol contract across Julia versions (scratch/lts_probe.log):
    • julia +lts --startup-file=no -t 4 scratch/lts_and_1thread_probe.jl (1.10.12), julia +1.12 --startup-file=no -t 4 ... (1.12.7), and julia --startup-file=no -t 1 ... (1.13.2): 3/3 passed on each runtime (ccall(:jl_in_threaded_region, Cint, ()) is 0 outside @threads, 1 inside @threads even with 1 thread, and restored to 0 afterwards).
  • Functional, convergence, cross-subpackage, and edge-case suite (scratch/setup_and_test.log):
    • Created an isolated scratch environment (scratch/env_suite) developing this checkout's OrdinaryDiffEqCore (4.20.2), OrdinaryDiffEqPRK (2.4.0), OrdinaryDiffEqPDIRK (2.5.4), OrdinaryDiffEqSDC (1.0.0), OrdinaryDiffEqFIRK (2.8.9), OrdinaryDiffEqNonlinearSolve (2.9.10), OrdinaryDiffEqDifferentiation (3.13.0), DiffEqBase (7.21.7), and DiffEqDevTools (3.6.3) with SciMLBase (3.58.0), ODEProblemLibrary (1.5.5), Polyester (0.7.19), AllocCheck (0.2.8), Aqua (0.8.19), JET (0.12.3), and SciMLTesting (2.13.3).
    • julia --startup-file=no scratch/setup_and_test.jl (JULIA_NUM_THREADS=4): 197/197 passed (50.0 s):
      • lib/OrdinaryDiffEqPRK/test/runtests.jl functional testsets (SciMLBase reexport and Threaded stages inside another threaded loop): 4/4 passed.
      • lib/OrdinaryDiffEqPRK/test/prk_convergence.jl (KuttaPRK2p5 OOP/IIP fifth-order convergence): 4/4 passed.
      • Coupled 2D and scalar analytic problems solved with KuttaPRK2p5 (threading = true, BaseThreads(), PolyesterThreads()) inside :default, :dynamic, :static, :greedy, and 3-level nested Threads.@threads loops: bitwise identical to threading = false and fifth-order convergence (𝒪est[:l∞] ≈ 5.0, atol = 0.1) confirmed inside nested @threads: 74/74 passed.
      • SciMLBase.EnsembleThreads() (16 trajectories) with KuttaPRK2p5(threading = true) and BaseThreads(): bitwise match with threading = false and error bounded by derived $\mathcal{O}((\lambda \Delta t)^5)$ truncation bound: 66/66 passed. (Initial probe iterations failed only on EnsembleContext/EnsembleSolution indexing and an overly tight constant before applying $\max_{\lambda&gt;0} \lambda e^{-\lambda} = e^{-1}$; preserved in scratch/setup_and_test_initial.log–v5.log.)
      • Other subpackage callers of OrdinaryDiffEqCore._threaded_execute (PDIRK44, SDC with SDCSweeper.MIN_SR_S, and AdaptiveRadau) inside nested Threads.@threads: 30/30 passed.
      • Direct _threaded_execute empty/singleton ranges, stage-exception propagation without leaking jl_in_threaded_region, and 0-byte allocation check on the nested foreach fallback: 19/19 passed.
    • Single-thread check (JULIA_NUM_THREADS=1, scratch/single_thread.log): 3/3 passed (2.7 s).
  • Negative control (scratch/negative_control.log):
    • Restored origin/master's _threaded_execute in memory via Core.eval without touching the checkout: 12/12 assertions passed (8.8 s), confirming that KuttaPRK2p5 (IIP and OOP), EnsembleThreads(), PDIRK44, SDC, and AdaptiveRadau all fail before this change with `@threads :static` cannot be used concurrently or nested.
  • QA suites (scratch/setup_and_test.log, scratch/core_qa.log):
    • OrdinaryDiffEqPRK QA (lib/OrdinaryDiffEqPRK/test/qa/{allocation_tests,qa,jet}.jl): 20/20 Aqua & ExplicitImports passed, 1/1 JET passed, 1/1 AllocCheck broken (as declared in the test).
    • OrdinaryDiffEqCore JET (lib/OrdinaryDiffEqCore/test/qa/jet.jl): 30/31 passed, 1/31 broken (as declared).
    • OrdinaryDiffEqCore isolated QA (scratch/env_core_qa, matching lib/OrdinaryDiffEqCore/test/qa/Project.toml): 26/26 AllocCheck, Aqua & ExplicitImports passed (13.3 s). (When SparseArrays was co-loaded in env_suite, ExplicitImports flagged pre-existing internal imports in untouched OrdinaryDiffEqCoreSparseArraysExt.)

What I did not verify

Live CI and downstream SciMLSensitivity.jl/Core4 runs on 58f1a5a1dfe66592e1e990de284600cbb54328e2 (preflight reported CI unreadable; review only; merge gates unchanged, and blind-review rules prohibit external CI fetches; merge gates remain unchanged). Full monorepo OrdinaryDiffEq test groups, downgrade workflows, and non-Linux platforms were not run. The checkout contains no Manifest.toml or uv.lock, so no repository-locked Julia or Python environment exists to verify. No commits, pushes, checkout edits, or GitHub actions were performed.

AUTHOR_GRADE: {"task": "bugfix", "score": 5, "difficulty": 2, "rounds": 5, "author_harness": "unknown", "author_model": "unknown", "note": "Minimal, well-targeted fix in OrdinaryDiffEqCore._threaded_execute with a regression test wired into OrdinaryDiffEqPRK/test/runtests.jl and clean upstream/master merges. Confirmed failing before and passing after across PRK, PDIRK, SDC, FIRK, EnsembleThreads, QA suites, and Julia 1.10/1.12/1.13."}

Head link: 58f1a5a


🤖 Posted by an AI agent — harness: Antigravity CLI 1.5.10 · model: gemini-4-carbon-high
Conversation: local session f4bb9bb3-5d94-42ba-a74e-9b38e6d7bacb (no session URL)

This branch has not been deployed

No deployments
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.

2 participants