perf: cross-language concurrent comparison benchmarks (#102)

## Summary
- Adds X5 16-thread comparison scenarios to Java `ComparisonBenchmark`
(old json-logic-java vs new WASM evaluator at high concurrency)
- Adds 3-way Python concurrent comparison: PyO3 (native) vs WASM
(wasmtime) vs panzi-json-logic at 1/4/16 threads with memory tracking
- Completes the cross-language performance comparison matrix across Go,
Java, and Python

## Benchmark Results Summary

### Go (wazero WASM vs diegoholiveira/jsonlogic)
| Scenario | WASM | Old | Speedup |
|----------|------|-----|---------|
| Simple 1G | 137 ns | 17,260 ns | **126x** |
| Targeting 4G | 1,668 ns | 9,752 ns | **5.8x** |
| Large ctx 16G | 2,124 ns | 1,063,688 ns | **500x** |

### Java (Chicory WASM vs json-logic-java)
| Scenario | WASM (µs) | Old (µs) | Alloc WASM (B/op) | Alloc Old (B/op)
|

|----------|-----------|----------|-------------------|-----------------|
| Simple 1T | 0.43 | 0.08 | 280 | 328 |
| Targeting 4T | 13.6 | 2.3 | 1,120 | 5,024 |
| Large ctx 16T | 13.3 | 2.4 | 1,184 | 5,024 |

Java old resolver has higher throughput but **4.5x more allocations**
per eval.

### Python (PyO3 vs WASM/wasmtime vs panzi-json-logic)
| Scenario | PyO3 | WASM | panzi | Best |
|----------|------|------|-------|------|
| 1T targeting | 3,459 ns | 37,361 ns | 3,115 ns | panzi |
| 4T targeting | 1,340 ns | 37,651 ns | 8,100 ns | **PyO3 6x** |
| 16T targeting | 1,073 ns | 37,530 ns | 9,854 ns | **PyO3 9.2x** |

PyO3 releases GIL → true parallelism at scale. WASM (wasmtime) holds GIL
→ serial.

## Test plan
- [ ] Java: `./mvnw clean package && java -jar target/benchmarks.jar
ComparisonBenchmark.X5`
- [ ] Python: `cd python && pytest
benchmarks/test_concurrent_comparison.py --benchmark-only -v`
- [ ] Python standalone: `cd python && python
benchmarks/test_concurrent_comparison.py`

Closes #101

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: aepfli

java/src/main/java/dev/openfeature/flagd/evaluator/ComparisonBenchmark.java

@@ -2,30 +2,39 @@
 
 import dev.openfeature.flagd.evaluator.comparison.MinimalInProcessResolver;
 import dev.openfeature.sdk.EvaluationContext;
-import dev.openfeature.sdk.MutableContext;
+import dev.openfeature.sdk.ImmutableContext;
+import dev.openfeature.sdk.LayeredEvaluationContext;
 import dev.openfeature.sdk.ProviderEvaluation;
+import dev.openfeature.sdk.Value;
 import org.openjdk.jmh.annotations.*;
 import org.openjdk.jmh.infra.Blackhole;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.TimeUnit;
 
 /**
  * JMH benchmarks comparing old JsonLogic resolver vs new WASM evaluator.
  *
+ * <p>Both resolvers use {@link LayeredEvaluationContext} (the production API path),
+ * which mirrors how the flagd provider constructs contexts with API, client,
+ * invocation, and transaction layers. This enables context key filtering and
+ * flag index evaluation on the WASM side.
+ *
  * <p>Covers single-threaded comparison (X1, X2), context size sweep (X3),
- * and concurrent comparison (X4).
+ * concurrent comparison at 4 threads (X4) and 16 threads (X5).
  *
  * <p><b>Running the benchmarks:</b>
  * <pre>
- * ./mvnw clean package
- * java -jar target/benchmarks.jar ComparisonBenchmark
+ * ./mvnw clean package -DskipTests
+ * java -jar target/benchmarks.jar ComparisonBenchmark -prof gc
  *
  * # Single-threaded only:
  * java -jar target/benchmarks.jar "ComparisonBenchmark.X[12]_.*"
  *
  * # Concurrent only:
- * java -jar target/benchmarks.jar "ComparisonBenchmark.X4_.*"
+ * java -jar target/benchmarks.jar "ComparisonBenchmark.X[45]_.*"
  * </pre>
  */
 @BenchmarkMode({Mode.Throughput, Mode.AverageTime})
@@ -69,30 +78,32 @@ public class ComparisonBenchmark {
         "  }\n" +
         "}";
 
-    // Context JSON strings for the new evaluator
-    private static final String EMPTY_CONTEXT_JSON = "{}";
+    /** Build a LayeredEvaluationContext matching the flagd provider pattern. */
+    private static EvaluationContext layeredContext(
+            EvaluationContext apiCtx,
+            EvaluationContext clientCtx,
+            EvaluationContext invocationCtx) {
+        return new LayeredEvaluationContext(apiCtx, clientCtx, invocationCtx, ImmutableContext.EMPTY);
+    }
 
-    private static final String SMALL_CONTEXT_JSON = "{" +
-        "\"targetingKey\": \"user-123\", " +
-        "\"tier\": \"premium\", " +
-        "\"role\": \"admin\", " +
-        "\"region\": \"us-east\", " +
-        "\"score\": 85" +
-        "}";
+    /** Build an ImmutableContext from a targeting key and attribute map. */
+    private static ImmutableContext immutableCtx(String targetingKey, Map<String, Value> attrs) {
+        return new ImmutableContext(targetingKey, attrs);
+    }
 
     @State(Scope.Benchmark)
     public static class ComparisonState {
         FlagEvaluator newEvaluator;
         MinimalInProcessResolver oldResolver;
 
-        // EvaluationContext objects for the old resolver
+        // Shared API-level context (global attributes like environment/service)
+        ImmutableContext apiContext;
+
+        // Layered contexts for benchmarks
         EvaluationContext emptyContext;
         EvaluationContext smallContext;
         EvaluationContext largeContext;
 
-        // JSON strings for the new evaluator
-        String largeContextJson;
-
         @Setup(Level.Trial)
         public void setup() {
             try {
@@ -104,67 +115,48 @@ public void setup() {
                 oldResolver = new MinimalInProcessResolver();
                 oldResolver.loadFlags(FLAG_CONFIG);
 
-                // Build contexts for old resolver
-                emptyContext = new MutableContext();
-
-                smallContext = new MutableContext()
-                    .add("targetingKey", "user-123")
-                    .add("tier", "premium")
-                    .add("role", "admin")
-                    .add("region", "us-east")
-                    .add("score", 85);
-
-                MutableContext large = new MutableContext()
-                    .add("targetingKey", "user-123")
-                    .add("tier", "premium")
-                    .add("role", "admin")
-                    .add("region", "us-east")
-                    .add("score", 85);
-                for (int i = 0; i < 100; i++) {
-                    switch (i % 4) {
-                        case 0:
-                            large.add("attr_" + i, "value-" + i);
-                            break;
-                        case 1:
-                            large.add("attr_" + i, i * 7);
-                            break;
-                        case 2:
-                            large.add("attr_" + i, i % 2 == 0);
-                            break;
-                        case 3:
-                            large.add("attr_" + i, i * 1.5);
-                            break;
-                    }
-                }
-                largeContext = large;
-
-                // Build large context JSON for the new evaluator
-                StringBuilder sb = new StringBuilder(4096);
-                sb.append("{");
-                sb.append("\"targetingKey\": \"user-123\", ");
-                sb.append("\"tier\": \"premium\", ");
-                sb.append("\"role\": \"admin\", ");
-                sb.append("\"region\": \"us-east\", ");
-                sb.append("\"score\": 85");
+                // API-level context (set once at provider init)
+                Map<String, Value> apiAttrs = new HashMap<>();
+                apiAttrs.put("environment", new Value("production"));
+                apiAttrs.put("service", new Value("checkout"));
+                apiContext = new ImmutableContext(apiAttrs);
+
+                // Empty invocation context — only API-level attributes
+                emptyContext = layeredContext(apiContext, ImmutableContext.EMPTY, ImmutableContext.EMPTY);
+
+                // Small invocation context (4 user attributes)
+                Map<String, Value> smallAttrs = new HashMap<>();
+                smallAttrs.put("tier", new Value("premium"));
+                smallAttrs.put("role", new Value("admin"));
+                smallAttrs.put("region", new Value("us-east"));
+                smallAttrs.put("score", new Value(85));
+                smallContext = layeredContext(apiContext, ImmutableContext.EMPTY,
+                    immutableCtx("user-123", smallAttrs));
+
+                // Large invocation context (100+ attributes)
+                Map<String, Value> largeAttrs = new HashMap<>();
+                largeAttrs.put("tier", new Value("premium"));
+                largeAttrs.put("role", new Value("admin"));
+                largeAttrs.put("region", new Value("us-east"));
+                largeAttrs.put("score", new Value(85));
                 for (int i = 0; i < 100; i++) {
-                    sb.append(", ");
                     switch (i % 4) {
                         case 0:
-                            sb.append("\"attr_").append(i).append("\": \"value-").append(i).append("\"");
+                            largeAttrs.put("attr_" + i, new Value("value-" + i));
                             break;
                         case 1:
-                            sb.append("\"attr_").append(i).append("\": ").append(i * 7);
+                            largeAttrs.put("attr_" + i, new Value(i * 7));
                             break;
                         case 2:
-                            sb.append("\"attr_").append(i).append("\": ").append(i % 2 == 0 ? "true" : "false");
+                            largeAttrs.put("attr_" + i, new Value(i % 2 == 0));
                             break;
                         case 3:
-                            sb.append("\"attr_").append(i).append("\": ").append(i * 1.5);
+                            largeAttrs.put("attr_" + i, new Value(i * 1.5));
                             break;
                     }
                 }
-                sb.append("}");
-                largeContextJson = sb.toString();
+                largeContext = layeredContext(apiContext, ImmutableContext.EMPTY,
+                    immutableCtx("user-123", largeAttrs));
             } catch (Exception e) {
                 throw new RuntimeException("Failed to setup comparison state", e);
             }
@@ -195,7 +187,7 @@ public void X1_old_simple(ComparisonState state, Blackhole bh) {
     public void X1_new_simple(ComparisonState state, Blackhole bh) {
         try {
             EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
-                Boolean.class, "simple-bool", EMPTY_CONTEXT_JSON);
+                Boolean.class, "simple-bool", state.emptyContext);
             bh.consume(result.getValue());
             bh.consume(result.getVariant());
         } catch (Exception e) {
@@ -220,7 +212,7 @@ public void X2_old_targeting(ComparisonState state, Blackhole bh) {
     public void X2_new_targeting(ComparisonState state, Blackhole bh) {
         try {
             EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
-                Boolean.class, "targeted-access", SMALL_CONTEXT_JSON);
+                Boolean.class, "targeted-access", state.smallContext);
             bh.consume(result.getValue());
             bh.consume(result.getVariant());
         } catch (Exception e) {
@@ -265,7 +257,7 @@ public void X3_old_largeContext(ComparisonState state, Blackhole bh) {
     public void X3_new_emptyContext(ComparisonState state, Blackhole bh) {
         try {
             EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
-                Boolean.class, "targeted-access", EMPTY_CONTEXT_JSON);
+                Boolean.class, "targeted-access", state.emptyContext);
             bh.consume(result.getValue());
             bh.consume(result.getVariant());
         } catch (Exception e) {
@@ -278,7 +270,7 @@ public void X3_new_emptyContext(ComparisonState state, Blackhole bh) {
     public void X3_new_smallContext(ComparisonState state, Blackhole bh) {
         try {
             EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
-                Boolean.class, "targeted-access", SMALL_CONTEXT_JSON);
+                Boolean.class, "targeted-access", state.smallContext);
             bh.consume(result.getValue());
             bh.consume(result.getVariant());
         } catch (Exception e) {
@@ -291,7 +283,7 @@ public void X3_new_smallContext(ComparisonState state, Blackhole bh) {
     public void X3_new_largeContext(ComparisonState state, Blackhole bh) {
         try {
             EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
-                Boolean.class, "targeted-access", state.largeContextJson);
+                Boolean.class, "targeted-access", state.largeContext);
             bh.consume(result.getValue());
             bh.consume(result.getVariant());
         } catch (Exception e) {
@@ -305,18 +297,56 @@ public void X3_new_largeContext(ComparisonState state, Blackhole bh) {
 
     @State(Scope.Thread)
     public static class ThreadContext {
-        Random random;
-        String simpleContextJson;
+        EvaluationContext simpleContext;
         EvaluationContext matchingContext;
+        EvaluationContext largeMatchingContext;
 
         @Setup(Level.Trial)
         public void setup() {
-            random = new Random(42 + Thread.currentThread().getId());
-            simpleContextJson = "{\"targetingKey\": \"user-" + random.nextInt(10000) + "\"}";
-            matchingContext = new MutableContext()
-                .add("role", "admin")
-                .add("tier", "premium")
-                .add("targetingKey", "user-" + random.nextInt(10000));
+            Random random = new Random(42 + Thread.currentThread().getId());
+            String targetingKey = "user-" + random.nextInt(10000);
+
+            // API-level context (same as ComparisonState)
+            Map<String, Value> apiAttrs = new HashMap<>();
+            apiAttrs.put("environment", new Value("production"));
+            apiAttrs.put("service", new Value("checkout"));
+            ImmutableContext apiCtx = new ImmutableContext(apiAttrs);
+
+            // Simple: only targeting key, no invocation attributes
+            simpleContext = layeredContext(apiCtx, ImmutableContext.EMPTY,
+                new ImmutableContext(targetingKey));
+
+            // Matching: role + tier that match the targeting rule
+            Map<String, Value> matchAttrs = new HashMap<>();
+            matchAttrs.put("role", new Value("admin"));
+            matchAttrs.put("tier", new Value("premium"));
+            matchingContext = layeredContext(apiCtx, ImmutableContext.EMPTY,
+                immutableCtx(targetingKey, matchAttrs));
+
+            // Large: 100+ attributes with role + tier
+            Map<String, Value> largeAttrs = new HashMap<>();
+            largeAttrs.put("role", new Value("admin"));
+            largeAttrs.put("tier", new Value("premium"));
+            largeAttrs.put("region", new Value("us-east"));
+            largeAttrs.put("score", new Value(85));
+            for (int i = 0; i < 100; i++) {
+                switch (i % 4) {
+                    case 0:
+                        largeAttrs.put("attr_" + i, new Value("value-" + i));
+                        break;
+                    case 1:
+                        largeAttrs.put("attr_" + i, new Value(i * 7));
+                        break;
+                    case 2:
+                        largeAttrs.put("attr_" + i, new Value(i % 2 == 0));
+                        break;
+                    case 3:
+                        largeAttrs.put("attr_" + i, new Value(i * 1.5));
+                        break;
+                }
+            }
+            largeMatchingContext = layeredContext(apiCtx, ImmutableContext.EMPTY,
+                immutableCtx(targetingKey, largeAttrs));
         }
     }
 
@@ -328,7 +358,7 @@ public void setup() {
     @Threads(4)
     public void X4_old_concurrentSimple(ComparisonState state, ThreadContext ctx, Blackhole bh) {
         ProviderEvaluation<Boolean> result = state.oldResolver.booleanEvaluation(
-            "simple-bool", false, state.emptyContext);
+            "simple-bool", false, ctx.simpleContext);
         bh.consume(result);
     }
 
@@ -337,7 +367,7 @@ public void X4_old_concurrentSimple(ComparisonState state, ThreadContext ctx, Bl
     public void X4_new_concurrentSimple(ComparisonState state, ThreadContext ctx, Blackhole bh) {
         try {
             EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
-                Boolean.class, "simple-bool", ctx.simpleContextJson);
+                Boolean.class, "simple-bool", ctx.simpleContext);
             bh.consume(result.getValue());
             bh.consume(result.getVariant());
         } catch (Exception e) {
@@ -366,6 +396,73 @@ public void X4_new_concurrentTargeting(ComparisonState state, ThreadContext ctx,
         }
     }
 
+    // ========================================================================
+    // X5: Old vs New under high concurrency (16 threads)
+    // ========================================================================
+
+    @Benchmark
+    @Threads(16)
+    public void X5_old_16t_simple(ComparisonState state, ThreadContext ctx, Blackhole bh) {
+        ProviderEvaluation<Boolean> result = state.oldResolver.booleanEvaluation(
+            "simple-bool", false, ctx.simpleContext);
+        bh.consume(result);
+    }
+
+    @Benchmark
+    @Threads(16)
+    public void X5_new_16t_simple(ComparisonState state, ThreadContext ctx, Blackhole bh) {
+        try {
+            EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
+                Boolean.class, "simple-bool", ctx.simpleContext);
+            bh.consume(result.getValue());
+            bh.consume(result.getVariant());
+        } catch (Exception e) {
+            throw new RuntimeException("Benchmark failed", e);
+        }
+    }
+
+    @Benchmark
+    @Threads(16)
+    public void X5_old_16t_targeting(ComparisonState state, ThreadContext ctx, Blackhole bh) {
+        ProviderEvaluation<Boolean> result = state.oldResolver.booleanEvaluation(
+            "targeted-access", false, ctx.matchingContext);
+        bh.consume(result);
+    }
+
+    @Benchmark
+    @Threads(16)
+    public void X5_new_16t_targeting(ComparisonState state, ThreadContext ctx, Blackhole bh) {
+        try {
+            EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
+                Boolean.class, "targeted-access", ctx.matchingContext);
+            bh.consume(result.getValue());
+            bh.consume(result.getVariant());
+        } catch (Exception e) {
+            throw new RuntimeException("Benchmark failed", e);
+        }
+    }
+
+    @Benchmark
+    @Threads(16)
+    public void X5_old_16t_largeContext(ComparisonState state, ThreadContext ctx, Blackhole bh) {
+        ProviderEvaluation<Boolean> result = state.oldResolver.booleanEvaluation(
+            "targeted-access", false, ctx.largeMatchingContext);
+        bh.consume(result);
+    }
+
+    @Benchmark
+    @Threads(16)
+    public void X5_new_16t_largeContext(ComparisonState state, ThreadContext ctx, Blackhole bh) {
+        try {
+            EvaluationResult<Boolean> result = state.newEvaluator.evaluateFlag(
+                Boolean.class, "targeted-access", ctx.largeMatchingContext);
+            bh.consume(result.getValue());
+            bh.consume(result.getVariant());
+        } catch (Exception e) {
+            throw new RuntimeException("Benchmark failed", e);
+        }
+    }
+
     /**
      * Main method to run benchmarks standalone.
      */