ZeroCompute.Core 1.3.0

ZeroCompute

ZeroCompute is a high-performance, dual-engine compute execution framework for .NET with zero external dependencies. It provides:

1. A CPU Parallel Compute Runtime that systematically exploits all 5 levels of CPU parallelism (Core, Cache Tiling, SIMD, Instruction-Level Parallelism, and Memory-Level Parallelism).
2. A Direct3D 11 GPU Compute Engine utilizing native COM VTable P/Invoke compute shaders for massive GPGPU acceleration without third-party C++ wrappers or external CUDA runtimes.

🌟 Architectural Highlights

Sequential For
    ↓
Level 1: Multi-Core / Task (Worker Pool, Sovereign Physical Core Pinning, Dynamic Chunk Stealing)
    ↓
Level 2: Cache-Aware Blocking (L1/L2 64x64 Tiling, 64-Byte Line Padding, Kernel Fusion)
    ↓
Level 3: SIMD Vectorization (SSE / AVX2 / AVX-512, Padé [5/5] Rational Approximations)
    ↓
Level 4: Instruction-Level Parallelism (4-Way Loop Unrolling, Multi-Accumulator Chains)
    ↓
Level 5: Memory-Level Parallelism (Line Fill Buffer Saturation, Prefetching & Streaming Stores)

• Axiom: Parallelism $\neq$ Performance: Never naively assumes more threads equals faster throughput. The ExecutionPlanner profiles arithmetic intensity ($I = \text{FLOPs}/\text{Byte}$), working-set cache sizing, and CPU microarchitecture to choose between Sequential, Single-Core SIMD, or Multi-Core Cache-Tiled execution.
• Sovereign Worker Pool (ComputeWorkerPool): Pre-spawned, background threads pinned to discrete physical cores via cross-platform affinity (Win32 SetThreadAffinityMask on Windows and libc sched_setaffinity on Linux with /proc/cpuinfo topology detection). SMT/Hyperthreading is selectively bypassed for compute-bound kernels to eliminate contention on shared FPU execution pipelines.
• Dynamic Lock-Free Chunk Stealing: Atomic chunk consumption balances heterogeneous architectures (e.g. Intel Alder Lake / Raptor Lake P-cores and E-cores) with zero task queue locking.
• Microsecond Dispatch Latency: Hybrid spin-wait barriers (10 spins $\to$ Thread.Yield() $\to$ private AutoResetEvent) achieve $1.85 \ \mu\text{s}$ dispatch latency ($2.0\times$ faster than standard .NET Parallel.For).
• SIMD Padé Rational Approximation: Vectorizes transcendental activations (GELU, Tanh) using a high-precision rational polynomial, converting scalar branching into pure SIMD FMA instructions ($5.99\times$ speedup).
• Cache-Aware 2D Tiling: $64 \times 64$ sub-matrix tiling ($16\text{ KB}$) ensures temporal working sets fit entirely inside private L1/L2 data caches ($4.18\times$ speedup on GEMM).
• NUMA-Node Awareness & Sovereign Memory Affinity: Dynamic multi-socket NUMA discovery (Windows GetNumaHighestNodeNumber / Linux /sys/devices/system/node) and node-local unmanaged memory allocation (VirtualAllocExNuma / Linux mmap) eliminating cross-socket QPI/UPI interconnect latency bottlenecks.
• Direct3D 11 GPGPU Acceleration: Seamless GPU offloading for massive tensor matrix operations via native DirectX 11 compute shaders.
• 100% Pure C#: Multi-targeting net8.0, netstandard2.0, and net462 with zero native DLL dependencies.

📦 Installation

dotnet add package ZeroCompute.Core

🚀 Developer API & Usage Examples

1. High-Performance CPU Parallel Loops (Compute.For)

Automatic cost-based execution planning and dynamic chunk stealing:

using ZeroCompute.Core.Cpu;

int n = 1_000_000;
float[] a = new float[n];
float[] b = new float[n];
float[] c = new float[n];

// Range-based parallel loop with optimal chunking
Compute.For(n, (start, end) =>
{
    for (int i = start; i < end; i++)
    {
        c[i] = a[i] * 2.5f + b[i];
    }
});

