Merge branch 'main' into codex/output-chrome-/tracing-json-trace

Author: pavpanchekha

src/config.rkt

@@ -1,27 +1,11 @@
 #lang racket
 
+(require racket/hash)
+
 (provide (all-defined-out))
 
 ;;; Flags
 
-(define all-flags
-  #hash([precision . (double fallback)]
-        [setup . (simplify search)]
-        [localize . (costs errors)]
-        [generate . (rr taylor simplify better-rr proofs egglog evaluate)]
-        [reduce . (regimes avg-error binary-search branch-expressions simplify)]
-        [rules
-         . (arithmetic polynomials
-                       fractions
-                       exponents
-                       trigonometry
-                       hyperbolic
-                       numerics
-                       special
-                       bools
-                       branches)]
-        [dump . (egg rival egglog trace)]))
-
 (define default-flags
   #hash([precision . ()]
         [setup . (search)]
@@ -31,22 +15,20 @@
         [rules . (arithmetic polynomials fractions exponents trigonometry hyperbolic)]
         [dump . ()]))
 
+(define deprecated-flags
+  #hash([precision . (double fallback)]
+        [setup . (simplify)]
+        [localize . (costs errors)]
+        [generate . (better-rr simplify)]
+        [reduce . (avg-error simplify)]
+        [rules . (numerics special bools branches)]))
+
+(define debug-flags #hash([generate . (egglog)] [dump . (egg rival egglog trace)]))
+
+(define all-flags (hash-union default-flags deprecated-flags debug-flags #:combine set-union))
+
 (define (flag-deprecated? category flag)
-  (match* (category flag)
-    [('precision 'double) #t]
-    [('precision 'fallback) #t]
-    [('setup 'simplify) #t]
-    [('generate 'better-rr) #t]
-    [('generate 'simplify) #t]
-    [('reduce 'simplify) #t]
-    [('reduce 'avg-error) #t]
-    [('localize 'costs) #t]
-    [('localize 'errors) #t]
-    [('rules 'numerics) #t]
-    [('rules 'special) #t]
-    [('rules 'bools) #t]
-    [('rules 'branches) #t]
-    [(_ _) #f]))
+  (set-member? (dict-ref deprecated-flags category '()) flag))
 
 ; `hash-copy` returns a mutable hash, which makes `dict-update` invalid
 (define *flags* (make-parameter (make-immutable-hash (hash->list default-flags))))

src/core/egg-herbie.rkt

@@ -503,6 +503,44 @@
                            (cons egg-rule ffi-rule)))))
           (for-each sow egg&ffi-rules))))
 
+;; Rules from impl to spec (fixed for a particular platform)
+(define/reset *lifting-rules* (make-hash))
+
+;; Rules from spec to impl (fixed for a particular platform)
+(define/reset *lowering-rules* (make-hash))
+
+;; Synthesizes the LHS and RHS of lifting/lowering rules.
+(define (impl->rule-parts impl)
+  (define vars (impl-info impl 'vars))
+  (define spec (impl-info impl 'spec))
+  (values vars spec (cons impl vars)))
+
+;; Synthesizes lifting rules for a platform platform.
+(define (platform-lifting-rules [pform (*active-platform*)])
+  (define impls (platform-impls pform))
+  (for/list ([impl (in-list impls)])
+    (hash-ref! (*lifting-rules*)
+               (cons impl pform)
+               (lambda ()
+                 (define name (sym-append 'lift- impl))
+                 (define-values (vars spec-expr impl-expr) (impl->rule-parts impl))
+                 (rule name impl-expr spec-expr '(lifting))))))
+
+;; Synthesizes lowering rules for a given platform.
+(define (platform-lowering-rules [pform (*active-platform*)])
+  (define impls (platform-impls pform))
+  (append* (for/list ([impl (in-list impls)])
+             (hash-ref! (*lowering-rules*)
+                        (cons impl pform)
+                        (lambda ()
+                          (define name (sym-append 'lower- impl))
+                          (define-values (vars spec-expr impl-expr) (impl->rule-parts impl))
+                          (list (rule name spec-expr impl-expr '(lowering))
+                                (rule (sym-append 'lower-unsound- impl)
+                                      (add-unsound spec-expr)
+                                      impl-expr
+                                      '(lowering))))))))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Racket egraph
 ;;

src/syntax/generators.rkt

@@ -8,6 +8,7 @@
          "types.rkt")
 
 (provide from-rival
+         from-ffi
          from-libm
          from-bigfloat
          define-generator
@@ -32,32 +33,36 @@
         (first exs)
         fail)))
 
-; ----------------------- LIBM GENERATOR ----------------------------
+; ----------------------- FFI GENERATOR -----------------------------
 
 ;; Looks up a function `name` with type signature `itype -> ... -> otype`
-;; in the system libm and returns the FFI function or `#f` if
-;; the procedure cannot be found.
+;; in the given FFI library and returns the function or `#f` if it
+;; cannot be found.
 ;; ```
-;; (make-libm (<name> <itype> ... <otype))
+;; (make-ffi <lib> (<name> <itype> ... <otype>))
 ;; ```
-(define (make-libm name itypes otype)
+(define (make-ffi lib name itypes otype)
   ; Repr matching
   (define (repr->ffi repr)
     (match (representation-name repr)
       ['binary64 _double]
       ['binary32 _float]
       ['integer _int]
       [else (raise-syntax-error 'repr->type "unknown type" repr)]))
-  (get-ffi-obj name #f (_cprocedure (map repr->ffi itypes) (repr->ffi otype)) (const #f)))
+  (get-ffi-obj name lib (_cprocedure (map repr->ffi itypes) (repr->ffi otype)) (const #f)))
 
-(define-generator ((from-libm name) spec ctx)
+(define-generator ((from-ffi lib name) spec ctx)
   (let ([itypes (context-var-reprs ctx)]
         [otype (context-repr ctx)])
-    (define fl (make-libm name itypes otype))
+    (define fl (make-ffi lib name itypes otype))
     (unless fl
-      (error 'libm-generator "Could not find libm implementation of `~a ~a ~a`" otype name itypes))
+      (error 'ffi-generator "Could not find FFI implementation of `~a ~a ~a`" otype name itypes))
     fl))
 
+(define libm-lib (ffi-lib #f))
+(define (from-libm name)
+  (from-ffi libm-lib name))
+
 ; ----------------------- BIGFLOAT GENERATOR ------------------------
 
 (define (repr->bf x type)

src/syntax/platform-language.rkt

@@ -244,6 +244,16 @@
   ; Update table
   (hash-set! impls (operator-impl-name impl) impl))
 
+(define (validate-platform! platform)
+  (when (empty? (platform-implementations platform))
+    (raise-herbie-error "Platform contains no operations"))
+  (for ([(name impl) (in-hash (platform-implementations platform))])
+    (define ctx (operator-impl-ctx impl))
+    (for ([repr (in-list (cons (context-repr ctx) (context-var-reprs ctx)))])
+      (unless (equal? (hash-ref (platform-representations platform) (representation-name repr) #f)
+                      repr)
+        (raise-herbie-error "Representation ~a not defined" (representation-name repr))))))
+
 (define-syntax (platform-register-implementations! stx)
   (syntax-case stx ()
     [(_ platform ([name ([var : repr] ...) otype spec fl fpcore cost] ...))

src/syntax/platform.rkt

@@ -4,7 +4,6 @@
 (require "../utils/common.rkt"
          "../utils/errors.rkt"
          "../config.rkt"
-         "../core/rules.rkt"
          "matcher.rkt"
          "types.rkt"
          "syntax.rkt"
@@ -29,10 +28,7 @@
      (fprintf port "#<platform>"))])
 
 (provide *active-platform*
-         platform-lifting-rules
-         platform-lowering-rules
          platform-copy
-         validate-platform!
          repr-exists?
          get-representation
          impl-exists?
@@ -68,16 +64,6 @@
   (define impls (make-hash))
   (create-platform reprs impls repr-costs))
 
-(define (validate-platform! platform)
-  (when (empty? (platform-implementations platform))
-    (raise-herbie-error "Platform contains no operations"))
-  (for ([(name impl) (in-hash (platform-implementations platform))])
-    (define ctx (operator-impl-ctx impl))
-    (for ([repr (in-list (cons (context-repr ctx) (context-var-reprs ctx)))])
-      (unless (equal? (hash-ref (platform-representations platform) (representation-name repr) #f)
-                      repr)
-        (raise-herbie-error "Representation ~a not defined" (representation-name repr))))))
-
 ;; Returns the representation associated with `name`
 ;; attempts to generate the repr if not initially found
 (define (get-representation name)
@@ -181,44 +167,6 @@
          (define itypes (impl-info impl 'itype))
          (apply cost-proc (map loop args itypes))]))))
 
-;; Rules from impl to spec (fixed for a particular platform)
-(define/reset *lifting-rules* (make-hash))
-
-;; Rules from spec to impl (fixed for a particular platform)
-(define/reset *lowering-rules* (make-hash))
-
-;; Synthesizes the LHS and RHS of lifting/lowering rules.
-(define (impl->rule-parts impl)
-  (define vars (impl-info impl 'vars))
-  (define spec (impl-info impl 'spec))
-  (values vars spec (cons impl vars)))
-
-;; Synthesizes lifting rules for a platform platform.
-(define (platform-lifting-rules [pform (*active-platform*)])
-  (define impls (platform-impls pform))
-  (for/list ([impl (in-list impls)])
-    (hash-ref! (*lifting-rules*)
-               (cons impl pform)
-               (lambda ()
-                 (define name (sym-append 'lift- impl))
-                 (define-values (vars spec-expr impl-expr) (impl->rule-parts impl))
-                 (rule name impl-expr spec-expr '(lifting))))))
-
-;; Synthesizes lowering rules for a given platform.
-(define (platform-lowering-rules [pform (*active-platform*)])
-  (define impls (platform-impls pform))
-  (append* (for/list ([impl (in-list impls)])
-             (hash-ref! (*lowering-rules*)
-                        (cons impl pform)
-                        (lambda ()
-                          (define name (sym-append 'lower- impl))
-                          (define-values (vars spec-expr impl-expr) (impl->rule-parts impl))
-                          (list (rule name spec-expr impl-expr '(lowering))
-                                (rule (sym-append 'lower-unsound- impl)
-                                      (add-unsound spec-expr)
-                                      impl-expr
-                                      '(lowering))))))))
-
 ;; Extracts the `fpcore` field of an operator implementation
 ;; as a property dictionary and expression.
 (define (impl->fpcore impl)

www/doc/2.3/platforms.html

@@ -214,12 +214,22 @@ <h3>Math Library Functions</h3>
   <pre>(define-operation (fabs.f32 [x &lt;binary32&gt;]) &lt;binary32&gt;
   #:spec (fabs x) #:impl (from-libm 'fabsf) #:cost 0.125)</pre>
 
-  <p>The <code>from-libm</code> uses dynamic linking to
-  load <code>libm</code>, extracts the symbol passed
-  to <code>from-libm</code>, and then uses the operation's signature
-  to call into the dynamically-linked library from Racket. Must make
-  sure to pass the correct symbol name; for single-precision
-  functions, make sure to add the "<code>f</code>" suffix.</p>
+  <p>The <code>from-libm</code> helper uses dynamic linking to load
+  <code>libm</code>, extracts the symbol passed to
+  <code>from-libm</code>, and then uses the operation's signature to
+  call into the dynamically-linked library from Racket. Be sure to
+  pass the correct symbol name; for single-precision functions, add the
+  "<code>f</code>" suffix.</p>
+
+  <p>For other libraries, open them with
+  <code>ffi-lib</code> and use <code>from-ffi</code>, which
+  generalizes <code>from-libm</code>. For example, to load functions
+  from the GNU Scientific Library:</p>
+
+  <pre>(require ffi/unsafe)
+(define libgsl (ffi-lib "gsl"))
+(define-operation (cos.gsl [x &lt;binary64&gt;]) &lt;binary64&gt;
+  #:spec (cos x) #:impl (from-ffi libgsl 'gsl_sf_cos) #:cost 0.125)</pre>
 
   <h3>Numeric Variations</h3>
 

www/doc/2.3/plugins.html

@@ -114,9 +114,9 @@ <h2>Defining representations</h2>
   <h2>Defining Generators</h2>
 
   <p><dfn>Generators</dfn> are helper functions for generating
-  implementations in <code>define-operation</code>. For
-  example, <a href="platforms.html"><code>from-libm</code>
-  and <code>from-rival</code></a> are generators.</p>
+  implementations in <code>define-operation</code>. For example,
+  <a href="platforms.html"><code>from-ffi</code></a> is a
+  generator.</p>
 
   <p>To define a generator, use <code>define-generator</code>:</p>
 
@@ -128,7 +128,8 @@ <h2>Defining Generators</h2>
   <p>Here, <code>from-<var>foo</var></code> is the name of your
   generator, and <var>args</var> are any additional arguments the
   generator takes. For example, <code>from-libm</code> takes one
-  argument, the symbol name.</p>
+  argument, the symbol name, while <code>from-ffi</code> takes an open
+  library and a symbol name.</p>
 
   <p>Then, inside the <var>body</var>, you can use those arguments as
   well as <code>spec</code> and <code>ctx</code>, to construct an