Merge pull request #1580 from herbie-fp/spec-split

Parse spec directly

Author: pavpanchekha

src/api/run.rkt

@@ -6,6 +6,7 @@
          "../reports/pages.rkt"
          "../reports/timeline.rkt"
          "../syntax/read.rkt"
+         "../syntax/sugar.rkt"
          "../syntax/platform.rkt"
          "../syntax/types.rkt"
          "../syntax/load-platform.rkt"
@@ -17,13 +18,41 @@
          "sandbox.rkt"
          "server.rkt")
 
-(provide make-report)
+(provide make-report
+         rerun-report)
+
+(define (extract-test row)
+  (define vars (table-row-vars row))
+  (define repr (get-representation (table-row-precision row)))
+  (define var-reprs (map (curryr cons repr) vars))
+  (define ctx (context vars repr (map (const repr) vars)))
+  (test (table-row-name row)
+        (table-row-identifier row)
+        (table-row-vars row)
+        (fpcore->prog (table-row-input row) ctx)
+        (fpcore->prog (table-row-output row) ctx)
+        (table-row-target-prog row)
+        (fpcore->spec (table-row-spec row))
+        (fpcore->spec (table-row-pre row))
+        (representation-name repr)
+        (for/list ([(k v) (in-dict var-reprs)])
+          (cons k (representation-name v)))))
 
 (define (make-report bench-dirs #:dir dir #:threads threads)
   (activate-platform! (*platform-name*))
   (define tests (sort (append-map load-tests bench-dirs) string-ci<? #:key test-name))
   (run-tests tests #:dir dir #:threads threads))
 
+(define (rerun-report json-file #:dir dir #:threads threads)
+  (define data (call-with-input-file json-file read-datafile))
+  (define tests (map extract-test (report-info-tests data)))
+  (activate-platform! (*platform-name*))
+  (*flags* (report-info-flags data))
+  (set-seed! (report-info-seed data))
+  (*num-points* (report-info-points data))
+  (*num-iterations* (report-info-iterations data))
+  (run-tests tests #:dir dir #:threads threads))
+
 (define (read-json-files info dir name)
   (filter identity
           (for/list ([res (report-info-tests info)])

src/api/sandbox.rkt

@@ -65,7 +65,11 @@
     (error 'get-alternatives "cannnot run without a pcontext"))
 
   (define-values (train-pcontext test-pcontext) (partition-pcontext joint-pcontext))
-  (define alternatives (run-improve! (test-input test) (test-spec test) (*context*) train-pcontext))
+  (define initial-expr
+    (if (equal? (prog->spec (test-input test)) (test-spec test))
+        (test-input test)
+        (approx (test-spec test) (test-input test))))
+  (define alternatives (run-improve! initial-expr (test-spec test) (*context*) train-pcontext))
 
   ;; compute error/cost for input expression
   (define start-expr (test-input test))
@@ -134,8 +138,8 @@
 
 (define (get-sample test)
   (random) ;; Tick the random number generator, for backwards compatibility
-  (define specification (prog->spec (or (test-spec test) (test-input test))))
-  (define precondition (prog->spec (test-pre test)))
+  (define specification (test-spec test))
+  (define precondition (test-pre test))
   (define-values (batch brfs) (progs->batch (list specification)))
   (define sample
     (parameterize ([*num-points* (+ (*num-points*) (*reeval-pts*))])

src/core/preprocess.rkt

@@ -57,9 +57,7 @@
     (cons `(sort ,a ,b) (replace-vars `((,a . ,b) (,b . ,a)) spec))))
 
 ;; See https://pavpanchekha.com/blog/symmetric-expressions.html
-(define (find-preprocessing expr ctx)
-  (define spec (prog->spec expr))
-
+(define (find-preprocessing spec ctx)
   ;; identities
   (define identities
     (append (make-even-identities spec ctx)

src/syntax/platform.rkt

@@ -37,6 +37,7 @@
          prog->spec
          batch-to-spec!
          get-fpcore-impl
+         impl->fpcore
          reset-fpcore-op-cache!
          (struct-out $platform)
          ;; Platform API
@@ -196,11 +197,16 @@
          (apply cost-proc (map loop args itypes))]))))
 
 ;; Extracts the `fpcore` field of an operator implementation
-;; as a property dictionary and expression.
+;; as a property dictionary and operation.
 (define (impl->fpcore impl)
-  (match (impl-info impl 'fpcore)
-    [(list '! props ... body) (values (props->dict props) body)]
-    [body (values '() body)]))
+  (define-values (props body)
+    (match (impl-info impl 'fpcore)
+      [(list '! props ... body) (values (props->dict props) body)]
+      [body (values '() body)]))
+  (values props
+          (if (symbol? body)
+              (list body)
+              body)))
 
 (define/reset op-hash #f)
 
@@ -215,12 +221,8 @@
     (define h (make-hash))
     (for ([impl (in-list (platform-impls (*active-platform*)))])
       (define-values (_ expr) (impl->fpcore impl))
-      (define expr*
-        (if (symbol? expr)
-            (list expr)
-            expr))
-      (when (list? expr*)
-        (hash-update! h (car expr*) (curry cons impl) '())))
+      (when (list? expr)
+        (hash-update! h (car expr) (curry cons impl) '())))
     (op-hash h))
 
   ; gather all implementations that have the same spec, input representations,
@@ -230,12 +232,8 @@
           (for ([impl (in-list (hash-ref (op-hash) op '()))]
                 #:when (equal? ireprs (impl-info impl 'itype)))
             (define-values (prop-dict* expr) (impl->fpcore impl))
-            (define expr*
-              (if (symbol? expr)
-                  (list expr)
-                  expr)) ; Handle named constants
             (define pattern (cons op (map (lambda (_) (gensym)) ireprs)))
-            (when (and (subset? prop-dict* prop-dict) (pattern-match pattern expr*))
+            (when (and (subset? prop-dict* prop-dict) (pattern-match pattern expr))
               (sow impl)))))
   ; check that we have any matching impls
   (cond

src/syntax/read.rkt

@@ -173,7 +173,7 @@
 
   ;; inline and desugar
   (define body* (fpcore->prog body ctx))
-  (define pre* (fpcore->prog (dict-ref prop-dict ':pre 'TRUE) ctx))
+  (define pre* (fpcore->spec (dict-ref prop-dict ':pre 'TRUE)))
 
   (define targets
     (for/list ([(key val) (in-dict prop-dict)]
@@ -188,11 +188,13 @@
            (fpcore->prog val ctx)
            (cons val #t))])))
 
-  (define spec (fpcore->prog (dict-ref prop-dict ':spec body) ctx))
+  (define spec-src (dict-ref prop-dict ':spec body))
+  (define spec (fpcore->spec spec-src))
 
   ;; Named fpcores become platform operators
   (when (and func-name (*register-named-fpcore-operators?*))
-    (register-fpcore-operator! func-name (struct-copy context ctx [repr output-repr]) body* spec))
+    (define spec* (fpcore->prog spec-src ctx))
+    (register-fpcore-operator! func-name (struct-copy context ctx [repr output-repr]) body* spec*))
   (check-unused-variables var-names body* pre*)
   (check-weird-variables var-names)
 

src/syntax/sugar.rkt

@@ -64,7 +64,8 @@
          "syntax.rkt"
          "types.rkt")
 
-(provide fpcore->prog
+(provide fpcore->spec
+         fpcore->prog
          prog->fpcore)
 
 ;; Local copies to avoid depending on core/programs.rkt.
@@ -85,6 +86,18 @@
       [(approx impl spec) (approx (loop impl) (loop spec))]
       [(list op args ...) (cons op (map loop args))])))
 
+(define (fpcore-extension-spec expr)
+  (define specs
+    (remove-duplicates (filter identity
+                               (for/list ([impl (in-list (platform-impls (*active-platform*)))])
+                                 (define-values (_ body) (impl->fpcore impl))
+                                 (define subst (pattern-match (expand-expr body) expr))
+                                 (and subst (pattern-substitute (impl-info impl 'spec) subst))))))
+  (match specs
+    ['() #f]
+    [(list spec) spec]
+    [_ (error 'fpcore->spec "ambiguous platform specs for `~a`: ~a" expr specs)]))
+
 ;; Expression pre-processing for normalizing expressions.
 ;; Used for conversion from FPCore to other IRs.
 (define (expand-expr expr)
@@ -146,12 +159,34 @@
       ; applications
       [`(,op ,args ...) `(,op ,@(map (curryr loop env) args))]
       ; constants
-      [(? operator-exists? op) (list expr)]
+      [(? operator-exists? op) (list op)]
       ; variables
       [(? symbol?) (dict-ref env expr expr)]
       ; other
       [_ expr])))
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; FPCore -> LSpec
+
+(define (fpcore->spec prog)
+  (let loop ([expr (expand-expr prog)])
+    (match expr
+      [(? number?)
+       (match expr
+         [(or +inf.0 -inf.0 +nan.0) expr]
+         [(? exact?) expr]
+         [_ (inexact->exact expr)])]
+      [(? symbol?) expr]
+      [(list '! _ ... body) (loop body)]
+      [(list 'cast arg) (loop arg)]
+      [(list op args ...)
+       (define args* (map loop args))
+       (define expr* `(,op ,@args*))
+       (match (fpcore-extension-spec expr*)
+         [#f expr*]
+         [(== expr*) expr*]
+         [spec (loop spec)])])))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; FPCore -> LImpl
 
@@ -169,11 +204,8 @@
   (define ireprs (map (lambda (arg) (repr-of arg ctx)) args))
   (define impl (assert-fpcore-impl op prop-dict ireprs))
   (define vars (impl-info impl 'vars))
-  (define pattern
-    (match (impl-info impl 'fpcore)
-      [(list '! _ ... body) body]
-      [body body]))
-  (define subst (pattern-match pattern (cons op args)))
+  (define-values (_ body) (impl->fpcore impl))
+  (define subst (pattern-match body (cons op args)))
   (pattern-substitute (cons impl vars) subst))
 
 ;; Translates from FPCore to an LImpl.
@@ -209,11 +241,8 @@
        (define idx-repr (repr-of idx* ctx))
        (define impl (assert-fpcore-impl 'ref prop-dict (list arr-repr idx-repr)))
        (define vars (impl-info impl 'vars))
-       (define pattern
-         (match (impl-info impl 'fpcore)
-           [(list '! _ ... body) body]
-           [body body]))
-       (define subst (pattern-match pattern (list 'ref arr* idx*)))
+       (define-values (_ body) (impl->fpcore impl))
+       (define subst (pattern-match body (list 'ref arr* idx*)))
        (pattern-substitute (cons impl vars) subst)]
       [(list op args ...)
        (define args* (map (lambda (arg) (loop arg prop-dict)) args))

src/syntax/test-syntax.rkt

@@ -2,6 +2,7 @@
 
 (require "syntax.rkt"
          "platform.rkt"
+         "sugar.rkt"
          "types.rkt")
 
 (module+ test
@@ -24,4 +25,9 @@
                 '+.f64)
   (check-equal? (get-impl 'sin '((:precision . binary64)) (list f64)) 'sin.f64)
 
+  ; fpcore->spec
+  (check-equal? (fpcore->spec '(log1p x)) '(log (+ 1 x)))
+  (check-equal? (fpcore->spec '(hypot x y)) '(sqrt (+ (* x x) (* y y))))
+  (check-equal? (fpcore->spec '(fma x y z)) '(+ (* x y) z))
+
   (void))