Region Memory Model & Escape Diagnostics

Deterministic $O(1)$ stack arena allocation, transparent escape analysis, and compile-time real-time assertions.

1. The Region-Based Execution Model

Every function in Nyx automatically instantiates a thread-local bump arena. Objects that do not escape the function scope are allocated contiguously and dropped in $O(1)$ bulk time upon return:

import std.core.*;

fn process_payload(raw_json: string) -> int {
    // Allocated inside the function's local region frame:
    let parsed = json::parse(raw_json);
    let mut total_score = 0;
    
    for item in parsed.items {
        total_score = total_score + item.score;
    }
    
    // parsed and all intermediate nodes are dropped in O(1) bulk time here!
    total_score
}

2. Escape Analysis Topology (The 5 Scenarios)

When an object must outlive its creating frame, Nyx's $O(V+E)$ intra-procedural escape engine classifies it into one of five distinct promotion topologies:

3. Escape Diagnostics Engine (--warn-escape)

To eliminate "implicit magic" and provide 100% visibility into memory allocation decisions, developers can compile with --warn-escape or --explain-escape:

$ nyxc src/server.nyx --warn-escape
[Nyx Info]: Function 'process_payload' -> 100% stack region allocations (0 heap escapes).
[Nyx Warn]: src/server.nyx:42:18: Variable 'client_session' escapes local frame to Atomic ARC
            Reason: Transmitted across async thread channel via 'channel.send(client_session)'

4. Real-Time Hard Assertion: @must_region

For high-frequency trading engines, audio DSP pipelines, and avionics flight modules, Nyx provides the @must_region (or #![deny(heap_escape)]) pragma. If any variable in an annotated scope escapes to heap or Atomic ARC, the compiler produces a hard build error:

import std.core.*;

@must_region
fn audio_dsp_kernel(samples: &[f32; 1024]) -> [f32; 512] {
    // The compiler enforces that ALL operations in this block
    // execute strictly in stack region frames with 0.00 ms GC pauses.
    let mut fft_bins: [f32; 512] = [0.0; 512];
    for i in 0..512 {
        fft_bins[i] = samples[i * 2] * 0.707;
    }
    fft_bins
}

5. Comparison with Industry Runtimes