[ellispatrick]

Part of a stack of 8 pull requests from the October 2026 audit of ClassifyR (AUDIT.md on branch audit-2026-10). Each part is based on the one before, so they need to be merged in order. Each one can be accepted, changed or rejected on its own merits. Draft PR #125 holds all eight together. Every part installs and passes its own tests.

Stack, merge in order: #126 tests and core fixes → #127 interface fixes → #128 metrics and plots → #129 pathways and criss-cross → #130 maintenance → #131 faster cross-validation (identical results) → #132 shared folds (changes results) → #133 release notes. The regression harness and timings are in SydneyBioX/ProjectClassifyR (private).

Summary

Faster cross-validation, with identical results: one pool of workers forked once per call, and faster classifier interfaces.

Why

On our 128-core server, students found ClassifyR often slower with more cores. Measurements located the causes in ClassifyR's machinery, not in the server or the models: pure R work scaled to 16× on 20 cores through the same BiocParallel.

• A new pool per run: every assay, classifier and combination started its own BiocParallel pool. Making a MulticoreParam costs a full gc() (about 0.5 s in a session with ClassifyR's dependencies): its worker check calls showConnections(), which runs gc().
• Forking: MulticoreParam, unless started with bpstart, forks a new process for every chunk of tasks. Each forked process copies much of the session's memory (about 0.5 GB with ClassifyR's dependencies) when R first collects garbage in it. Kernel time grew with the number of cores: devel used 85 s of kernel time on 32 cores for a 139 s job.
• Overhead around the models: DataFrame → data.frame conversion cost 0.2 s per call; model.matrix 0.15 s; the SVM formula interface 0.3 s; and Cox elastic net tuning by C-index called survival::concordance about 1000 times per fit.

What changes

• One pool per call:
  • runTests is split into preparing, running the splits, and assembling the result.
  • crossValidate prepares every assay, classifier and combination, then runs all splits in one BiocParallel pool: a MulticoreParam started once per call with bpstart() after the data are ready, so forked workers share the data and receive only task numbers; a SnowParam on Windows, sent the task once per worker.
  • Threads: BLAS and OpenMP are set to one thread in the main session before the workers start, and restored afterwards. OpenBLAS otherwise starts one thread per core (128 on our server) in every worker: PCA + GLM on 8 cores took 68.8 s with 128 BLAS threads per worker and 7.4 s with one. Workers forked after the session has used several OpenMP threads can hang (randomSurvivalForest on 8 cores never finished; now 4 s).
  • No parallel functions are used: random number streams per split come from BiocParallel (identical to before), and RhpcBLASctl replaces parallel in Imports.
  • Tasks are handed out in about eight chunks per worker as workers become free.
  • Each split sets the random stream bpmapply would have given it, so results don't depend on the number or kind of workers.
  • runTests still uses any BiocParallel parameters it is given.
• Interfaces:
  • .asDataFrame (the same data.frame, built directly);
  • numeric design matrices built directly (identical to model.matrix);
  • the SVM fitted to a matrix (the same model);
  • random forest vote shares counted per class;
  • fold models drop the importance-only forest.
• Cox elastic net: .cvCoxnetC reproduces cv.glmnet(type.measure = "C") (same folds, fits and lambda) with a vectorised C-index that matches survival::concordance bit for bit.
• Packaging: the stats and utils functions used are imported; the obsolete C++11 request is removed.

Do results change?

No. The regression harness (18 scenarios) gives results identical to part 5, apart from two differences in form only:

• leave-one-out rankings are numerically equal but stored with another type;
• the SVM's fitted model has class svm instead of svm.formula, with the same predictions.

Results are also identical between 1 and 20 cores, and between forked and socket workers (tested).

Evidence

Protocol procedures on verona, measured with parts 6 and 7 together, in a session with no thread settings:

Elapsed time, and speed-up against the same build on 1 core:

	1 core	8 cores	20 cores	32 cores
Procedure 1 (random forest, 100 × 5), devel	138.6 s	28.7 s (4.8×)	18.4 s (7.5×)	19.3 s (7.2×)
Procedure 1, this series	91.5 s	14.8 s (6.2×)	7.9 s (11.6×)	7.3 s (12.5×)
Procedure 2 step 4 (CoxNet, 7 views, 20 × 5), devel	624.1 s	113.3 s (5.5×)	64.0 s (9.7×)	55.9 s (11.2×)
Procedure 2 step 4, this series	178.1 s	25.3 s (7.0×)	12.3 s (14.4×)	10.6 s (16.8×)

A timeline of Procedure 1 on 20 cores showed workers waiting for the main process between small chunks of tasks; handing out about eight chunks per worker took it from 13.2 s to about 8 s. Pure R work reached 16× on 20 cores on this server, through BiocParallel or parallel alike, which is the ceiling.

472 tests pass.

Limits

Jobs of a few seconds still don't gain from many cores: forking and the memory copy cost about 0.5–1 s per worker. On a two-socket server, expect 10–16× on 20 cores rather than 20×.

🤖 Generated with Claude Code

https://claude.ai/code/session_01TfsjwkbDbHkX4kJZNe4ER4

[ellispatrick]

@DarioS: following your point that Bioconductor packages must use BiocParallel, this PR no longer uses the parallel package. The stack above it (#132–#144) is rebuilt on top, and each branch gained exactly this one commit.

• The pool is now a BiocParallel MulticoreParam, started once per call with bpstart(), with the task kept in .ClassifyRenvir so that only task numbers are sent. It is a SnowParam on Windows. The per-split RNG streams come from a serial bplapply with the cross-validation's RNGseed, which gives the same streams as before.
• New: BLAS and OpenMP run one thread in each worker (RhpcBLASctl). OpenBLAS starts one thread per core in every worker otherwise, so 8 workers ran 128 threads each on our server.
• Results: identical to the previous version of this branch in all 18 regression scenarios, at 1 and 8 cores. The tests pass on review/6, review/12, review/18 and integration.
• Cost: MulticoreParam() and bpstart() each run a full gc() through showConnections(), adding about 1 s per crossValidate call. That is BiocParallel's own cost.

The same helper went into spicyR, lisaClust and Statial: SydneyBioX/spicyR#81, SydneyBioX/lisaClust#17 and SydneyBioX/Statial#18.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Y1PuRkfDQ3ApzuNoe5ovxW

[DarioS]

O.K.