Delete *sampling-iteration*, fixing #133

Thank you, amp code!

Author: pavpanchekha

AGENTS.md

@@ -10,3 +10,8 @@
   task to format your code correctly.
 - When editing an interval arithmetic function, always run the tests.
   Run tests with `racket -y test.rkt add` (for the right function).
+- When editing the eval stuff, always run the tests. Run them with
+  `racket -y time.rkt --id N ../../infra/points.json`. The number `N`
+  is a benchmark ID; some common choices are 12 and 57, but there are
+  a bit over 500 in total and sometimes you're asked to focus on a
+  particular one. Smaller numbers are faster to run.

eval/adjust.rkt

@@ -166,7 +166,7 @@
         [out-dr? (in-vector slackvec)]
         #:when (>= root-reg varc)
         #:when out-dr?)
-    (vector-set! vprecs-new (- root-reg varc) (get-slack)))
+    (vector-set! vprecs-new (- root-reg varc) (get-slack current-iter)))
 
   ; Step 1b. Checking if a operation should be computed again at all
   ;   This step traverses instructions top-down and check whether a reevaluation is needed
@@ -188,15 +188,17 @@
       [else (path-reduction vrepeats vregs varc instr i #:reexec-val #f)]))
 
   ; Step 2. Precision tuning
-  (precision-tuning (rival-machine-max-precision machine)
-                    ivec
-                    vregs
-                    vprecs-new
-                    varc
-                    vstart-precs
-                    vrepeats
-                    vhint
-                    constants-lookup)
+  (define hit-max?
+    (precision-tuning (rival-machine-max-precision machine)
+                      ivec
+                      vregs
+                      vprecs-new
+                      varc
+                      vstart-precs
+                      vrepeats
+                      vhint
+                      constants-lookup
+                      current-iter))
 
   ; Step 3. Repeating precisions check + Assigning if a operation should be computed again at all
   ; vrepeats[i] = #t if the node has the same precision as an iteration before and children have #t flag as well
@@ -235,19 +237,23 @@
     ; clean progress of the current tuning pass and start over
     (vector-fill! vprecs-new 0)
     (vector-fill! vrepeats #f)
-    (precision-tuning (rival-machine-max-precision machine)
-                      ivec
-                      vregs
-                      vprecs-new
-                      varc
-                      vstart-precs
-                      vrepeats
-                      vhint
-                      constants-lookup)
+    (define hit-max2?
+      (precision-tuning (rival-machine-max-precision machine)
+                        ivec
+                        vregs
+                        vprecs-new
+                        varc
+                        vstart-precs
+                        vrepeats
+                        vhint
+                        constants-lookup
+                        current-iter))
+    (set! hit-max? (or hit-max? hit-max2?))
     (repeats)) ; do repeats again
 
   ; Step 5. Copying new precisions into vprecs
-  (vector-copy! vprecs 0 vprecs-new))
+  (vector-copy! vprecs 0 vprecs-new)
+  hit-max?)
 
 ; Usually, add-bang instructions have a pointer to itself that is needed to be dropped
 (define (drop-self-pointer tail-regs n)
@@ -269,8 +275,10 @@
                           vstart-precs
                           vrepeats
                           vhint
-                          constants)
+                          constants
+                          iter)
   (define vprecs-min (make-vector (vector-length ivec) 0))
+  (define hit-max? #f)
   (for ([instr (in-vector ivec (- (vector-length ivec) 1) -1 -1)]
         [repeat? (in-vector vrepeats (- (vector-length vrepeats) 1) -1 -1)]
         [n (in-range (- (vector-length vregs) 1) -1 -1)]
@@ -296,13 +304,14 @@
     (match (*lower-bound-early-stopping*)
       [#t
        (when (>= min-prec machine-max-precision)
-         (*sampling-iteration* (*rival-max-iterations*)))]
+         (set! hit-max? #t))]
       [#f
        (when (equal? final-precision machine-max-precision)
-         (*sampling-iteration* (*rival-max-iterations*)))])
+         (set! hit-max? #t))])
 
     ; Precision propogation for each tail instruction
-    (define ampl-bounds (get-bounds op output srcs)) ; amplification bounds for children instructions
+    (define ampl-bounds
+      (get-bounds op output srcs iter)) ; amplification bounds for children instructions
     (for ([x (in-list tail-registers)]
           [bound (in-list ampl-bounds)]
           #:when (>= x varc)) ; when tail register is not a variable
@@ -316,4 +325,5 @@
       ; Lower precision bound propogation
       (vector-set! vprecs-min
                    (- x varc)
-                   (max (vector-ref vprecs-min (- x varc)) (+ min-prec (max 0 lo-bound)))))))
+                   (max (vector-ref vprecs-min (- x varc)) (+ min-prec (max 0 lo-bound))))))
+  hit-max?)

