fmt

Author: pavpanchekha

eval/optimal.rkt

@@ -81,9 +81,9 @@
        (vector-set! optimal-precs idx (rival-machine-search-precision machine pt optimal-precs idx)))
 
      ; Time run with optimal precisions
-     (define optimal-time (time-min (lambda () (rival-machine-test-precision machine pt optimal-precs))))
+     (define optimal-time
+       (time-min (lambda () (rival-machine-test-precision machine pt optimal-precs))))
 
      ; Return both ratios and precision vectors
      (list optimal-precs optimal-time max-precs final-time)]
-    [else
-     #f]))
+    [else #f]))

infra/optimize.rkt

@@ -21,20 +21,20 @@
       (rival-compile exprs vars discs)))
 
   (define results
-    (filter identity
-            (for/list ([pt* (in-list (hash-ref rec 'points))]
-                       [pt-id (in-naturals)])
-              (match-define (list pt _sollya-exs _sollya-status _sollya-apply-time) pt*)
-              (define pt-vec
-                (parameterize ([bf-precision 53])
-                  (list->vector (map bf pt))))
-              (define result (rival-machine-find-optimal-precisions machine pt-vec))
-              (match result
-                [(list optimal-precs optimal-time cur-precs cur-time)
-                 (list pt-id pt optimal-time cur-time)]
-                [#f
-                 (eprintf "; Benchmark ~a point ~a, failure to optimize\n" bench-id pt-id)
-                 #f]))))
+    (filter
+     identity
+     (for/list ([pt* (in-list (hash-ref rec 'points))]
+                [pt-id (in-naturals)])
+       (match-define (list pt _sollya-exs _sollya-status _sollya-apply-time) pt*)
+       (define pt-vec
+         (parameterize ([bf-precision 53])
+           (list->vector (map bf pt))))
+       (define result (rival-machine-find-optimal-precisions machine pt-vec))
+       (match result
+         [(list optimal-precs optimal-time cur-precs cur-time) (list pt-id pt optimal-time cur-time)]
+         [#f
+          (eprintf "; Benchmark ~a point ~a, failure to optimize\n" bench-id pt-id)
+          #f]))))
 
   (define (bad-pt? rec)
     (match-define (list pt-id pt opt-time cur-time) rec)
@@ -44,7 +44,9 @@
   (define dt (* 1000 (- (apply + (map fourth results)) (apply + (map third results)))))
   (define valid-results (sort (filter bad-pt? results) > #:key fourth)) ; Sort by cur-time
   (eprintf "; Benchmark ~a, total ~aµs available, ~a bad points\n"
-           bench-id (~r dt #:precision '(= 1)) (length valid-results))
+           bench-id
+           (~r dt #:precision '(= 1))
+           (length valid-results))
   (unless (empty? valid-results)
     (fprintf output-port "; Benchmark ~a, total ~aµs available\n" bench-id (~r dt #:precision '(= 1)))
     (fprintf output-port
@@ -64,13 +66,14 @@
   (define min-speedup (make-parameter 1.2))
   (command-line
    #:once-each [("--min") n "Minimum speedup to report" (min-speedup (string->number n))]
-   #:args ([points-file "infra/points.json"]
-           [output-file "optimaize.rival"])
+   #:args ([points-file "infra/points.json"] [output-file "optimaize.rival"])
    (printf "Analyzing points bad precision assignment (min speedup: ~a)...\n\n" (min-speedup))
-   (call-with-output-file output-file #:exists 'replace
-     (λ (out-port)
-       (call-with-input-file points-file
-         (λ (input)
-           (for ([rec (in-port read-json input)]
-                 [bench-id (in-naturals)])
-             (analyze-program rec bench-id (min-speedup) out-port))))))))
+   (call-with-output-file
+    output-file
+    #:exists 'replace
+    (λ (out-port)
+      (call-with-input-file points-file
+                            (λ (input)
+                              (for ([rec (in-port read-json input)]
+                                    [bench-id (in-naturals)])
+                                (analyze-program rec bench-id (min-speedup) out-port))))))))

repl.rkt

@@ -232,13 +232,16 @@
          (printf "~a optimal ~aµs faster (~a×)\n"
                  name
                  (~r (* 1000 (- cur-time optimal-time)) #:precision '(= 1))
-                 (if (zero? optimal-time) "∞" (~r (/ cur-time optimal-time) #:precision '(= 3))))
+                 (if (zero? optimal-time)
+                     "∞"
+                     (~r (/ cur-time optimal-time) #:precision '(= 3))))
          (define ivec (rival-machine-instructions machine))
          (for ([instr (in-vector ivec)]
                [final (in-vector cur-precs)]
                [optimal (in-vector optimal-precs)])
            (define instr-name (normalize-function-name (~a (object-name (car instr)))))
-           (printf "~a ~a ~a\n" (~a instr-name #:width 20 #:align 'left)
+           (printf "~a ~a ~a\n"
+                   (~a instr-name #:width 20 #:align 'left)
                    (~a final #:width 6 #:align 'right)
                    (~a optimal #:width 6 #:align 'right)))
          (newline))]