Merge pull request GaijinEntertainment#2712 from GaijinEntertainment/bbatkin/linq-fold-sort-family

linq_fold: retire _old_fold; 3-tier cascade; order-family + select+where splice

Author: borisbat

benchmarks/sql/LINQ.md

@@ -30,17 +30,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let yes = _old_fold(each(arr)._all(_.price < 9999))
-        if (!yes) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -61,11 +50,6 @@ def all_match_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def all_match_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def all_match_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/all_match.das

@@ -30,17 +30,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let yes = _old_fold(each(arr)._any(_.price > THRESHOLD))
-        if (!yes) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -61,11 +50,6 @@ def any_match_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def any_match_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def any_match_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/any_match.das

@@ -4,7 +4,7 @@ options persistent_heap
 require _common public
 
 // SQL: SELECT AVG(price) FROM Cars.
-// m3/m3f_old/m3f sum and divide on a single pass.
+// m3/m3f sum and divide on a single pass.
 
 def run_m1(b : B?; n : int) {
     with_sqlite(":memory:") $(db) {
@@ -27,17 +27,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let a = _old_fold(each(arr)._select(double(_.price)).average())
-        if (a == 0.0lf) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -58,11 +47,6 @@ def average_aggregate_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def average_aggregate_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def average_aggregate_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/average_aggregate.das

@@ -0,0 +1,64 @@
+options gen2
+options persistent_heap
+
+require _common public
+
+let THRESHOLD = 500
+
+// _where(_.price > T) |> _order_by(_.price) — fused prefilter + sort, NO take.
+// SQL: WHERE price > T ORDER BY price.
+// m3 (plain LINQ) materializes a filter array, then sorts a clone (two allocations).
+// m3f (spliced via plan_order_family Phase 3c) emits a single fused loop that collects
+// matching elements into one pre-allocated buffer, then sort_inplace's the buffer.
+
+def run_m1(b : B?; n : int) {
+    with_sqlite(":memory:") $(db) {
+        fixture_db(db, n)
+        b |> run("m1_sql/{n}", n) {
+            let rows <- _sql(db |> select_from(type<Car>)
+                                |> _where(_.price > THRESHOLD)
+                                |> _order_by(_.price))
+            if (empty(rows)) {
+                b->failNow()
+            }
+        }
+    }
+}
+
+def run_m3(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3_array/{n}", n) {
+        let rows <- (arr |> _where(_.price > THRESHOLD)
+                         |> _order_by(_.price))
+        if (empty(rows)) {
+            b->failNow()
+        }
+    }
+}
+
+def run_m3f(b : B?; n : int) {
+    let arr <- fixture_array(n)
+    b |> run("m3f_array_fold/{n}", n) {
+        let rows <- _fold(each(arr)._where(_.price > THRESHOLD)
+                                   ._order_by(_.price)
+                                   .to_array())
+        if (empty(rows)) {
+            b->failNow()
+        }
+    }
+}
+
+[benchmark]
+def bare_order_where_m1(b : B?) {
+    run_m1(b, 100000)
+}
+
+[benchmark]
+def bare_order_where_m3(b : B?) {
+    run_m3(b, 100000)
+}
+
+[benchmark]
+def bare_order_where_m3f(b : B?) {
+    run_m3f(b, 100000)
+}

benchmarks/sql/bare_order_where.das

@@ -37,19 +37,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let c = _old_fold(each(arr)._where(_.price > THRESHOLD)
-                                   ._where(_.year >= YEAR_FLOOR)
-                                   .count())
-        if (c == 0) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -72,11 +59,6 @@ def chained_where_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def chained_where_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def chained_where_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/chained_where.das

@@ -33,17 +33,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let yes = _old_fold(each(arr)._select(_.id).contains(TARGET_ID))
-        if (!yes) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -64,11 +53,6 @@ def contains_match_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def contains_match_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def contains_match_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/contains_match.das

@@ -7,7 +7,6 @@ let THRESHOLD = 500
 
 // SQL pushes COUNT(*) to the engine returning one row.
 // m3 must materialize the full filtered array, then walk to count it.
-// m3f_old is the pre-rewrite baseline fold (frozen — diverges as splice mode lands).
 // m3f folds where+count into a single fused pass (no intermediate array).
 
 // --- m1: _sql over :memory: ---
@@ -34,17 +33,6 @@ def run_m3(b : B?; n : int) {
     }
 }
 
-// --- m3f_old: pre-rewrite baseline fold ---
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let c = _old_fold(each(arr)._where(_.price > THRESHOLD).count())
-        if (c == 0) {
-            b->failNow()
-        }
-    }
-}
-
 // --- m3f: array LINQ folded into a single fused pass ---
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
@@ -66,11 +54,6 @@ def count_aggregate_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def count_aggregate_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def count_aggregate_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/count_aggregate.das

@@ -31,17 +31,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let rows <- _old_fold(each(arr)._select(_.brand).distinct().to_array())
-        if (empty(rows)) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -62,11 +51,6 @@ def distinct_count_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def distinct_count_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def distinct_count_m3f(b : B?) {
     run_m3f(b, 100000)

benchmarks/sql/distinct_count.das

@@ -7,8 +7,8 @@ let THRESHOLD = 500
 
 // SQL: SELECT ... LIMIT 1 — engine stops at first hit.
 // m3 materializes the full filtered array then indexes [0].
-// m3f_old / m3f should ideally early-exit at the first matching row;
-// splice mode is the main target here.
+// m3f should ideally early-exit at the first matching row; splice mode
+// is the main target here.
 
 def run_m1(b : B?; n : int) {
     with_sqlite(":memory:") $(db) {
@@ -31,17 +31,6 @@ def run_m3(b : B?; n : int) {
         }
     }
 }
-
-def run_m3f_old(b : B?; n : int) {
-    let arr <- fixture_array(n)
-    b |> run("m3f_old_array_fold/{n}", n) {
-        let row = _old_fold(each(arr)._where(_.price > THRESHOLD).first())
-        if (row.price == 0) {
-            b->failNow()
-        }
-    }
-}
-
 def run_m3f(b : B?; n : int) {
     let arr <- fixture_array(n)
     b |> run("m3f_array_fold/{n}", n) {
@@ -62,11 +51,6 @@ def first_match_m3(b : B?) {
     run_m3(b, 100000)
 }
 
-[benchmark]
-def first_match_m3f_old(b : B?) {
-    run_m3f_old(b, 100000)
-}
-
 [benchmark]
 def first_match_m3f(b : B?) {
     run_m3f(b, 100000)