Merge pull request #1281 from herbie-fp/remove-more-preprocessing

Remove more preprocessing code

Author: pavpanchekha

infra/ci.rkt

@@ -47,7 +47,7 @@
     (match-define (job-result _ test status time timeline profile warnings backend) result)
     (match status
       ['success
-       (match-define (improve-result preprocess _ start targets end) backend)
+       (match-define (improve-result _ start targets end) backend)
        (match-define (alt-analysis start-alt start-error) start)
        (match-define (alt-analysis end-alt end-error) (first end))
 

src/api/datafile.rkt

@@ -17,7 +17,6 @@
         (name identifier
               status
               pre
-              preprocess
               precision
               conversions
               vars
@@ -98,7 +97,6 @@
                              identifier
                              status
                              pre
-                             preprocess
                              prec
                              conversions
                              vars
@@ -126,7 +124,6 @@
                  (list cost error (~a expr))))]))
     (make-hash `((name . ,name) (identifier . ,(~s identifier))
                                 (pre . ,(~s pre))
-                                (preprocess . ,(~s preprocess))
                                 (prec . ,(~s prec))
                                 (bits . ,(representation-total-bits (get-representation prec)))
                                 (conversions . ,(map (curry map ~s) conversions))
@@ -207,7 +204,6 @@
                               (parse-string (hash-ref test 'identifier "#f"))
                               (get 'status)
                               (parse-string (hash-ref test 'pre "TRUE"))
-                              (parse-string (hash-ref test 'preprocess "()"))
                               (parse-string (hash-ref test 'prec "binary64"))
                               (let ([cs (hash-ref test 'conversions "()")])
                                 (if (string? cs)

src/api/run.rkt

@@ -31,7 +31,6 @@
         (table-row-target-prog row)
         (fpcore->prog (table-row-spec row) ctx)
         (fpcore->prog (table-row-pre row) ctx)
-        (table-row-preprocess row)
         (representation-name repr)
         (for/list ([(k v) (in-dict var-reprs)])
           (cons k (representation-name v)))

src/api/sandbox.rkt

@@ -20,7 +20,6 @@
          "../syntax/platform.rkt"
          "../core/points.rkt"
          "../core/explain.rkt"
-         "../core/preprocess.rkt"
          "../utils/profile.rkt"
          "../utils/timeline.rkt"
          (submod "../utils/timeline.rkt" debug))
@@ -33,7 +32,7 @@
          (struct-out alt-analysis))
 
 (struct job-result (command test status time timeline profile warnings backend))
-(struct improve-result (preprocess pcontext start target end))
+(struct improve-result (pcontext start target end))
 (struct alt-analysis (alt errors) #:prefab)
 
 ;; API users can supply their own, weird set of points, in which case
@@ -62,16 +61,12 @@
     (error 'get-alternatives "cannnot run without a pcontext"))
 
   (define-values (train-pcontext test-pcontext) (partition-pcontext joint-pcontext))
-  ;; TODO: Ignoring all user-provided preprocessing right now
   (define alternatives (run-improve! (test-input test) (test-spec test) (*context*) train-pcontext))
 
-  (define preprocessing (alt-preprocessing (first alternatives)))
-  (define test-pcontext* (preprocess-pcontext (*context*) test-pcontext preprocessing))
-
   ;; compute error/cost for input expression
   (define start-expr (test-input test))
-  (define start-alt (make-alt-preprocessing start-expr (test-preprocess test)))
-  (define start-errs (errors start-expr test-pcontext* (*context*)))
+  (define start-alt (make-alt start-expr))
+  (define start-errs (errors start-expr test-pcontext (*context*)))
   (define start-alt-data (alt-analysis start-alt start-errs))
 
   ;; optionally compute error/cost for input expression
@@ -80,18 +75,18 @@
     (for/list ([(expr is-valid?) (in-dict (test-output test))]
                #:when is-valid?)
       (define target-expr (fpcore->prog expr (*context*)))
-      (define target-errs (errors target-expr test-pcontext* (*context*)))
+      (define target-errs (errors target-expr test-pcontext (*context*)))
       (alt-analysis (make-alt target-expr) target-errs)))
 
   ;; compute error/cost for output expression
   ;; and sort alternatives by accuracy + cost on testing subset
-  (define test-errs* (batch-errors (map alt-expr alternatives) test-pcontext* (*context*)))
-  (define sorted-end-exprs (sort-alts alternatives test-errs*))
+  (define test-errs (batch-errors (map alt-expr alternatives) test-pcontext (*context*)))
+  (define sorted-end-exprs (sort-alts alternatives test-errs))
   (define end-exprs (map (compose alt-expr car) sorted-end-exprs))
   (define end-errs (map cdr sorted-end-exprs))
   (define end-data (map alt-analysis alternatives end-errs))
 
-  (improve-result preprocessing test-pcontext* start-alt-data target-alt-data end-data))
+  (improve-result test-pcontext start-alt-data target-alt-data end-data))
 
 (define (get-cost test)
   (define cost-proc (platform-cost-proc (*active-platform*)))
@@ -219,16 +214,10 @@
 (define (dummy-table-row-from-hash result-hash status link)
   (define test (car (load-tests (open-input-string (hash-ref result-hash 'test)))))
   (define repr (test-output-repr test))
-  (define preprocess
-    (if (eq? (hash-ref result-hash 'status) 'success)
-        (map (compose read open-input-string)
-             (hash-ref (hash-ref result-hash 'backend) 'preprocessing))
-        (test-preprocess test)))
   (table-row (test-name test)
              (test-identifier test)
              status
              (prog->fpcore (test-pre test) (test-context test))
-             preprocess
              (representation-name repr)
              '() ; TODO: eliminate field
              (test-vars test)

src/api/server.rkt

@@ -415,8 +415,7 @@
        (make-hash (map cons exprs (batch-errors exprs pcontext ctx)))]
       [else #f]))
 
-  (define test-fpcore
-    (alt->fpcore test (make-alt-preprocessing (test-input test) (test-preprocess test))))
+  (define test-fpcore (alt->fpcore test (make-alt (test-input test))))
 
   (define fpcores
     (if (equal? (job-result-status herbie-result) 'success)
@@ -461,9 +460,7 @@
 (define (backend-improve-result-hash-table backend test errcache)
   (define repr (context-repr (test-context test)))
   (define pcontext (improve-result-pcontext backend))
-  (hasheq 'preprocessing
-          (map ~s (improve-result-preprocess backend))
-          'pcontext
+  (hasheq 'pcontext
           (pcontext->json pcontext repr)
           'start
           (analysis->json (improve-result-start backend) pcontext test errcache)
@@ -519,9 +516,6 @@
            ,@(if (equal? (test-spec test) empty)
                  '()
                  `(:herbie-spec ,(prog->fpcore (test-spec test) (test-context test))))