eval/machine.rkt

@@ -8,7 +8,6 @@
          *rival-max-iterations*
          *rival-profile-executions*
          *ampl-tuning-bits*
-         *sampling-iteration*
          *lower-bound-early-stopping*
          *base-tuning-precision*
          *bumps-activated*)
@@ -46,5 +45,4 @@
                    profile-iteration))
 
 (define *ampl-tuning-bits* (make-parameter 2))
-(define *sampling-iteration* (make-parameter 0))
 (define *base-tuning-precision* (make-parameter 5))

eval/main.rkt

@@ -34,13 +34,12 @@
          *rival-profile-executions*)
 
 (define (rival-machine-full machine vhint)
-  (set-rival-machine-iteration! machine (*sampling-iteration*))
-  (rival-machine-adjust machine vhint)
-  (cond
-    [(>= (*sampling-iteration*) (*rival-max-iterations*)) (values #f #f #f #t #f)]
-    [else
-     (rival-machine-run machine vhint)
-     (rival-machine-return machine)]))
+  (define early-stop? (rival-machine-adjust machine vhint))
+  (if early-stop?
+      (values #f #f #f #t #f)
+      (begin
+        (rival-machine-run machine vhint)
+        (rival-machine-return machine))))
 
 (struct exn:rival exn:fail ())
 (struct exn:rival:invalid exn:rival (pt))
@@ -82,9 +81,9 @@
   ; Load arguments
   (rival-machine-load machine (vector-map ival-real pt))
   (let loop ([iter 0])
+    (set-rival-machine-iteration! machine iter)
     (define-values (good? done? bad? stuck? fvec)
-      (parameterize ([*sampling-iteration* iter]
-                     [*rival-max-precision* (rival-machine-max-precision machine)])
+      (parameterize ([*rival-max-precision* (rival-machine-max-precision machine)])
         (rival-machine-full machine (or hint (rival-machine-default-hint machine)))))
     (cond
       [bad? (raise (exn:rival:invalid "Invalid input" (current-continuation-marks) pt))]
@@ -98,9 +97,9 @@
 (define (rival-analyze-with-hints machine rect [hint #f])
   ; Load arguments
   (rival-machine-load machine rect)
+  (set-rival-machine-iteration! machine 0)
   (define-values (good? done? bad? stuck? fvec)
-    (parameterize ([*sampling-iteration* 0])
-      (rival-machine-full machine (or hint (rival-machine-default-hint machine)))))
+    (rival-machine-full machine (or hint (rival-machine-default-hint machine))))
   (define-values (hint* hint*-converged?)
     (make-hint machine (or hint (rival-machine-default-hint machine))))
   (list (ival (or bad? stuck?) (not good?)) hint* hint*-converged?))

eval/run.rkt

@@ -118,12 +118,15 @@
   (define iter (rival-machine-iteration machine))
   (let ([start-time (current-inexact-milliseconds)]
         [start-memory (current-memory-use 'cumulative)])
-    (unless (zero? iter)
-      (backward-pass machine vhint))
+    (define early-stop?
+      (if (zero? iter)
+          #f
+          (backward-pass machine vhint)))
     (rival-machine-record machine
                           'adjust
                           -1
                           (* iter 1000)
                           (- (current-inexact-milliseconds) start-time)
                           (- (current-memory-use 'cumulative) start-memory)
-                          iter)))
+                          iter)
+    early-stop?))