test: record repeated performance evidence and compatibility validation

Keep semantic regression oracles from the rejected conditional-branch experiment; do not retain its inconsistent production optimization. Record 144 benchmark measurements, identical benchmark IL for kept changes, all target/native checks, and unchanged imported outcomes: 34945 pass, 152 existing failures, 36 skips, no new failures or observed crashes.

Author: jogibear9988

test/FastExpressionCompiler.Performance/Measure.ps1

@@ -29,5 +29,13 @@ try {
         $env:FEC_PERF_OUTPUT = "$run/results"
         dotnet "$run/binaries/FastExpressionCompiler.Performance.dll" --filter $Filter *> "$run/run.log"
         if ($LASTEXITCODE) { throw "Benchmark host failed; see $run/run.log" }
+        $exports = @(Get-ChildItem "$run/results/results/*-report-full.json" -ErrorAction SilentlyContinue)
+        if ($exports.Count -eq 0) { throw "No benchmark results; see $run/run.log" }
+        foreach ($export in $exports) {
+            $benchmarks = (Get-Content -LiteralPath $export.FullName -Raw | ConvertFrom-Json).Benchmarks
+            foreach ($benchmark in $benchmarks) {
+                if ($null -eq $benchmark.Statistics) { throw "Benchmark failed: $($benchmark.FullName)" }
+            }
+        }
     } finally { $env:FEC_PERF_OUTPUT = $oldOutput }
 } finally { Pop-Location }

test/FastExpressionCompiler.Performance/Measurements/00-array-repeat.csv

@@ -0,0 +1,9 @@
+phase,method,workload,mean_ns,standard_error_ns,confidence999_halfwidth_ns,samples,allocated_bytes
+Compilation,SystemCompile,Array,44092.36429663609,407.32815266319074,2427.1935824096317,7,5111
+Compilation,FastCompile,Array,2621.0309961963353,19.430183989718255,133.4625652749972,6,1151
+Compilation,LightCompile,Array,2424.5386448831327,27.224825466302182,147.2286576927394,8,1151
+Construction,SystemTree,Array,969.3136211490965,5.787494632720198,34.48661659874039,7,1192
+Construction,LightTree,Array,402.8292236121681,1.8216322897360446,9.85117341374887,8,672
+Invocation,SystemInvoke,Array,1.054202266541688,0.0017252807453472041,0.009330115581273508,8,0
+Invocation,FastInvoke,Array,1.3237841197142184,0.0016429300083295327,0.008884772470217512,8,0
+Invocation,LightInvoke,Array,1.3212930901631867,0.0038169751589302897,0.020641753233328133,8,0

test/FastExpressionCompiler.Performance/Measurements/01-vector-array-repeat.csv

@@ -0,0 +1,9 @@
+phase,method,workload,mean_ns,standard_error_ns,confidence999_halfwidth_ns,samples,allocated_bytes
+Compilation,SystemCompile,Array,58547.57658837992,1923.9837321399457,10404.677989809199,8,5111
+Compilation,FastCompile,Array,3416.32220589223,81.83097329810235,487.61572686020907,7,1152
+Compilation,LightCompile,Array,2963.829124362262,43.158118028056904,257.1712915537042,7,1151
+Construction,SystemTree,Array,1208.9290449575717,37.76366866130416,204.2214835661297,8,1192
+Construction,LightTree,Array,527.3626725838265,28.377524943103573,153.46232104175343,8,672
+Invocation,SystemInvoke,Array,1.0453298149441264,0.0032650202882277927,0.017656846137373266,8,0
+Invocation,FastInvoke,Array,1.2981700574302244,0.002646519738569882,0.014312067827552054,8,0
+Invocation,LightInvoke,Array,1.2998468951871944,0.002365871755547004,0.014097794872077418,7,0

test/FastExpressionCompiler.Performance/Measurements/03-conditional-before-repeat.csv