-           ,@(if (equal? (alt-preprocessing altn) empty)
-                 '()
-                 `(:herbie-preprocess ,(alt-preprocessing altn)))
            ,@(if (equal? (test-expected test) #t)
                  '()
                  `(:herbie-expected ,(test-expected test)))

src/core/mainloop.rkt

@@ -45,7 +45,8 @@
   (define pcontext* (preprocess-pcontext context pcontext preprocessing))
   (*pcontext* pcontext*)
   (*start-prog* initial)
-  (^table^ (make-alt-table pcontext (make-alt-preprocessing initial preprocessing) context))
+  (define start-alt (alt initial 'start '() preprocessing))
+  (^table^ (make-alt-table pcontext start-alt context))
 
   (for ([iteration (in-range (*num-iterations*))]
         #:break (atab-completed? (^table^)))
@@ -123,7 +124,7 @@
     [(< (length altns) (*pareto-pick-limit*)) altns] ; take max
     [else
      (define best (argmin score-alt altns))
-     (define altns* (sort (filter-not (curry alt-equal? best) altns) < #:key (curryr alt-cost repr)))
+     (define altns* (sort (set-remove altns best) < #:key (curryr alt-cost repr)))
      (define simplest (car altns*))
      (define altns** (cdr altns*))
      (define div-size (round (/ (length altns**) (- (*pareto-pick-limit*) 1))))

src/reports/common.rkt

@@ -154,11 +154,7 @@
       (core->tex prog* #:loc (and loc (cons 2 loc)) #:color "blue")
       "ERROR"))
 
-(define (render-program expr
-                        ctx
-                        #:ident [identifier #f]
-                        #:pre [precondition '(TRUE)]
-                        #:instructions [instructions empty])
+(define (render-program expr ctx #:ident [identifier #f] #:pre [precondition '(TRUE)])
   (define output-repr (context-repr ctx))
   (define out-prog
     (parameterize ([*expr-cse-able?* at-least-two-ops?])

src/reports/make-graph.rkt

@@ -37,7 +37,6 @@
   (define ctx (test-context test))
   (define identifier (test-identifier test))
 
-  (define preprocessing (map (compose read open-input-string) (hash-ref backend 'preprocessing)))
   (define start-expr (read (open-input-string (hash-ref (hash-ref backend 'start) 'expr))))
   (define start-cost (hash-ref (hash-ref backend 'start) 'cost))
   (define start-error (hash-ref (hash-ref backend 'start) 'errors))
@@ -151,8 +150,7 @@
                   [errs end-errors]
                   [cost end-costs]
                   [history end-histories])
-         (define-values (dropdown body)
-           (render-program expr ctx #:ident identifier #:instructions preprocessing))
+         (define-values (dropdown body) (render-program expr ctx #:ident identifier))
          `(section ([id ,(format "alternative~a" i)] (class "programs"))
                    (h2 "Alternative "
                        ,(~a i)

src/syntax/read.rkt

@@ -18,17 +18,7 @@
          load-tests
          parse-test)
 
-(struct test
-        (name identifier
-              vars
-              input
-              output
-              expected
-              spec
-              pre
-              preprocess
-              output-repr-name
-              var-repr-names)
+(struct test (name identifier vars input output expected spec pre output-repr-name var-repr-names)
   #:prefab)
 
 (define (test-output-repr test)
@@ -216,7 +206,6 @@
         (dict-ref prop-dict ':herbie-expected #t)
         spec
         pre*
-        (dict-ref prop-dict ':herbie-preprocess empty)
         (representation-name default-repr)
         (for/list ([var (in-list var-names)]
                    [repr (in-list var-reprs)])

src/utils/alternative.rkt

@@ -3,44 +3,19 @@
 (require "../syntax/platform.rkt")
 (provide (struct-out alt)
          make-alt
-         alt?
-         alt-expr
-         alt-add-event
-         *all-alts*
          alt-cost
-         alt-equal?
-         alt-map
-         alt-add-preprocessing
-         make-alt-preprocessing)
+         alt-map)
 
-;; Alts are a lightweight audit trail.
-;; An alt records a low-level view of how Herbie got
-;; from one program to another.
-;; They are a labeled linked list of changes.
+;; Alts are an expression plus a derivation for it.
 
 (struct alt (expr event prevs preprocessing) #:prefab)
 
 (define (make-alt expr)
   (alt expr 'start '() '()))
 
-(define (make-alt-preprocessing expr preprocessing)
-  (alt expr 'start '() preprocessing))
-
-(define (alt-equal? x y)
-  (equal? (alt-expr x) (alt-expr y)))
-
-(define (alt-add-event altn event)
-  (alt (alt-expr altn) event (list altn) (alt-preprocessing altn)))
-
-(define (alt-add-preprocessing altn preprocessing)
-  (alt (alt-expr altn) 'add-preprocessing (list altn) preprocessing))
-
 (define (alt-cost altn repr)
   (define expr-cost (platform-cost-proc (*active-platform*)))
   (expr-cost (alt-expr altn) repr))
 
 (define (alt-map f altn)
   (f (struct-copy alt altn [prevs (map (curry alt-map f) (alt-prevs altn))])))
-
-;; Keeps track of all alts so far.
-(define *all-alts* (make-parameter '()))