Module_ComputingContext

Location: Home / ComputingContext module

ComputingContext module — ComputingContext

Lightweight CPU execution policy for choosing scalar, SIMD, or parallel implementations per call or code block without global mutable state. Covers FFT, statistics, linear algebra, batch deep learning, MFCC/audio frontends, and training entry points (see “Integrated APIs” below).

No GPU: ComputingContext schedules CPU work only (scalar / SIMD / multithreaded). The main package has dropped built-in CUDA/ILGPU; see GPU policy.

Namespace: Vorcyc.Mathematics

---

Core types

Type	Description
ComputingContext	Immutable execution policy (Normal / Simd / Parallel / Auto)
ComputingScope	AsyncLocal scope; using (ComputingScope.Enter(ctx)) { ... }
CpuExecutionMode	CPU mode enum
ComputingContextExecution	Parallel thresholds and worker-count helpers

Resolution order

explicit context parameter  >  ComputingContext.Current (scope)  >  Default

context: null means “unspecified” and follows the chain above — not forced scalar.

Presets

ComputingContext.Normal    // scalar
ComputingContext.Simd      // SIMD
ComputingContext.Parallel  // parallel (large data)
ComputingContext.Auto      // heuristic by problemSize
ComputingContext.Default   // process default (initially Auto)

Auto thresholds (elements / flop count): ≥1024 → SIMD, ≥16384 → Parallel (see ResolveCpuMode).

---

Usage

1. Default (no parameter)

signal.TransformToFrequencyDomain();
values.Sum();
var c = a * b;

2. Explicit per call

signal.TransformToFrequencyDomain(ComputingContext.Parallel, WindowType.Hamming);
FastFourierTransform.Forward(input, output, ComputingContext.Simd);
var sum = span.Sum(ComputingContext.Parallel);
var product = Matrix.Multiply(a, b, ComputingContext.Parallel);

3. Scope (multiple calls in a pipeline)

using (ComputingScope.Enter(ComputingContext.Parallel))
{
    var spec1 = s1.TransformToFrequencyDomain();
    var spec2 = s2.TransformToFrequencyDomain(ComputingContext.Simd); // single-call override
    var mean = buffer.Average(); // uses Parallel from scope
}

4. Configure process default

ComputingContext.ConfigureDefault(ComputingContext.Auto);

---

Integrated APIs

Signal processing

• ITimeDomainSignal.TransformToFrequencyDomain(ComputingContext?, WindowType?)
• FastFourierTransform.Forward / Inverse(..., ComputingContext?) (real/complex span and array overloads)
• TimeDomainCharacteristicOps.GetRms / GetAmplitude / GetAveragePower / ...
• ISingleThreadTimeDomainSignal.GetRms(context) and related extensions (bypass cached properties)

Statistics

• Basic.Sum / Average / Variance / StandardDeviation (Span<float/double> and generic floating-point)
• IComparableExtension.CompareMax / CompareMin

Linear algebra

• Matrix.Multiply(a, b, context), Matrix<T>.Multiply(...)
• Matrix.Multiply(vector, result, context)
• VectorSpan.Dot / Sum / Norm / Add / Subtract / Axpy / Scale(..., context)

Scope resolution (Phase 2 fix)

APIs that accept ComputingContext? context call ComputingContext.Resolve(null) when context == null, so ComputingScope applies even when null is passed explicitly (consistent with the resolution order above). Legacy overloads without a context parameter are unchanged.

Tensor statistics

• TensorStatistics.MeanAlongAxis / StandardDeviationAlongAxis / NormalizeAlongAxis / MeanAlongDepth (optional context)
• Basic.WeightedAverage(values, weights, context) (generic floating-point)

Deep learning (Phase 3–4)

• ComputingContextExecution.ForEach — batch-dimension / index parallel scheduling
• BatchConv2DMath.Forward, BatchMaxPool2DMath.Forward, BatchFullyConnectedLayer, BatchDepthwiseConvolution2DLayer forward (reads ComputingScope / Resolve)
• BatchConv2DIm2Col.Forward — im2col + TensorOps.GemmTransposeRight(..., context)
• Trainer.Fit / FitBatched / FitBatchSequential / FitBatchParallelConcat / FitCnnMlp optional computingContext parameter
• MlpTrainingOptions.ComputingContext
• Legacy single-sample layers Layers.Conv2D / Dense / LinearLayer / MaxPool2D / ReLU / Sigmoid / BatchNorm / JoinLayer / Fusion — channel-dimension ForEachDepth (respects ComputingScope)

