wip

Author: avanhatt

cranelift/codegen/src/egraph/elaborate.rs

@@ -248,7 +248,7 @@ impl<'a> Elaborator<'a> {
                     seen_this_traversal.remove(&x_val);
                 }
                 let (best_value_y, new_seen_y) = self.best_value_traversal(y, seen_this_traversal);
-                // Usually, right will be better. But if not, choose x and restore seen_this_traversal state
+                // Usually, y will be better. But if not, choose x and restore seen_this_traversal state
                 if best_value_x.0 < best_value_y.0 {
                     for x_val in new_seen_x.keys() {
                         seen_this_traversal.insert(x_val.clone());
@@ -316,12 +316,25 @@ impl<'a> Elaborator<'a> {
                     let best = BestEntry(cost, value);
                     union_of_new_seen[value] = best;
                     trace!(" -> cost of value {} = {:?}", value, cost);
+
+                    // AVH TODO REMOVE
+                    trace!("size of new {}", union_of_new_seen.capacity());
                     return (best, union_of_new_seen);
                 }
             }
         };
     }
 
+    // Elaborate the best value (from required/skeleton use). If we have already found a best value,
+    // we can just return that. Otherwise, we traverse the aegraph from this point, keeping track
+    // of previously seen values along argument paths to avoid double-counting DAG entries (e.g., to
+    // have a cost function that does not repeat costs for subexpressions). This involves carefully
+    // handling union nodes, only counting their values as permanently seen once a choice is made between
+    // the unioned values.
+
+    // Once the `best_value_traversal` helper is complete, we know we have found a best value for the
+    // current node, and every node newly seen in its chosen traversal. We can thus add all of these
+    // values to our per-function `value_to_best_value` map.
     fn elaborate_best_value(&mut self, value: Value) -> BestEntry {
         let best_found = self.value_to_best_value[value];
         if !best_found.1.is_reserved_value() {

cranelift/filetests/filetests/egraph/sharing.clif

@@ -2,9 +2,6 @@ test optimize
 set opt_level=speed
 target x86_64
 
-;; iadd has cost 3, imul has cost 10
-;; (rule (simplify (ireduce ty (iadd _ x y))) (iadd ty (ireduce ty x) (ireduce ty y)))
-
 function %f0(i32, i32) -> i16 {
 block0(v0: i32, v1: i32):
     v2 = imul.i32 v0, v1
@@ -31,8 +28,11 @@ block0(v0: i32, v1: i32):
     v23 = imul.i32 v22, v22
     v24 = imul.i32 v23, v23
     v25 = isub.i32 v24, v1
-    ;; Chain of imuls saturate to infinity w/o DAG cost model
-    ;; then do a rewrite to a more expensive thing
+    ;; Chain of imuls saturate to infinity with a tree cost model that ignores
+    ;; sharing. A DAG cost model that attempts to avoid double-counting shared
+    ;; subterms will not saturate. To test, invoke one of the few rewrite rules
+    ;; that rewrites to a high-cost expression:
+    ;; (rule (simplify (ireduce ty (iadd _ x y))) (iadd ty (ireduce ty x) (ireduce ty y)))
     v26 = iadd.i32 v24, v25
     v27 = ireduce.i16 v26
     v28 = ireduce.i16 v0