Ordo JIT Compilation and Performance Optimization

Schema-Aware JIT

Ordo's JIT compiler is based on Cranelift, supporting Schema-aware direct memory access with 20-30x performance improvement.

Core Architecture

                    ┌─────────────────┐
                    │   Expr AST      │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │ SchemaJITCompiler│
                    └────────┬────────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
     ┌────────▼────────┐    │    ┌────────▼────────┐
     │  Field Offset   │    │    │  Native Code    │
     │   Resolution    │    │    │   Generation    │
     └─────────────────┘    │    └─────────────────┘
                    ┌───────▼────────┐
                    │ Machine Code   │
                    │ ldr d0, [ptr+N]│
                    └────────────────┘

TypedContext Derive Macro

rust
1use ordo_derive::TypedContext;
2
3#[derive(TypedContext)]
4struct UserContext {
5    age: i64,
6    balance: f64,
7    vip_level: i64,
8    #[typed_context(skip)]  // Skip non-numeric fields
9    name: String,
10}

The generated Schema contains field offsets, JIT compiler directly generates memory load instructions.

Using JIT Evaluator

rust
1use ordo_core::expr::jit::{SchemaJITCompiler, SchemaJITEvaluator};
2
3// Create compiler
4let mut compiler = SchemaJITCompiler::new()?;
5
6// Compile expression (with Schema)
7let schema = UserContext::schema();
8let compiled = compiler.compile_with_schema(&expr, &schema)?;
9
10// Execute
11let ctx = UserContext { age: 25, balance: 1000.0, vip_level: 3 };
12let result = unsafe { compiled.call_typed(&ctx)? };

Performance Comparison

Optimization Strategies

1. Expression Pre-compilation

rust
1// Pre-compile expressions when loading rules
2let mut ruleset = RuleSet::from_json(json)?;
3ruleset.compile()?;  // Pre-compile all expressions to bytecode
4
5// Or use one-step loading
6let ruleset = RuleSet::from_json_compiled(json)?;

2. Batch Execution

rust
1use ordo_core::prelude::*;
2
3let executor = RuleExecutor::new();
4
5// Batch execution (reduces lock contention)
6let inputs: Vec<Value> = load_batch();
7let results = executor.execute_batch(&ruleset, inputs)?;

3. Vectorized Evaluation

rust
1use ordo_core::expr::VectorizedEvaluator;
2
3let evaluator = VectorizedEvaluator::new();
4let contexts: Vec<Context> = prepare_contexts();
5let results = evaluator.eval_batch(&expr, &contexts)?;

4. Function Fast Path

Common functions (len, sum, max, min, abs, count, is_null) have inline fast paths, avoiding HashMap lookups.

Compiler Configuration

JIT Compiler Options

rust
1let mut compiler = SchemaJITCompiler::new()?;
2
3// View compilation statistics
4let stats = compiler.stats();
5println!("Successful compiles: {}", stats.successful_compiles);
6println!("Total code size: {} bytes", stats.total_code_size);

Feature Flags

Configure in Cargo.toml:

toml
1[dependencies]
2ordo-core = { version = "0.2", features = ["jit"] }
3
4# Full features
5ordo-core = { version = "0.2", features = ["default"] }  # jit + signature + derive

Note: JIT is not available on WASM targets (Cranelift doesn't support wasm32).

Performance Tuning Checklist

Compile-time Optimization

• Build with --release mode
• Enable LTO: lto = true
• Set codegen-units = 1

Runtime Optimization

• Pre-compile rule expressions
• Use JIT for fixed Schema
• Batch execution to reduce overhead
• Set reasonable max_depth

Server Optimization

• Set RUST_LOG=warn or info
• Disable unnecessary tracing
• Use connection pooling
• Configure appropriate worker count

Benchmarking

Run built-in benchmarks:

bash
1# Basic benchmarks
2cargo bench --package ordo-core
3
4# JIT comparison tests
5cargo bench --package ordo-core --bench jit_comparison_bench
6
7# Schema JIT tests
8cargo bench --package ordo-core --bench schema_jit_bench

Typical Results (Apple Silicon)

expression/eval/simple_compare    time: [79.234 ns]
expression/eval/function_call     time: [211.45 ns]
rule/simple_ruleset              time: [1.6312 µs]
jit/schema_aware/numeric         time: [52.341 ns]

Key Files

• crates/ordo-core/src/expr/jit/schema_compiler.rs - Schema JIT compiler
• crates/ordo-core/src/expr/jit/schema_evaluator.rs - JIT evaluator
• crates/ordo-core/src/expr/jit/typed_context.rs - Typed context
• crates/ordo-derive/src/lib.rs - TypedContext derive macro
• crates/ordo-core/benches/ - Benchmarks