Tensor GEMM (Phase 4)

• TensorOps.GemmTransposeRight(..., ComputingContext?) — im2col convolution GEMM row parallelism

Feature extraction / MFCC pipeline (Phase 4+)

• FeatureExtractor.ParallelChunksComputeFrom / ParallelComputeFrom(..., ComputingContext?) — thread count and chunked parallelism
• MfccExtractor and subclasses via ParallelComputeFrom(samples, context: ComputingContext.Parallel) or outer ComputingScope for unified policy

CNN + audio frontend (Phase 4+)

• Trainer.FitCnnMlp(..., computingContext) — same scope installation as FitBatched
• BatchPreEmphasisLayer / BatchStftMagnitudeLayer / BatchMelFilterbankLayer — batch-dimension ForEach (STFT parallelism uses per-thread Stft instances)
• BatchNormLayer / BatchBatchNormLayer — channel parallelism (for large data)

// Offline MFCC features
using (ComputingScope.Enter(ComputingContext.Parallel))
    var mfcc = extractor.ParallelComputeFrom(samples);

// CNN + Mel frontend training
trainer.FitCnnMlp(model, loss, opt, batches, epochs, computingContext: ComputingContext.Parallel);

---

Migration: FftVersion (obsolete)

The following APIs are marked [Obsolete]; migrate to ComputingContext:

Legacy API	New API
FftVersion.SIMD	ComputingContext.Simd
FftVersion.Parallel	ComputingContext.Parallel
FftVersion.Normal	ComputingContext.Normal
TransformToFrequencyDomain(window, fftVersion)	TransformToFrequencyDomain(context, window)
FastFourierTransform.Version = ...	ComputingScope.Enter(...) or per-call context

Pointer-based FFT overloads without a context parameter still use the global Version delegate; prefer span/array overloads in new code.

---

Parallel thresholds (ComputingContextExecution)

Constant	Value	Use
ParallelReductionThreshold	65536	Sum, variance, dot product, etc.
ParallelMatrixMultiplyThreshold	262144	Matrix multiply

---

APIs that do not read ComputingContext (intentional)

• Cached properties such as Signal.Rms / Amplitude — fixed SIMD path; use GetRms(context) etc. for policy-aware behavior
• Matrix operator *, parameterless values.Sum() — library default; use Multiply(..., context) / Sum(context) when needed

Not yet integrated (intentional or low ROI)

• Matrix decomposition (SVD / LU / QR) — no parallel hot spots
• RealOnlyFFT, overlap-add filters — single-threaded implementations
• Experimental.CurveFitting.NeuralNetwork — separate optimization path
• GPU / CUDA — not provided in the main package; see GPU policy
• Alignment with OptimizationMode (curve fitting)
• Removal of FftVersion and FastFourierTransform.Version

Note: Legacy APIs without a context parameter keep their previous behavior; only hot paths listed in this document read ComputingContext / ComputingScope.

---

Future hardware taxonomy (reserved)

The main package executes on CPU only today. These enums describe a future extension surface; they are not wired into ComputingContext yet.

ComputingBackend

Value	Meaning
CPU	Host processor (current default)
GPU	Graphics / compute GPU
FPGA	Field-programmable gate array
ASIC	Application-specific integrated circuit
TPU	Tensor processing unit
NPU	Neural processing unit

ComputingMethodPriority

Maps a backend choice to an execution style: Sequential_Normal, Sequential_SIMD, Parallel.

See GPU policy for why GPU is not shipped in the main NuGet package.

---

Verification and tests

Numerical equivalence across Normal / Parallel (and SIMD) paths is covered by tests:

Test project	Content
TESTS/core_module_test	ComputingContext_test: statistics, matrices, VectorSpan, FFT roundtrip, large-array parallelism
TESTS/DL_module_test	ComputingContext_equivalence_test: 27 forward/backward/training/MFCC/frontend-layer Normal vs Parallel cases

Run (Release):

dotnet run --project TESTS/core_module_test/core_module_test.csproj -c Release
dotnet run --project TESTS/DL_module_test/DL_module_test.csproj -c Release

Equivalence tolerances: forward/backward 1e-4; post-training inference 5e-3 (floating-point accumulation order differences).