Replace the IR tree-walking evaluator with a bytecode VM. (#128)

* rego: Replace the IR tree-walking evaluator with a bytecode VM.

Introduce a Bytecode package that compiles IR into a compact
instruction stream and executes it in a tight PC loop, replacing the
recursive tree-walking IR evaluator.

Bytecode is more compact than the IR, more cache-friendly, and
eliminates per-evaluation pointer chasing. The tree-walking evaluator
copies Statement enum associated values on every dispatch; the VM
decodes operands directly from the byte stream instead.

The IR-to-bytecode converter runs once at load time. Compact opcode
variants pack their operand into the 24-bit header length field,
saving a payload word for the most frequent single-operand statements.
Validation bounds-checks all string/number/function table references
before execution so the VM hot loop can skip those checks entirely.

The bytecode VM is up to 25% faster in benchmarks, with the biggest
gains on iteration and call-heavy workloads.

Signed-off-by: Teemu Koponen <tkoponen@apple.com>

* rego: Remove auto-grow from Locals - validate local indices at load time.

Signed-off-by: Teemu Koponen <tkoponen@apple.com>

Author: koponen

Package.swift

@@ -30,18 +30,23 @@ let package = Package(
         // Targets can depend on other targets in this package and products from dependencies.
         .target(
             name: "SwiftOPA",
-            dependencies: ["AST", "IR", "Rego"]
+            dependencies: ["AST", "IR", "Bytecode", "Rego"]
         ),
         .target(name: "AST"),
         .target(
             name: "IR",
             dependencies: ["AST"]
         ),
+        .target(
+            name: "Bytecode",
+            dependencies: ["AST", "IR"]
+        ),
         .target(
             name: "Rego",
             dependencies: [
                 "AST",
                 "IR",
+                "Bytecode",
                 .product(name: "Crypto", package: "swift-crypto", condition: .when(platforms: [.linux])),
             ]
         ),
@@ -52,9 +57,13 @@ let package = Package(
         ),
         .testTarget(
             name: "IRTests",
-            dependencies: ["IR"],
+            dependencies: ["AST", "IR"],
             resources: [.copy("Fixtures")]
         ),
+        .testTarget(
+            name: "BytecodeTests",
+            dependencies: ["AST", "IR", "Bytecode"]
+        ),
         .testTarget(
             name: "RegoTests",
             dependencies: ["Rego"],

Sources/AST/Local.swift

@@ -0,0 +1,2 @@
+/// Local variable index type used across IR and bytecode evaluation.
+public typealias Local = UInt32

Sources/Bytecode/Builder.swift

@@ -0,0 +1,68 @@
+import AST
+import IR
+
+/// Builds deduplicated string table during bytecode conversion
+public struct StringTableBuilder {
+    private var strings: [String] = []
+    private var indices: [String: Int] = [:]
+
+    public init() {}
+
+    /// Intern a string and return its index in the table
+    public mutating func intern(_ string: String) -> Int {
+        if let existing = indices[string] {
+            return existing
+        }
+        let index = strings.count
+        strings.append(string)
+        indices[string] = index
+        return index
+    }
+
+    /// Get the final string table
+    public var table: [String] {
+        return strings
+    }
+
+    /// Get the number of strings in the table
+    public var count: Int {
+        return strings.count
+    }
+}
+
+/// Context for bytecode conversion, tracks state during conversion
+public struct ConversionContext {
+    public var stringTable: StringTableBuilder
+    public var encoder: Encoder
+    public var functionIndices: [String: Int]
+    public var numbers: [RegoNumber?]
+
+    public init(functionIndices: [String: Int] = [:], numbers: [RegoNumber?] = []) {
+        self.stringTable = StringTableBuilder()
+        self.encoder = Encoder()
+        self.functionIndices = functionIndices
+        self.numbers = numbers
+    }
+
+    /// Get current bytecode offset
+    public var currentOffset: Int {
+        return encoder.offset
+    }
+
+    /// Convert IR operand to encoded operand, interning strings as needed
+    public mutating func convertOperand(_ operand: IR.Operand) throws -> EncodedOperand {
+        switch operand.value {
+        case .localIndex(let idx):
+            return .local(UInt32(idx))
+        case .bool(let value):
+            return .bool(value)
+        case .stringIndex(let idx):
+            return .stringIndex(UInt32(idx))
+        }
+    }
+
+    /// Convert array of IR operands to encoded operands
+    public mutating func convertOperands(_ operands: [IR.Operand]) throws -> [EncodedOperand] {
+        return try operands.map { try convertOperand($0) }
+    }
+}