@@ -0,0 +1,9 @@
+phase,method,workload,mean_ns,standard_error_ns,confidence999_halfwidth_ns,samples,allocated_bytes
+Compilation,SystemCompile,Conditional,27237.520292207795,838.8639100267337,4998.63583113423,7,4749
+Compilation,FastCompile,Conditional,2293.181434552196,10.619921840017621,72.94640197636504,6,1136
+Compilation,LightCompile,Conditional,2474.948375176611,65.05998891362111,351.83677666228107,8,1135
+Construction,SystemTree,Conditional,682.0495613296781,29.50878834748411,159.58006062946978,8,712
+Construction,LightTree,Conditional,109.25339300498254,2.1186179819405773,11.457237146695228,8,408
+Invocation,SystemInvoke,Conditional,1.3325786860725501,0.025716880262671934,0.1390738671880405,8,0
+Invocation,FastInvoke,Conditional,1.1029724193602846,0.0019814990040205754,0.01180738830514044,7,0
+Invocation,LightInvoke,Conditional,1.456330592293892,0.05360008240937755,0.31939303775116945,7,0

test/FastExpressionCompiler.Performance/Measurements/03-conditional-rejected-repeat.csv

@@ -0,0 +1,9 @@
+phase,method,workload,mean_ns,standard_error_ns,confidence999_halfwidth_ns,samples,allocated_bytes
+Compilation,SystemCompile,Conditional,28920.111283847604,1171.0280526619538,6332.782133988809,8,4751
+Compilation,FastCompile,Conditional,2943.1422084725396,75.2368800483712,406.87220831670874,8,1128
+Compilation,LightCompile,Conditional,2036.0785071992375,28.612096703005292,170.49422447910754,7,1136
+Construction,SystemTree,Conditional,526.4769093096265,3.654186148155998,21.7746235062429,7,712
+Construction,LightTree,Conditional,100.78099814368055,0.9431908560070429,5.62030092376333,7,408
+Invocation,SystemInvoke,Conditional,0.9108637075684305,0.0007482628613593188,0.0040465176467566226,8,0
+Invocation,FastInvoke,Conditional,1.0925913443853665,0.0009054578315352813,0.005395456767414297,7,0
+Invocation,LightInvoke,Conditional,1.0907725181655428,0.0009683142706522157,0.005236529816116151,8,0

test/FastExpressionCompiler.Performance/Measurements/03-conditional-rejected.csv

@@ -0,0 +1,9 @@
+phase,method,workload,mean_ns,standard_error_ns,confidence999_halfwidth_ns,samples,allocated_bytes
+Compilation,SystemCompile,Conditional,19747.49481397216,191.31221794749212,1034.5939989034505,8,4751
+Compilation,FastCompile,Conditional,1937.3223442287428,14.271873351622522,85.04346969767312,7,1127
+Compilation,LightCompile,Conditional,2001.8317771236075,34.058675729801735,184.18531706282687,8,1135
+Construction,SystemTree,Conditional,618.4042653827383,40.90746225400293,243.76004753514005,7,712
+Construction,LightTree,Conditional,89.71923810780875,0.2865719376669982,1.5497473718368786,8,408
+Invocation,SystemInvoke,Conditional,1.2011257647880265,0.0017795024866120118,0.009623340387950844,8,0
+Invocation,FastInvoke,Conditional,1.0959969554896767,0.004571584488996063,0.024722591837252943,8,0
+Invocation,LightInvoke,Conditional,1.0740817028453802,0.0008019874305278588,0.0043370538051461524,8,0

test/FastExpressionCompiler.Performance/Measurements/README.md

@@ -36,6 +36,13 @@ arguments, covariance, ignored reads and exception-region receivers.
 
 Code commit: `7b6863bc`. Both libraries build across all four targets with zero warnings/errors.
 
