From 33f77facc22a0e5007e4893aff8a39b35cd104de Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 12:25:43 -0800 Subject: [PATCH 1/9] working on better perf --- dag_in_context/src/schedule.rs | 4 +- dag_in_context/src/utility/terms.egg | 58 ++++++++++++++++++++++------ src/rvsdg/optimize_direct_jumps.rs | 4 +- 3 files changed, 51 insertions(+), 15 deletions(-) diff --git a/dag_in_context/src/schedule.rs b/dag_in_context/src/schedule.rs index faa9a66b3..9e3b769d6 100644 --- a/dag_in_context/src/schedule.rs +++ b/dag_in_context/src/schedule.rs @@ -52,7 +52,9 @@ pub(crate) fn helpers() -> String { (saturate canon) (saturate interval-analysis) - (saturate terms) + (saturate + terms + (saturate terms-helpers)) ;; memory-helpers TODO run memory helpers for memory optimizations ;; finally, subsume now that helpers are done diff --git a/dag_in_context/src/utility/terms.egg b/dag_in_context/src/utility/terms.egg index f6c223655..eb372ac7f 100644 --- a/dag_in_context/src/utility/terms.egg +++ b/dag_in_context/src/utility/terms.egg @@ -1,35 +1,69 @@ (ruleset terms) +(ruleset terms-helpers) (sort TermAndCost) (function Smaller (TermAndCost TermAndCost) TermAndCost) (function ExtractedExpr (Expr) TermAndCost :merge (Smaller old new)) +;; potential extractions- use so that we don't modify the +;; timestamp of ExtractedExpr when the costs are equal +(relation PotentialExtractedExpr (Expr TermAndCost)) (function TCPair (Term i64) TermAndCost) +(function NoTerm () Term) + +;; set extracted expr to default value +(rule ((PotentialExtractedExpr expr termandcost)) + ((set (ExtractedExpr expr) (TCPair (NoTerm) 10000000000000000))) + :ruleset terms-helpers) + +;; set extracted expr to new value as long as not equal +(rule ((PotentialExtractedExpr expr (TCPair term cost)) + (= (ExtractedExpr expr) (TCPair oldterm oldcost)) + (< cost oldcost)) + ((set (ExtractedExpr expr) (TCPair term cost))) + :ruleset terms-helpers) + +;; if the cost is negative panic, terms got too big +(rule ((PotentialExtractedExpr expr (TCPair term cost)) + (< cost 0)) + ((panic "Negative cost")) + :ruleset terms-helpers) + ;; Resolve Smaller (rule ( (= lhs (Smaller (TCPair t1 cost1) (TCPair t2 cost2))) - (<= cost1 cost2) + (< cost1 cost2) ) ((union lhs (TCPair t1 cost1))) - :ruleset terms) + :ruleset terms-helpers) (rule ( (= lhs (Smaller (TCPair t1 cost1) (TCPair t2 cost2))) (> cost1 cost2) ) ((union lhs (TCPair t2 cost2))) - :ruleset terms) + :ruleset terms-helpers) + + +(rule ( + (= lhs (Smaller (TCPair t1 cost1) (TCPair t2 cost2))) + (= cost1 cost2) + (!= t1 t2) + ) + ((panic "Should have been handled by PotentialExtractedExpr")) + :ruleset terms-helpers) + ; Compute smallest Expr bottom-up (rule ((= lhs (Const c ty ass))) - ((set (ExtractedExpr lhs) (TCPair (TermConst c) 1))) + ((PotentialExtractedExpr lhs (TCPair (TermConst c) 1))) :ruleset terms) (rule ((= lhs (Arg ty ass))) - ((set (ExtractedExpr lhs) (TCPair (TermArg) 1))) + ((PotentialExtractedExpr lhs (TCPair (TermArg) 1))) :ruleset terms) (rule ( @@ -37,7 +71,7 @@ (= (TCPair t1 c1) (ExtractedExpr e1)) (= (TCPair t2 c2) (ExtractedExpr e2)) ) - ((set (ExtractedExpr lhs) (TCPair (TermBop o t1 t2) (+ 1 (+ c1 c2))))) + ((PotentialExtractedExpr lhs (TCPair (TermBop o t1 t2) (+ 1 (+ c1 c2))))) :ruleset terms) (rule ( @@ -46,14 +80,14 @@ (= (TCPair t2 c2) (ExtractedExpr e2)) (= (TCPair t3 c3) (ExtractedExpr e3)) ) - ((set (ExtractedExpr lhs) (TCPair (TermTop o t1 t2 t3) (+ (+ 1 c1) (+ c2 c3))))) + ((PotentialExtractedExpr lhs (TCPair (TermTop o t1 t2 t3) (+ (+ 1 c1) (+ c2 c3))))) :ruleset terms) (rule ( (= lhs (Uop o e1)) (= (TCPair t1 c1) (ExtractedExpr e1)) ) - ((set (ExtractedExpr lhs) (TCPair (TermUop o t1) (+ 1 c1)))) + ((PotentialExtractedExpr lhs (TCPair (TermUop o t1) (+ 1 c1)))) :ruleset terms) (rule ( @@ -61,7 +95,7 @@ (= (TCPair t1 c1) (ExtractedExpr tup)) ) ; cost of the get is the same as the cost of the whole tuple - ((set (ExtractedExpr lhs) (TCPair (TermGet t1 i) c1))) + ((PotentialExtractedExpr lhs (TCPair (TermGet t1 i) c1))) :ruleset terms) ; todo Alloc @@ -73,7 +107,7 @@ (= (TCPair t1 c1) (ExtractedExpr e1)) ) ; cost of single is same as cost of the element - ((set (ExtractedExpr lhs) (TCPair (TermSingle t1) c1))) + ((PotentialExtractedExpr lhs (TCPair (TermSingle t1) c1))) :ruleset terms) (rule ( @@ -82,7 +116,7 @@ (= (TCPair t2 c2) (ExtractedExpr e2)) ) ; cost of concat is sum of the costs - ((set (ExtractedExpr lhs) (TCPair (TermConcat t1 t2) (+ c1 c2)))) + ((PotentialExtractedExpr lhs (TCPair (TermConcat t1 t2) (+ c1 c2)))) :ruleset terms) @@ -95,7 +129,7 @@ ; (= (TCPair t4 c4) (ExtractedExpr els)) ; ) ; ; cost of if is 10 + cost of pred + cost of input + max of branch costs -; ((set (ExtractedExpr lhs) (TCPair (TermIf t1 t2 t3 t4) (+ 10 (+ (+ c1 c2) (max c3 c4)))))) +; ((PotentialExtractedExpr lhs (TCPair (TermIf t1 t2 t3 t4) (+ 10 (+ (+ c1 c2) (max c3 c4)))))) ; :ruleset terms) (sort Node) diff --git a/src/rvsdg/optimize_direct_jumps.rs b/src/rvsdg/optimize_direct_jumps.rs index f0fc80e4f..e949091fe 100644 --- a/src/rvsdg/optimize_direct_jumps.rs +++ b/src/rvsdg/optimize_direct_jumps.rs @@ -30,8 +30,8 @@ impl SimpleCfgFunction { .fuse_down() .fuze_up() .fuze_up() - .return_early() - .return_early() + //.return_early() + //.return_early() .collapse_empty_blocks() .collapse_empty_blocks(); res.remove_unreachable(); From 6ad3a9ded1f75c56d327b5e5fd5812fc940231ce Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 14:02:35 -0800 Subject: [PATCH 2/9] select type analysis --- dag_in_context/src/type_analysis.egg | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/dag_in_context/src/type_analysis.egg b/dag_in_context/src/type_analysis.egg index e0c6ac42e..07088a4b3 100644 --- a/dag_in_context/src/type_analysis.egg +++ b/dag_in_context/src/type_analysis.egg @@ -245,6 +245,30 @@ ((panic "(Load) expected pointer, received tuple")) :ruleset error-checking) +(rule ( + (= lhs (Top (Select) pred v1 v2)) + ) + ((ExpectType pred (Base (BoolT)) "(Select)")) + :ruleset type-analysis) + +(rule ( + (= lhs (Top (Select) pred v1 v2)) + (HasType v1 ty) + (HasType v2 ty) + ) + ((HasType lhs ty)) + :ruleset type-analysis) + +(rule ( + (= lhs (Top (Select) pred v1 v2)) + (HasType v1 ty1) + (HasType v2 ty2) + (!= ty1 ty2) + ) + ((panic "(Select) branches had different types")) + :ruleset error-checking) + + ; Binary ops ;; Operators that have type Type -> Type -> Type From bf317aa938318102c26a79fd3883c2f4d1ec0385 Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 14:20:48 -0800 Subject: [PATCH 3/9] evil hack complete --- dag_in_context/src/utility/terms.egg | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dag_in_context/src/utility/terms.egg b/dag_in_context/src/utility/terms.egg index eb372ac7f..3ef4c1bc3 100644 --- a/dag_in_context/src/utility/terms.egg +++ b/dag_in_context/src/utility/terms.egg @@ -51,9 +51,9 @@ (rule ( (= lhs (Smaller (TCPair t1 cost1) (TCPair t2 cost2))) (= cost1 cost2) - (!= t1 t2) ) - ((panic "Should have been handled by PotentialExtractedExpr")) + ;; arbitrarily pick first one + ((union lhs (TCPair t1 cost1))) :ruleset terms-helpers) From 7661cadf01457223c46d7ffd4524383d1b7097b9 Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 14:21:51 -0800 Subject: [PATCH 4/9] revert debug change --- src/rvsdg/optimize_direct_jumps.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/rvsdg/optimize_direct_jumps.rs b/src/rvsdg/optimize_direct_jumps.rs index e949091fe..f0fc80e4f 100644 --- a/src/rvsdg/optimize_direct_jumps.rs +++ b/src/rvsdg/optimize_direct_jumps.rs @@ -30,8 +30,8 @@ impl SimpleCfgFunction { .fuse_down() .fuze_up() .fuze_up() - //.return_early() - //.return_early() + .return_early() + .return_early() .collapse_empty_blocks() .collapse_empty_blocks(); res.remove_unreachable(); From 2420328d4706ae25b9491b3702dc946ef61aad07 Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 14:21:57 -0800 Subject: [PATCH 5/9] extra test --- .../simple_select_after_block_diamond.bril | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 tests/passing/small/simple_select_after_block_diamond.bril diff --git a/tests/passing/small/simple_select_after_block_diamond.bril b/tests/passing/small/simple_select_after_block_diamond.bril new file mode 100644 index 000000000..699ac0f9e --- /dev/null +++ b/tests/passing/small/simple_select_after_block_diamond.bril @@ -0,0 +1,20 @@ +# ARGS: 1 +@main(v0: int) { + c1_: int = const 1; + c2_: int = const 2; + v3_: bool = lt v0 c2_; + c4_: int = const 4; + v5_: int = select v3_ c4_ c1_; + v6_: int = id v5_; + v7_: int = id c1_; + br v3_ .b8_ .b9_; +.b9_: + v10_: int = add c2_ v5_; + v6_: int = id v10_; + v7_: int = id c1_; +.b8_: + v11_: int = add c1_ v6_; + print v11_; + ret; +} + From 2dbc6c41257e81b903a14e1279f7a50ed8a27214 Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 14:24:55 -0800 Subject: [PATCH 6/9] snapshots --- ...__branch_hoisting-optimize-sequential.snap | 45 +++++++++------- .../files__branch_hoisting-optimize.snap | 16 +++--- ...riant_code_motion-optimize-sequential.snap | 53 +++++++++++-------- ...eduction_modified-optimize-sequential.snap | 45 +++++++++++----- ...ter_block_diamond-optimize-sequential.snap | 17 ++++++ ...e_select_after_block_diamond-optimize.snap | 17 ++++++ 6 files changed, 132 insertions(+), 61 deletions(-) create mode 100644 tests/snapshots/files__simple_select_after_block_diamond-optimize-sequential.snap create mode 100644 tests/snapshots/files__simple_select_after_block_diamond-optimize.snap diff --git a/tests/snapshots/files__branch_hoisting-optimize-sequential.snap b/tests/snapshots/files__branch_hoisting-optimize-sequential.snap index 38b493dd8..d6c27fd7c 100644 --- a/tests/snapshots/files__branch_hoisting-optimize-sequential.snap +++ b/tests/snapshots/files__branch_hoisting-optimize-sequential.snap @@ -6,28 +6,33 @@ expression: visualization.result @main(v0: int) { c1_: int = const 0; c2_: int = const 500; - v3_: int = id c1_; + v3_: bool = eq c1_ v0; v4_: int = id c1_; - v5_: int = id v0; - v6_: int = id c1_; - v7_: int = id c2_; -.b8_: - v9_: bool = eq v5_ v6_; - c10_: int = const 2; - v11_: int = mul c10_ v4_; - c12_: int = const 3; - v13_: int = mul c12_ v4_; - v14_: int = select v9_ v11_ v13_; - c15_: int = const 1; - v16_: int = add c15_ v4_; - v17_: bool = lt v16_ v7_; - v3_: int = id v14_; - v4_: int = id v16_; - v5_: int = id v5_; + v5_: int = id c1_; + v6_: int = id v0; + v7_: int = id c1_; + v8_: int = id c2_; + v9_: bool = id v3_; +.b10_: + c11_: int = const 1; + v12_: int = add c11_ v5_; + v13_: int = add c11_ v12_; + v14_: int = add c11_ v13_; + c15_: int = const 2; + v16_: int = mul c15_ v14_; + c17_: int = const 3; + v18_: int = mul c17_ v14_; + v19_: int = select v9_ v16_ v18_; + v20_: int = add c11_ v14_; + v21_: bool = lt v20_ v8_; + v4_: int = id v19_; + v5_: int = id v20_; v6_: int = id v6_; v7_: int = id v7_; - br v17_ .b8_ .b18_; -.b18_: - print v3_; + v8_: int = id v8_; + v9_: bool = id v9_; + br v21_ .b10_ .b22_; +.b22_: + print v4_; ret; } diff --git a/tests/snapshots/files__branch_hoisting-optimize.snap b/tests/snapshots/files__branch_hoisting-optimize.snap index 68b7a124a..21f98990f 100644 --- a/tests/snapshots/files__branch_hoisting-optimize.snap +++ b/tests/snapshots/files__branch_hoisting-optimize.snap @@ -19,16 +19,16 @@ expression: visualization.result v13_: int = id c3_; .b14_: v15_: bool = eq v11_ v12_; - c16_: int = const 2; - c17_: int = const 1; - v18_: int = add c17_ v10_; - v19_: int = add c17_ v18_; - v20_: int = add c17_ v19_; - v21_: int = mul c16_ v20_; + c16_: int = const 1; + v17_: int = add c16_ v10_; + v18_: int = add c16_ v17_; + v19_: int = add c16_ v18_; + c20_: int = const 2; + v21_: int = mul c20_ v19_; c22_: int = const 3; - v23_: int = mul c22_ v20_; + v23_: int = mul c22_ v19_; v24_: int = select v15_ v21_ v23_; - v25_: int = add c17_ v20_; + v25_: int = add c16_ v19_; v26_: bool = lt v25_ v13_; v9_: int = id v24_; v10_: int = id v25_; diff --git a/tests/snapshots/files__loop_invariant_code_motion-optimize-sequential.snap b/tests/snapshots/files__loop_invariant_code_motion-optimize-sequential.snap index ea91a88fb..6d94bab8a 100644 --- a/tests/snapshots/files__loop_invariant_code_motion-optimize-sequential.snap +++ b/tests/snapshots/files__loop_invariant_code_motion-optimize-sequential.snap @@ -7,26 +7,37 @@ expression: visualization.result c2_: int = const 0; c3_: int = const 1; c4_: int = const 20; - v5_: int = id c2_; - v6_: int = id c3_; - v7_: int = id v1; - v8_: int = id v0; - v9_: int = id c4_; -.b10_: - v11_: int = mul v8_ v9_; - v12_: bool = lt v11_ v7_; - v13_: int = add v11_ v6_; - v14_: int = select v12_ v13_ v11_; - v15_: int = mul v14_ v5_; - print v15_; - v16_: int = add v5_ v6_; - v17_: bool = lt v16_ v9_; - v5_: int = id v16_; - v6_: int = id v6_; - v7_: int = id v7_; - v8_: int = id v8_; - v9_: int = id v9_; - br v17_ .b10_ .b18_; -.b18_: + v5_: int = mul c4_ v0; + v6_: bool = lt v5_ v1; + v7_: int = add c3_ v5_; + v8_: int = select v6_ v7_ v5_; + v9_: int = id c2_; + v10_: int = id c3_; + v11_: int = id v1; + v12_: int = id v0; + v13_: int = id c4_; + v14_: int = id v8_; +.b15_: + v16_: int = add v10_ v9_; + v17_: int = add v10_ v16_; + v18_: int = add v10_ v17_; + v19_: int = mul v14_ v18_; + v20_: int = mul v14_ v17_; + v21_: int = mul v14_ v16_; + v22_: int = mul v14_ v9_; + print v22_; + print v21_; + print v20_; + print v19_; + v23_: int = add v10_ v18_; + v24_: bool = lt v23_ v13_; + v9_: int = id v23_; + v10_: int = id v10_; + v11_: int = id v11_; + v12_: int = id v12_; + v13_: int = id v13_; + v14_: int = id v14_; + br v24_ .b15_ .b25_; +.b25_: ret; } diff --git a/tests/snapshots/files__loop_strength_reduction_modified-optimize-sequential.snap b/tests/snapshots/files__loop_strength_reduction_modified-optimize-sequential.snap index 9b3df8cb6..44964d214 100644 --- a/tests/snapshots/files__loop_strength_reduction_modified-optimize-sequential.snap +++ b/tests/snapshots/files__loop_strength_reduction_modified-optimize-sequential.snap @@ -18,22 +18,43 @@ expression: visualization.result v11_: int = id c4_; v12_: int = id c5_; .b13_: - v14_: int = mul v11_ v8_; - print v14_; - v15_: int = add v6_ v7_; - v16_: bool = eq v10_ v6_; - v17_: int = add v7_ v8_; - v18_: int = add v17_ v9_; - v19_: int = select v16_ v18_ v17_; - v20_: bool = lt v15_ v12_; - v6_: int = id v15_; + v14_: int = add v6_ v7_; + v15_: int = add v14_ v7_; + v16_: bool = eq v10_ v15_; + v17_: bool = eq v10_ v14_; + v18_: bool = eq v10_ v6_; + v19_: int = add v7_ v8_; + v20_: int = add v19_ v9_; + v21_: int = select v18_ v20_ v19_; + v22_: int = add v21_ v7_; + v23_: int = add v22_ v9_; + v24_: int = select v17_ v23_ v22_; + v25_: int = add v24_ v7_; + v26_: int = add v25_ v9_; + v27_: int = select v16_ v26_ v25_; + v28_: int = mul v11_ v27_; + v29_: int = mul v11_ v24_; + v30_: int = mul v11_ v21_; + v31_: int = mul v11_ v8_; + print v31_; + print v30_; + print v29_; + print v28_; + v32_: int = add v15_ v7_; + v33_: int = add v32_ v7_; + v34_: bool = eq v10_ v32_; + v35_: int = add v27_ v7_; + v36_: int = add v35_ v9_; + v37_: int = select v34_ v36_ v35_; + v38_: bool = lt v33_ v12_; + v6_: int = id v33_; v7_: int = id v7_; - v8_: int = id v19_; + v8_: int = id v37_; v9_: int = id v9_; v10_: int = id v10_; v11_: int = id v11_; v12_: int = id v12_; - br v20_ .b13_ .b21_; -.b21_: + br v38_ .b13_ .b39_; +.b39_: ret; } diff --git a/tests/snapshots/files__simple_select_after_block_diamond-optimize-sequential.snap b/tests/snapshots/files__simple_select_after_block_diamond-optimize-sequential.snap new file mode 100644 index 000000000..8a4663283 --- /dev/null +++ b/tests/snapshots/files__simple_select_after_block_diamond-optimize-sequential.snap @@ -0,0 +1,17 @@ +--- +source: tests/files.rs +expression: visualization.result +--- +# ARGS: 1 +@main(v0: int) { + c1_: int = const 2; + v2_: bool = lt v0 c1_; + c3_: int = const 4; + c4_: int = const 1; + v5_: int = select v2_ c3_ c4_; + v6_: int = add c1_ v5_; + v7_: int = select v2_ v5_ v6_; + v8_: int = add c4_ v7_; + print v8_; + ret; +} diff --git a/tests/snapshots/files__simple_select_after_block_diamond-optimize.snap b/tests/snapshots/files__simple_select_after_block_diamond-optimize.snap new file mode 100644 index 000000000..8a4663283 --- /dev/null +++ b/tests/snapshots/files__simple_select_after_block_diamond-optimize.snap @@ -0,0 +1,17 @@ +--- +source: tests/files.rs +expression: visualization.result +--- +# ARGS: 1 +@main(v0: int) { + c1_: int = const 2; + v2_: bool = lt v0 c1_; + c3_: int = const 4; + c4_: int = const 1; + v5_: int = select v2_ c3_ c4_; + v6_: int = add c1_ v5_; + v7_: int = select v2_ v5_ v6_; + v8_: int = add c4_ v7_; + print v8_; + ret; +} From e0b347b3191cf0ee32105b01416adb933eacb6ce Mon Sep 17 00:00:00 2001 From: oflatt Date: Thu, 6 Feb 2025 14:42:02 -0800 Subject: [PATCH 7/9] more optimizations --- dag_in_context/src/optimizations/select.egg | 19 ++++++++++--------- dag_in_context/src/schedule.rs | 4 +++- dag_in_context/src/utility/terms.egg | 7 ++++--- 3 files changed, 17 insertions(+), 13 deletions(-) diff --git a/dag_in_context/src/optimizations/select.egg b/dag_in_context/src/optimizations/select.egg index be21fe28e..b43edace0 100644 --- a/dag_in_context/src/optimizations/select.egg +++ b/dag_in_context/src/optimizations/select.egg @@ -1,19 +1,20 @@ (ruleset select_opt) + +;; inlined (Get thn i) makes the query faster ): (rule ( (= if_e (If pred inputs thn els)) - (ContextOf if_e ctx) - (= thn_out (Get thn i)) - (= els_out (Get els i)) - (ExprIsPure thn_out) - (ExprIsPure els_out) + (ExprIsPure (Get thn i)) + (ExprIsPure (Get els i)) - (> 10 (Expr-size thn_out)) ; TODO: Tune these size limits - (> 10 (Expr-size els_out)) - (= (TCPair t1 c1) (ExtractedExpr thn_out)) - (= (TCPair t2 c2) (ExtractedExpr els_out)) + (> 10 (Expr-size (Get thn i))) ; TODO: Tune these size limits + (> 10 (Expr-size (Get els i))) + (= (TCPair t1 c1) (ExtractedExpr (Get thn i))) + (= (TCPair t2 c2) (ExtractedExpr (Get els i))) + + (ContextOf if_e ctx) ) ( (union (Get if_e i) diff --git a/dag_in_context/src/schedule.rs b/dag_in_context/src/schedule.rs index 9e3b769d6..34963de39 100644 --- a/dag_in_context/src/schedule.rs +++ b/dag_in_context/src/schedule.rs @@ -54,7 +54,9 @@ pub(crate) fn helpers() -> String { (saturate interval-analysis) (saturate terms - (saturate terms-helpers)) + (saturate + terms-helpers + (saturate terms-helpers-helpers))) ;; memory-helpers TODO run memory helpers for memory optimizations ;; finally, subsume now that helpers are done diff --git a/dag_in_context/src/utility/terms.egg b/dag_in_context/src/utility/terms.egg index 3ef4c1bc3..9cf5f9a2f 100644 --- a/dag_in_context/src/utility/terms.egg +++ b/dag_in_context/src/utility/terms.egg @@ -1,5 +1,6 @@ (ruleset terms) (ruleset terms-helpers) +(ruleset terms-helpers-helpers) (sort TermAndCost) (function Smaller (TermAndCost TermAndCost) TermAndCost) @@ -38,14 +39,14 @@ (< cost1 cost2) ) ((union lhs (TCPair t1 cost1))) - :ruleset terms-helpers) + :ruleset terms-helpers-helpers) (rule ( (= lhs (Smaller (TCPair t1 cost1) (TCPair t2 cost2))) (> cost1 cost2) ) ((union lhs (TCPair t2 cost2))) - :ruleset terms-helpers) + :ruleset terms-helpers-helpers) (rule ( @@ -54,7 +55,7 @@ ) ;; arbitrarily pick first one ((union lhs (TCPair t1 cost1))) - :ruleset terms-helpers) + :ruleset terms-helpers-helpers) ; Compute smallest Expr bottom-up From 8719c4f752f946dc7b06107ff5bf40a8d0cc09c9 Mon Sep 17 00:00:00 2001 From: oliver Date: Mon, 10 Feb 2025 09:14:25 -0800 Subject: [PATCH 8/9] some comments --- dag_in_context/src/utility/terms.egg | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/dag_in_context/src/utility/terms.egg b/dag_in_context/src/utility/terms.egg index 9cf5f9a2f..302b47ff7 100644 --- a/dag_in_context/src/utility/terms.egg +++ b/dag_in_context/src/utility/terms.egg @@ -1,5 +1,7 @@ (ruleset terms) +;; helpers keeps track of the new best extracted terms (ruleset terms-helpers) +;; helpers-helpers runs `Smaller` rules, resolving the merge function for helpers (ruleset terms-helpers-helpers) (sort TermAndCost) @@ -7,8 +9,8 @@ (function ExtractedExpr (Expr) TermAndCost :merge (Smaller old new)) -;; potential extractions- use so that we don't modify the -;; timestamp of ExtractedExpr when the costs are equal +;; potential extractions- use so that when the costs are equal, we don't change the term +;; this preserves egglog's timestamp of when the last time ExtractedExpr was changed, fixing a big performance problem (relation PotentialExtractedExpr (Expr TermAndCost)) (function TCPair (Term i64) TermAndCost) From dd17c4655e721d00c0f44f4a9d903be359c6b724 Mon Sep 17 00:00:00 2001 From: oflatt Date: Mon, 10 Feb 2025 11:42:43 -0800 Subject: [PATCH 9/9] snapshot --- ...es__block-diamond-optimize-sequential.snap | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/tests/snapshots/files__block-diamond-optimize-sequential.snap b/tests/snapshots/files__block-diamond-optimize-sequential.snap index 4beedd492..953ce41fc 100644 --- a/tests/snapshots/files__block-diamond-optimize-sequential.snap +++ b/tests/snapshots/files__block-diamond-optimize-sequential.snap @@ -4,30 +4,30 @@ expression: visualization.result --- # ARGS: 1 @main(v0: int) { - c1_: int = const 2; - v2_: bool = lt v0 c1_; - c3_: int = const 1; - v4_: int = id c3_; - v5_: int = id c3_; - v6_: int = id c1_; - br v2_ .b7_ .b8_; + c1_: int = const 1; + c2_: int = const 2; + v3_: bool = lt v0 c2_; + v4_: int = id c1_; + v5_: int = id c1_; + v6_: int = id c2_; + br v3_ .b7_ .b8_; .b7_: c9_: bool = const true; c10_: int = const 4; - v11_: int = select c9_ c10_ c1_; + v11_: int = select c9_ c10_ c2_; v4_: int = id v11_; - v5_: int = id c3_; - v6_: int = id c1_; - v12_: int = add c1_ v4_; - v13_: int = select v2_ v4_ v12_; - v14_: int = add c3_ v13_; + v5_: int = id c1_; + v6_: int = id c2_; + v12_: int = add c2_ v4_; + v13_: int = select v3_ v4_ v12_; + v14_: int = add c1_ v13_; print v14_; ret; jmp .b15_; .b8_: - v12_: int = add c1_ v4_; - v13_: int = select v2_ v4_ v12_; - v14_: int = add c3_ v13_; + v12_: int = add c2_ v4_; + v13_: int = select v3_ v4_ v12_; + v14_: int = add c1_ v13_; print v14_; ret; .b15_: