[maleadt]

tforeach calls tmapreduce(...; kwargs..., init = nothing, outputtype = Nothing). Passed through keyword arguments, Nothing is stored in the keyword NamedTuple as a DataType, so _tmapreduce gets compiled with OutputType unknown: for every output type at once. A scheduler implementation that branches on OutputType === Nothing then compiles its reduction path for every tforeach body too.

tforeach now calls a positional entry point, tmapreduce_positional, which tmapreduce shares, with Nothing as a constant. Behaviour doesn't change: tforeach still ignores init and outputtype.

With ThreadTeams.jl's team scheduler this takes a new loop body's first tforeach from about 100 to 80 ms of compilation.

This also fixes ThreadTeams.jl's Enzyme tests on Julia ≥ 1.12, which 0.8.8 broke (a CallingConventionMismatchError in its Enzyme rule for run_chunks; they pass with this PR).

[codecov-commenter]

⚠️ Please install the to ensure uploads and comments are reliably processed by Codecov.

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 92.86%. Comparing base (cba9127) to head (f0e43eb).
⚠️ Report is 162 commits behind head on master.
❗ Your organization needs to install the Codecov GitHub app to enable full functionality.

Additional details and impacted files

@@            Coverage Diff             @@
##           master     #177      +/-   ##
==========================================
+ Coverage   90.24%   92.86%   +2.62%     
==========================================
  Files           3        9       +6     
  Lines          82      729     +647     
==========================================
+ Hits           74      677     +603     
- Misses          8       52      +44     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[MasonProtter]

So one potential side-effect of this is that it slows down the serial fallback path when T is runtime resolved, because it introduces a dispatch layer that was previously skipped.

e.g. here's what I see

using OhMyThreads, BenchmarkTools
tref = Ref{DataType}(Float64)   # concrete type; the value is only known at run time
xs1 = 1:1; xs = 1:1000

@benchmark tmapreduce(sin, +, $xs1; outputtype = $tref[])   # serial, run-time T
@benchmark tmapreduce(sin, +, $xs;  outputtype = $tref[])   # parallel, run-time T
@benchmark tmapreduce(sin, +, $xs;  outputtype = Float64)   # parallel, literal T

┌──────────────────────┬────────────────────┬──────────────────────────┬───────────────────┐
│                      │       master       │         PR #177          │     PR + fix      │
├──────────────────────┼────────────────────┼──────────────────────────┼───────────────────┤
│ serial, run-time T   │ 11.8 ns, 1 alloc   │ 807 ns, 5 allocs (240 B) │ 11.8 ns, 1 alloc  │
├──────────────────────┼────────────────────┼──────────────────────────┼───────────────────┤
│ parallel, run-time T │ 11.1 µs, 33 allocs │ 12.8 µs, 37 allocs       │ 9.9 µs, 33 allocs │
├──────────────────────┼────────────────────┼──────────────────────────┼───────────────────┤
│ parallel, literal T  │ 10.2 µs, 30 allocs │ 9.8 µs, 30 allocs        │ 9.6 µs, 30 allocs │
└──────────────────────┴────────────────────┴──────────────────────────┴───────────────────┘

the PR + fix line is a potential workaround Claude suggested

@inline function tmapreduce_positional(f::F, op::OP, Arrs, outputtype::Type,
        scheduler, init, kwargs) where {F, OP}
    # ... scheduler setup, checks, serial fallback: unchanged ...
    else
        _tmapreduce_typed(f, op, Arrs, outputtype, _scheduler, mapreduce_kwargs)
    end
end

# function barrier: only the parallel path depends on the output type
@noinline function _tmapreduce_typed(f::F, op::OP, Arrs, ::Type{OutputType}, scheduler,
        mapreduce_kwargs) where {F, OP, OutputType}
    return _tmapreduce(f, op, Arrs, OutputType, scheduler, mapreduce_kwargs)
end

[maleadt]

So one potential side-effect of this is that it slows down the serial fallback path when T is runtime resolved, because it introduces a dispatch layer that was previously skipped.

Thanks, reproduced (6 ns → 470 ns). _tmapreduce already specializes on the output type, so it's enough to drop the type parameter from tmapreduce_positional without adding another barrier. I pushed a fix, the serial case is back to 6 ns, and tforeach still passes Nothing as a constant.