+Focused frozen-binary repeat: `00-array-repeat.csv` versus `01-vector-array-repeat.csv`.
+System compilation moved 44,092 -> 58,548 ns, standard FEC 2,621 -> 3,416 ns, Light
+2,425 -> 2,964 ns. Absolute times worsened with the host conditions. Relative to System,
+standard FEC improved about 1.8% and Light about 8.0%, in the same direction as the first
+run. The small standard-FEC difference remains uncertain; do not advertise the first
+run's absolute percentages as an established universal gain.
+
 ## Optimization 2: named-field lookup without enumerating every field
 
 Use TypeInfo.GetDeclaredField and recurse to the base type only when necessary. This
@@ -56,3 +63,51 @@ One initial native run failed the existing generated FlatExpression roundtrip pr
 test (reported case seed 864021005, replay seed 6H3IIevvWaa1). Replays with both baseline
 and current libraries passed, including the explicit reported seed and default settings;
 the failure remains unreproduced. Preserve the failing log rather than masking it.
+
+Code commit: `a9b98445`. Comparing the original baseline directly with this final production
+code gives Light construction improvements of 40.7%, 52.7%, 35.7% and 55.6%, respectively.
+The more useful per-change comparison above uses its immediate parent as requested.
+
+## Rejected runtime candidate: direct conditional comparison branches
+
+Baseline benchmark commit: `37d445aa`; production baseline remains `a9b98445`.
+Candidate: replace equality/inequality materialization followed by Brfalse with Bne_Un/Beq
+for simple non-lifted, non-overloaded operands. Keep complex/EH cases on the existing path.
+The candidate passes the six standard/Light regression methods, including primitive and
+reference input matrices, NaN, nullable and overloaded exclusions, side effects and EH.
+
+Evidence: `03-conditional-before.csv` / `03-conditional-rejected.csv` and their repeat files.
+Standard compilation: 2,642 -> 1,937 ns initially, but 2,293 -> 2,943 ns on repeat.
+Light compilation: 2,314 -> 2,002 ns initially, 2,475 -> 2,036 ns on repeat. System controls
+also moved considerably. Standard invocation was 1.196 -> 1.096 ns initially and
+1.103 -> 1.093 ns on repeat; these tiny loop-inclusive timings do not establish a runtime win.
+Construction was measured in both runs as well. The inconsistent compilation results
+do not justify retaining this production change. It is removed from the branch.
+Retain the added workload and regression oracles for future investigations. The candidate
+patch and its exact frozen binaries/hashes remain in the local measurement archive.
+
+## Final validation and runtime interpretation
+
+The two kept changes emit exactly the same IL as the original baseline for all five
+benchmark workloads, in both standard and Light modes (ten delegate bodies compared).
+No delegate runtime speedup is claimed. Original/final timings for the first four
+workloads are in `00-baseline.csv` and `02-named-field.csv`; the conditional workload's
+final production timing is `03-conditional-before.csv`. Candidate timing files are not
+final production results. No compiler layout changes or System fallbacks were introduced.
+
+All library targets (`net472`, `netstandard2.1`, `net8.0`, `net10.0`) build with zero warnings
+and errors. Native .NET 10 and .NET 8 suites pass (1,712 / 1,711 legacy tests plus registered
+regressions). Framework passes 712 TestX executions and 1,595 legacy tests, using the
+existing external en-US runner. One initial unreproduced property-test failure is recorded above.
+
+The full imported compatibility suite was rerun against frozen final compiler binaries:
+34,945 pass, 152 fail, 36 normalized skips, zero observed crashes/timeouts. All outcome
+groups match the fixes baseline exactly: zero newly failing or unmatched groups. The
+152 pre-existing failures remain open. Skips include two compilation-mode cases of the
+one known deep-tree crash, which remains deferred; its explicit Skip discovery was
+verified without executing the tree body. See `validation.json` for counts and hashes.
+
+144 benchmark measurements were collected across nine serial runs. Each kept optimization
+has a separate code commit with measurements of construction, compilation and runtime.
+These local commits and evidence are ready for a later stacked performance PR; nothing
+has been pushed and the previous pull requests are unchanged.