// Item-based parallel loop with deterministic sequential cutoff for small N
Compute.For(100, i =>
{
    c[i] = a[i] + b[i];
});

2. Cache-Aware 2D Grid / Tiling (Compute.Tile2D)

Eliminates cache thrashing by restricting active working sets to L1/L2 cache capacity:

int rows = 1024, cols = 1024;
const int blockR = 64, blockC = 64;

Compute.Tile2D(rows, cols, blockR, blockC, (r0, r1, c0, c1) =>
{
    // Inner tile [r0..r1, c0..c1] fits completely inside 16 KB L1 Data Cache
    for (int r = r0; r < r1; r++)
    {
        for (int c = c0; c < c1; c++)
        {
            matrixC[r, c] += matrixA[r, c] * matrixB[r, c];
        }
    }
});

3. Vectorized Math & Transcendental GELU (Compute.Vector)

4-way unrolled SIMD vectorization with Padé rational approximation:

// High-throughput SIMD vector addition & multiplication
Compute.Vector.Add(aSpan, bSpan, destSpan);
Compute.Vector.Multiply(aSpan, bSpan, destSpan);

// High-precision vectorized GELU activation (5.99x speedup vs scalar Math.Tanh)
Compute.Vector.Gelu(inputSpan, outputSpan);

4. Single-Pass Kernel Fusion (Compute.FusedMap)

Saves 66.7% DRAM bandwidth by fusing multiple operations in L1/registers instead of round-tripping through memory:

// 3 operations executed in a single memory pass
Compute.FusedMap(src, dst, x =>
{
    float v = x * 2.0f + 10.0f;
    return v > 0f ? v : 0f; // Fused Scale + Bias + ReLU
});

5. Multi-Accumulator Parallel Reduction (Compute.ReduceSum)

Saturates multiple execution ports (Port 0 & Port 1) by unrolling across 4 independent vector accumulators:

float sum = Compute.ReduceSum(dataSpan);
float max = Compute.ReduceMax(dataSpan);

6. Unified Compute Device Selection (CPU / GPU)

using ZeroCompute.Core;
using ZeroTensor.Core;

// Automatically selects Direct3D 11 GPU if present, else fallback to CPU SIMD
using var ctx = ComputeDevice.GetBestDevice();

var a = Tensor.RandomUniform(1024, 1024);
var b = Tensor.RandomUniform(1024, 1024);

// Executes GEMM on selected hardware
var c = ctx.Gemm(a, b);

7. NUMA-Node Topology & Domain Allocation

using ZeroCompute.Core.Cpu;

// Query system NUMA topology (Windows & Linux dual-socket / multi-socket)
int nodeCount = NumaTopology.GetNodeCount();
Console.WriteLine($"System NUMA Nodes: {nodeCount}, Dual-Socket Detected: {NumaTopology.IsDualSocketOrGreater()}");

// Allocate 64MB pin-bound directly on NUMA node 0 memory controller
using var memory = NumaTopology.Allocate(64 * 1024 * 1024, preferredNode: 0);
Span<byte> span = memory.AsSpan();
span.Fill(0xAA);

📊 Empirical Benchmarks

Evaluated on an Intel 12-Logical-Core processor under Windows 11 (Release x64 build):

🏛️ Placement in ZeroPlatform Ecosystem

graph TD
    subgraph Tier 0: Primitives
        ZP[ZeroPrimitives.Core]
    end

    subgraph Tier 1: Hardware Compute & Data
        ZT[ZeroTensor.Core: N-D Tensor & Striding]
        ZC[ZeroCompute.Core: CPU Multi-Level Runtime & D3D11 GPU]
    end

    subgraph Tier 2: AI & Signal Engines
        ZI[ZeroInference.Core: Edge AI ONNX Engine]
        ZN[ZeroNeural.Core: Deep Learning & Autograd]
        ZS[ZeroSignal.Core: DSP & FFT Filtering]
    end

    ZP --> ZT
    ZP --> ZC
    ZT --> ZC
    ZC --> ZI
    ZC --> ZN
    ZC --> ZS

📄 License

MIT License © 2026 Phong Võ. Part of the ZeroPlatform project.