feat(compiler): Implement true concurrent parallel execution for compiled code

[KrisSimon]

Overview

Implements true concurrent parallel execution for parallel for each loops in compiled ARO binaries using function pointers and DispatchQueue, matching the interpreter's non-deterministic concurrent behavior.

Changes

Runtime Bridge (RuntimeBridge.swift)

• ✅ Add RuntimeError enum for compilation error handling
• ✅ Add aro_parallel_for_each_execute C-callable function
  • Uses DispatchQueue + DispatchGroup for reliable parallelism
  • Implements concurrency limiting with DispatchSemaphore
  • Thread-safe error tracking with NSLock
  • Defaults to System.coreCount threads, configurable via with <concurrency: N>

LLVM Code Generator (LLVMCodeGenerator.swift)

• ✅ Add global runtime pointer (@global_runtime) for parallel executor access
• ✅ Extract parallel loop bodies as separate LLVM functions
  • Function signature: ptr function(ptr context, ptr item, i64 index)
  • Proper variable binding and filter support
  • Isolated %__result variable per loop body
• ✅ Replace serial parallel loop generation with function pointer approach
• ✅ Add generateLoopBodyFunction() to emit loop body functions
• ✅ Add generatePendingLoopBodies() to emit after feature sets
• ✅ Update external declarations with parallel executor

Example

• ✅ Add Examples/ParallelForEach/ demonstrating serial vs parallel iteration
• ✅ Shows non-deterministic execution order in parallel loops

Technical Highlights

• Function Pointers: Loop bodies compiled as separate LLVM functions, passed to runtime executor
• Concurrency Control: Default to System.coreCount, override via with <concurrency: N> syntax
• Context Isolation: Child contexts per iteration for immutability guarantees
• DispatchQueue: Replaced Swift concurrency (Task/TaskGroup) for compiled binary compatibility
• No Breaking Changes: Serial loops unchanged, parallel loops now truly parallel

Testing

Verified with Examples/ParallelForEach:

Interpreter (aro run):

=== Parallel Iteration ===
1, 3, 4, 5, 2, 8, 6, 10, 7, 9  ← Non-deterministic ✓

Compiled Binary (aro build):

=== Parallel Iteration ===
1, 2, 3, 4, 6, 7, 8, 9, 5, 10  ← Non-deterministic ✓

Both show true concurrent execution with varying iteration order across runs.

Performance

• Serial loops: Unchanged performance, deterministic ordering preserved
• Parallel loops: True concurrent execution leveraging multiple CPU cores
• Concurrency limiting: Prevents thread explosion on large collections
• Context overhead: Minimal - child contexts created per iteration as in interpreter

Example Usage

(Application-Start: Parallel Demo) {
    <Create> the <numbers> with [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].

    (* Serial execution - deterministic order *)
    for each <n> in <numbers> {
        <Log> the <msg> for the <console> with <n>.
    }

    (* Parallel execution - non-deterministic order *)
    parallel for each <n> in <numbers> {
        <Log> the <msg> for the <console> with <n>.
    }

    (* With concurrency limit *)
    parallel for each <n> in <numbers> with <concurrency: 4> {
        <Log> the <msg> for the <console> with <n>.
    }

    <Return> an <OK: status> for the <demo>.
}

Build & Test

# Build the project
swift build

# Run with interpreter (already had parallelism)
.build/debug/aro run ./Examples/ParallelForEach

# Compile to native binary (now has parallelism!)
.build/debug/aro build ./Examples/ParallelForEach

# Run compiled binary
./Examples/ParallelForEach/ParallelForEach

Files Changed

• Sources/ARORuntime/Bridge/RuntimeBridge.swift (+147 lines)
• Sources/AROCompiler/LLVMCodeGenerator.swift (+322 lines, -66 lines)
• Examples/ParallelForEach/main.aro (new)

Related

Implements the full vision for parallel execution in compiled ARO code, bridging the gap between interpreter and compiler capabilities.