test/FastExpressionCompiler.Performance/Measurements/validation.json

@@ -0,0 +1,31 @@
+{
+  "baselineCompilerCommit": "3f682768d6b23e445ae46595e456658899e371e4",
+  "finalProductionCommit": "a9b98445",
+  "completedBatches": 21,
+  "actualBatchOutcomes": {
+    "Passed": 34945,
+    "Failed": 152,
+    "NotExecuted": 34
+  },
+  "knownDeferredDeepTreeCases": 2,
+  "normalizedBaselineCases": 35133,
+  "normalizedOutcomes": {
+    "Passed": 34945,
+    "Failed": 152,
+    "Skipped": 36
+  },
+  "observedCrashes": [],
+  "changedOutcomeGroups": [],
+  "unmatchedCurrentGroups": 0,
+  "unmatchedBaselineGroups": 0,
+  "nativeValidation": {
+    "standard-targets": 0,
+    "light-targets": 0,
+    "native-net10": 0,
+    "native-net8": 0,
+    "framework-build": 0,
+    "framework-run": 0
+  },
+  "importedAssemblySHA256": "974d9a6f614cc796bc942ff5951e2f8d548286153927b01d7a5732356342e26a",
+  "compilerAssemblySHA256": "61ef1449552e6e18c32fc1ea3e21c1bbe4b1b5308636706e5c698be44cad3bb7"
+}

test/FastExpressionCompiler.TestsRunner.Net472/Program.cs

@@ -36,6 +36,7 @@ static void RunLightExpressionTests(object state)
                 var t = (LightExpression.TestRun)state;
                 t.Run(new LightExpression.UnitTests.NumericConversionRegressionTests());
                 t.Run(new LightExpression.UnitTests.IntrinsicConstructorExceptionRegressionTests());
+                t.Run(new LightExpression.UnitTests.ConditionalBranchRegressionTests());
                 t.Run(new LightExpression.UnitTests.NamedFieldLookupRegressionTests());
                 t.Run(new LightExpression.UnitTests.FormalByRefArgumentRegressionTests());
                 t.Run(new LightExpression.UnitTests.WritableReceiverAddressRegressionTests());
@@ -131,6 +132,7 @@ static void RunLightExpressionTests(object state)
             var fecTests = new TestRun();
             fecTests.Run(new NumericConversionRegressionTests());
             fecTests.Run(new IntrinsicConstructorExceptionRegressionTests());
+            fecTests.Run(new ConditionalBranchRegressionTests());
             fecTests.Run(new FormalByRefArgumentRegressionTests());
             fecTests.Run(new WritableReceiverAddressRegressionTests());
             fecTests.Run(new NestedMemberBindingLayoutBehaviorRegressionTests());

test/FastExpressionCompiler.TestsRunner/Program.cs

@@ -54,6 +54,7 @@ public static void Main()
 
             st.Run(new NumericConversionRegressionTests());
             st.Run(new IntrinsicConstructorExceptionRegressionTests());
+            st.Run(new ConditionalBranchRegressionTests());
             st.Run(new FormalByRefArgumentRegressionTests());
             st.Run(new WritableReceiverAddressRegressionTests());
             st.Run(new NestedMemberBindingLayoutBehaviorRegressionTests());
@@ -148,6 +149,7 @@ public static void Main()
 
             lt.Run(new LightExpression.UnitTests.NumericConversionRegressionTests());
             lt.Run(new LightExpression.UnitTests.IntrinsicConstructorExceptionRegressionTests());
+            lt.Run(new LightExpression.UnitTests.ConditionalBranchRegressionTests());
             lt.Run(new LightExpression.UnitTests.NamedFieldLookupRegressionTests());
             lt.Run(new LightExpression.UnitTests.FormalByRefArgumentRegressionTests());
             lt.Run(new LightExpression.UnitTests.WritableReceiverAddressRegressionTests());