Merge pull request #457 from herbie-fp/remove-egraph-addresults

Remove `EGraphAddResult`

Author: bksaiki

egg-herbie/egg-interface.rkt

@@ -5,13 +5,12 @@
          racket/runtime-path)
 
 (provide egraph_create egraph_destroy egraph_add_expr
-         egraph_addresult_destroy egraph_run egraph_run_with_iter_limit
+         egraph_run egraph_run_with_iter_limit
          egraph_get_stop_reason
          egraph_get_simplest egraph_get_variants
          _EGraphIter destroy_egraphiters egraph_get_cost
          egraph_is_unsound_detected egraph_get_times_applied
          destroy_string
-         (struct-out EGraphAddResult)
          (struct-out EGraphIter)
          (struct-out FFIRule))
 
@@ -27,10 +26,6 @@
 
 (define _egraph-pointer (_cpointer 'egraph))
 
-(define-cstruct _EGraphAddResult
-  ([id _uint]
-   [successp _bool]))
-
 (define-cstruct _EGraphIter
   ([numnodes _uint]
    [numeclasses _uint]
@@ -51,9 +46,7 @@
 (define-eggmath destroy_string (_fun _pointer -> _void))
 
 ;; egraph pointer, s-expr string -> node number
-(define-eggmath egraph_add_expr (_fun _egraph-pointer _string/utf-8 -> _EGraphAddResult-pointer))
-
-(define-eggmath egraph_addresult_destroy (_fun _EGraphAddResult-pointer -> _void))
+(define-eggmath egraph_add_expr (_fun _egraph-pointer _string/utf-8 -> _uint))
 
 (define-eggmath destroy_egraphiters (_fun _uint _EGraphIter-pointer -> _void))
 

egg-herbie/main.rkt

@@ -6,7 +6,7 @@
 
 (module+ test (require rackunit))
 
-(provide egraph-run egraph-add-exprs with-egraph
+(provide egraph-run egraph-add-expr with-egraph
          egraph-get-simplest egraph-get-variants
          egg-expr->expr egg-exprs->exprs egg-add-exn?
          make-ffi-rules free-ffi-rules egraph-get-cost
@@ -166,34 +166,14 @@
 (struct egg-add-exn exn:fail ())
 
 ;; result function is a function that takes the ids of the nodes
-;; egraph-add-exprs returns the result of result-function
-(define (egraph-add-exprs eg-data exprs result-function)
-  (define egg-exprs
-    (map
-     (lambda (expr) (expr->egg-expr expr eg-data))
-     exprs))
-    
-  (define expr-results
-    (map
-     (lambda (expr)
-       (egraph_add_expr (egraph-data-egraph-pointer eg-data) expr))
-     egg-exprs))
-  
-  (define node-ids
-    (for/list ([result expr-results])
-      (if (EGraphAddResult-successp result)
-          (EGraphAddResult-id result)
-          (raise (egg-add-exn
-               (string-append "Failed to add expr to egraph")
-               (current-continuation-marks))))))
-
-  (define res (result-function node-ids))
-
-  (for/list ([result expr-results])
-    (egraph_addresult_destroy result))
-
-  res)
-
+(define (egraph-add-expr eg-data expr)
+  (define egg-expr (expr->egg-expr expr eg-data))
+  (define result (egraph_add_expr (egraph-data-egraph-pointer eg-data) egg-expr))
+  (when (= result 0)
+    (raise (egg-add-exn
+            "Failed to add expr to egraph"
+            (current-continuation-marks))))
+  (- result 1))
 
 (module+ test
 

egg-herbie/src/lib.rs

@@ -43,11 +43,6 @@ pub unsafe extern "C" fn egraph_destroy(ptr: *mut Context) {
     std::mem::drop(Box::from_raw(ptr))
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn egraph_addresult_destroy(ptr: *mut EGraphAddResult) {
-    std::mem::drop(Box::from_raw(ptr))
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn destroy_egraphiters(size: u32, ptr: *mut EGraphIter) {
     let _array: &[EGraphIter] = slice::from_raw_parts(ptr, size as usize);
@@ -58,13 +53,6 @@ pub unsafe extern "C" fn destroy_string(ptr: *mut c_char) {
     let _str = CString::from_raw(ptr);
 }
 
-// a struct to report failure if the add fails
-#[repr(C)]
-pub struct EGraphAddResult {
-    id: u32,
-    successp: bool,
-}
-
 #[repr(C)]
 pub struct EGraphIter {
     numnodes: u32,
@@ -110,10 +98,7 @@ fn runner_egraphiters(runner: &Runner) -> *mut EGraphIter {
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn egraph_add_expr(
-    ptr: *mut Context,
-    expr: *const c_char,
-) -> *mut EGraphAddResult {
+pub unsafe extern "C" fn egraph_add_expr(ptr: *mut Context, expr: *const c_char) -> u32 {
     ffirun(|| {
         let _ = env_logger::try_init();
         let ctx = &mut *ptr;
@@ -125,20 +110,18 @@ pub unsafe extern "C" fn egraph_add_expr(
         assert_eq!(ctx.iteration, 0);
 
         let result = match cstring_to_recexpr(expr) {
-            None => EGraphAddResult {
-                id: 0,
-                successp: false,
-            },
+            None => 0 as u32,
             Some(rec_expr) => {
                 runner = runner.with_expr(&rec_expr);
                 let id = *runner.roots.last().unwrap();
                 let id = usize::from(id) as u32;
-                EGraphAddResult { id, successp: true }
+                assert!(id < u32::MAX);
+                id + 1 as u32
             }
         };
 
         ctx.runner = Some(runner);
-        Box::into_raw(Box::new(result))
+        result
     })
 }
 

src/core/matcher.rkt

@@ -95,40 +95,37 @@
     (define result-thunk
       (with-egraph
         (λ (egg-graph)
-          (egraph-add-exprs
-            egg-graph
-            exprs
-            (λ (node-ids)
-              (define iter-data (egg-run-rules egg-graph #:limit iter-limit (*node-limit*) irules node-ids #t))
-              (for ([rule rules])
-                (define count (egraph-get-times-applied egg-graph (rule-name rule)))
-                (when (> count 0) (timeline-push! 'rules (~a (rule-name rule)) count)))
-              (cond
-              [(egraph-is-unsound-detected egg-graph)
-                ; unsoundness detected, fallback
-                (match* (exprs iter-limit)
-                 [((list (? list?) (? list?) (? list?) ...) #f)     ; run expressions individually
-                  (λ ()
-                    (for/list ([expr exprs] [root-loc root-locs])
-                      (timeline-push! 'method "egg-rewrite")
-                      (car (loop (list expr) (list root-loc) #f))))]
-                 [((list (? list?)) #f)                             ; run expressions with iter limit
-                  (λ ()
-                    (let ([limit (- (length iter-data) 2)])
-                      (timeline-push! 'method "egg-rewrite-iter-limit")
-                      (loop exprs root-locs limit)))]
-                 [(_ (? number?))                                   ; give up
-                  (timeline-push! 'method "egg-rewrite-fail")
-                  (λ () '(()))])]
-              [else
-                (define variants
-                  (for/list ([id node-ids] [expr exprs] [root-loc root-locs] [expr-repr reprs])
-                    (define egg-rule (rule "egg-rr" 'x 'x (list expr-repr) expr-repr))
-                    (define output (egraph-get-variants egg-graph id expr))
-                    (define extracted (egg-exprs->exprs output egg-graph))
-                    (for/list ([variant (remove-duplicates extracted)])
-                     (list (change egg-rule root-loc (list (cons 'x variant)))))))
-                (λ () variants)]))))))
+          (define node-ids (map (curry egraph-add-expr egg-graph) exprs))
+          (define iter-data (egg-run-rules egg-graph #:limit iter-limit (*node-limit*) irules node-ids #t))
+          (for ([rule rules])
+            (define count (egraph-get-times-applied egg-graph (rule-name rule)))
+            (when (> count 0) (timeline-push! 'rules (~a (rule-name rule)) count)))
+          (cond
+           [(egraph-is-unsound-detected egg-graph)
+            ; unsoundness detected, fallback
+            (match* (exprs iter-limit)
+              [((list (? list?) (? list?) (? list?) ...) #f)     ; run expressions individually
+              (λ ()
+                (for/list ([expr exprs] [root-loc root-locs])
+                  (timeline-push! 'method "egg-rewrite")
+                  (car (loop (list expr) (list root-loc) #f))))]
+              [((list (? list?)) #f)                             ; run expressions with iter limit
+              (λ ()
+                (let ([limit (- (length iter-data) 2)])
+                  (timeline-push! 'method "egg-rewrite-iter-limit")
+                  (loop exprs root-locs limit)))]
+              [(_ (? number?))                                   ; give up
+              (timeline-push! 'method "egg-rewrite-fail")
+              (λ () '(()))])]
+           [else
+            (define variants
+              (for/list ([id node-ids] [expr exprs] [root-loc root-locs] [expr-repr reprs])
+                (define egg-rule (rule "egg-rr" 'x 'x (list expr-repr) expr-repr))
+                (define output (egraph-get-variants egg-graph id expr))
+                (define extracted (egg-exprs->exprs output egg-graph))
+                (for/list ([variant (remove-duplicates extracted)])
+                  (list (change egg-rule root-loc (list (cons 'x variant)))))))
+            (λ () variants)]))))
     (result-thunk)))
 
 ;;  Recursive rewrite chooser

src/core/simplify.rkt

@@ -80,26 +80,21 @@
 
   (with-egraph
    (lambda (egg-graph)
-     (egraph-add-exprs
-      egg-graph
-      exprs
-      (lambda (node-ids)
-        (define iter-data (egg-run-rules egg-graph (*node-limit*) irules node-ids (and precompute? true)))
+     (define node-ids (map (curry egraph-add-expr egg-graph) exprs))
+     (define iter-data (egg-run-rules egg-graph (*node-limit*) irules node-ids (and precompute? true)))
 
-        (when (egraph-is-unsound-detected egg-graph)
-          (warn 'unsound-rules #:url "faq.html#unsound-rules"
-               "Unsound rule application detected in e-graph. Results from simplify may not be sound."))
+     (when (egraph-is-unsound-detected egg-graph)
+       (warn 'unsound-rules #:url "faq.html#unsound-rules"
+             "Unsound rule application detected in e-graph. Results from simplify may not be sound."))
 
-        (for ([rule rls])
-          (define count (egraph-get-times-applied egg-graph (rule-name rule)))
-          (when (> count 0)
-            (timeline-push! 'rules (~a (rule-name rule)) count)))
+     (for ([rule rls])
+       (define count (egraph-get-times-applied egg-graph (rule-name rule)))
+       (when (> count 0)
+         (timeline-push! 'rules (~a (rule-name rule)) count)))
 
-        (map
-         (lambda (id)
-           (for/list ([iter (in-range (length iter-data))])
-                      (egg-expr->expr (egraph-get-simplest egg-graph id iter) egg-graph)))
-         node-ids))))))
+     (for/list ([id node-ids])
+        (for/list ([iter (in-range (length iter-data))])
+          (egg-expr->expr (egraph-get-simplest egg-graph id iter) egg-graph))))))
 
 (define (stop-reason->string sr)
   (match sr