add benchmarks

benchmarks/big_fibo.lisp

@@ -0,0 +1,64 @@
+(define (fibo-0) 0)
+
+(define (fibo-1) 1)
+
+(define (fibo-2) (+ (fibo-1) (fibo-0)))
+
+(define (fibo-3) (+ (fibo-2) (fibo-1)))
+
+(define (fibo-4) (+ (fibo-3) (fibo-2)))
+
+(define (fibo-5) (+ (fibo-4) (fibo-3)))
+
+(define (fibo-6) (+ (fibo-5) (fibo-4)))
+
+(define (fibo-7) (+ (fibo-6) (fibo-5)))
+
+(define (fibo-8) (+ (fibo-7) (fibo-6)))
+
+(define (fibo-9) (+ (fibo-8) (fibo-7)))
+
+(define (fibo-10) (+ (fibo-9) (fibo-8)))
+
+(define (fibo-11) (+ (fibo-10) (fibo-9)))
+
+(define (fibo-12) (+ (fibo-11) (fibo-10)))
+
+(define (fibo-13) (+ (fibo-12) (fibo-11)))
+
+(define (fibo-14) (+ (fibo-13) (fibo-12)))
+
+(define (fibo-15) (+ (fibo-14) (fibo-13)))
+
+(define (fibo-16) (+ (fibo-15) (fibo-14)))
+
+(define (fibo-17) (+ (fibo-16) (fibo-15)))
+
+(define (fibo-18) (+ (fibo-17) (fibo-16)))
+
+(define (fibo-19) (+ (fibo-18) (fibo-17)))
+
+(define (fibo-20) (+ (fibo-19) (fibo-18)))
+
+(define (fibo-21) (+ (fibo-20) (fibo-19)))
+
+(define (fibo-22) (+ (fibo-21) (fibo-20)))
+
+(define (fibo-23) (+ (fibo-22) (fibo-21)))
+
+(define (fibo-24) (+ (fibo-23) (fibo-22)))
+
+(define (fibo-25) (+ (fibo-24) (fibo-23)))
+
+(define (fibo-26) (+ (fibo-25) (fibo-24)))
+
+(define (fibo-27) (+ (fibo-26) (fibo-25)))
+
+(define (fibo-28) (+ (fibo-27) (fibo-26)))
+
+(define (fibo-29) (+ (fibo-28) (fibo-27)))
+
+(define (fibo-30) (+ (fibo-29) (fibo-28)))
+
+(let ((fibo-32 (+ (fibo-30) (+ (fibo-30) (fibo-29)))))
+    (print (+ fibo-32 (+ fibo-32 (+ (fibo-30) (fibo-29))))))

benchmarks/certain-error.in

@@ -0,0 +1 @@
+256847

benchmarks/certain-error.lisp

@@ -0,0 +1,34 @@
+(define (multiply-pos x y)
+  (multiply-pos-inner x y 0))
+
+(define (multiply-pos-inner x y total)
+  (if (= y 0) total (multiply-pos-inner x (- y 1) (+ x total))))
+
+(define (divide-pos x y)
+  (divide-pos-inner x y 0))
+
+(define (divide-pos-inner x y guess)
+  (let ((diff (- x (multiply-pos y guess))))
+    (if (< diff y)
+      (if (zero? diff) guess false)
+      (divide-pos-inner x y (add1 guess)))))
+
+(define (concatenate l r)
+  (if 
+    (empty? l) 
+    r
+    (pair (left l) (concatenate (right l) r))))
+
+(define (slow-factorize num)
+  (if (= num 1) () (slow-factorize-inner num (sub1 num))))
+
+(define (slow-factorize-inner num guess)
+  (if (= guess 1) 
+    (pair num ())
+    (if (divide-pos num guess)
+      (concatenate 
+        (slow-factorize (divide-pos num guess))
+        (slow-factorize guess))
+      (slow-factorize-inner num (sub1 guess)))))
+
+(print (pair (slow-factorize (read-num)) (+ 2 false)))

benchmarks/combined

@@ -0,0 +1,10 @@
+(define (f) 1)
+(define (g x) (sub1 (f)))
+(define (h x) (+ (f) (- (g (g (g (g (g (g (g x))))))) (f))))
+(define (i x) (+ (- x (add1 1)) (sub1 3)))
+(print (let ((x (h (h (h (h (g (h (f))))))))) 
+    (if (< 0 1)
+        (if (= 1 1)
+            (i (+ (i x) (+ (i x) (+ x 1)))) 
+            0) 
+        0)))

benchmarks/common_subexpr.lisp

@@ -0,0 +1,9 @@
+(define (fib x)
+    (if (< x 2) 1
+        (+ (fib (- x 1)) (fib (- x 2)))))
+
+(let ((x (fib 30)))
+    (do (fib 30)
+        (print (fib 30))
+        (print x)
+        (print (+ (fib 30) (fib 30)))))

benchmarks/const_in_func.lisp

@@ -0,0 +1,12 @@
+(define (do-math0 x)
+        (+ x (- 19999 (+ 9999 10000))))
+
+(define (do-math x)
+        (+ x (- (do-math0 19999) (+ (do-math0 9999) (do-math0 10000)))))
+
+(define (run-bench passes) 
+    (if (< passes 1) (print 0)
+        (let ((x (do-math passes)))
+            (run-bench (- passes 1)))))
+
+(run-bench 999999)

benchmarks/const_prop_behind_mut_rec.lisp

@@ -0,0 +1,81 @@
+
+(define (slow1 x)
+  (+ (slow2 x) (slow2 x)))
+
+(define (slow2 x)
+  (+ (slow3 x) (slow3 x)))
+
+(define (slow3 x)
+  (+ (slow4 x) (slow4 x)))
+
+(define (slow4 x)
+  (+ (slow5 x) (slow5 x)))
+
+(define (slow5 x)
+  (+ (slow6 x) (slow6 x)))
+
+(define (slow6 x)
+  (+ (slow7 x) (slow7 x)))
+
+(define (slow7 x)
+  (+ (slow8 x) (slow8 x)))
+
+(define (slow8 x)
+  (+ (slow9 x) (slow9 x)))
+
+(define (slow9 x)
+  (+ (slow10 x) (slow10 x)))
+
+(define (slow10 x)
+  (+ (slow11 x) (slow11 x)))
+
+(define (slow11 x)
+  (+ (slow12 x) (slow12 x)))
+
+(define (slow12 x)
+  (+ (slow13 x) (slow13 x)))
+
+(define (slow13 x)
+  (+ (slow14 x) (slow14 x)))
+
+(define (slow14 x)
+  (+ (slow15 x) (slow15 x)))
+
+(define (slow15 x)
+  (+ (slow16 x) (slow16 x)))
+
+(define (slow16 x)
+  (+ (slow17 x) (slow17 x)))
+
+(define (slow17 x)
+  (+ (slow18 x) (slow18 x)))
+
+(define (slow18 x)
+  (+ (slow19 x) (slow19 x)))
+
+(define (slow19 x)
+  (+ (slow20 x) (slow20 x)))
+
+(define (slow20 x)
+  (+ (slow21 x) (slow21 x)))
+
+(define (slow21 x)
+  (+ (slow22 x) (slow22 x)))
+
+(define (slow22 x)
+  (+ x x))
+
+(define (slow x)
+  (+ (slow1 x) (slow1 x)))
+
+(define (f x)
+  (if (< x 1)
+      0
+      (g (sub1 x))))
+
+(define (g x)
+  (do
+    (print (slow 1))
+    (f (sub1 x))))
+
+(f 70)

benchmarks/constant-prop-after-inlining.lisp

@@ -0,0 +1,23 @@
+(define (one) 1)
+
+(define (do-a-lot n) (if (= 0 n) 
+                         true 
+                         (do (+ (one)
+                                   (+ (one)
+                                      (+ (one)
+                                         (+ (one)
+                                            (+ (one)
+                                               (+ (one)
+                                                  (+ (one)
+                                                     (+ (one)
+                                                        (+ (one)
+                                                           (+ (one)
+                                                              (+ (one)
+                                                                 (+ (one)
+                                                                    (+ (one)
+                                                                       (+ (one)
+                                                                          (+ (one)
+                                                                             (+ (one)
+                                                                                (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (+ (one) (one)))))))))))))))))))))))))))))))))))))))))))))))))))))
+                                (do-a-lot (- n 1)))))
+(do-a-lot 9999999)

benchmarks/cse-bench.lisp

@@ -0,0 +1,22 @@
+(define (expensive n)
+  (if (< n 3)
+    n
+    (+ 
+      (expensive (sub1 n))
+      (+
+        (expensive (sub1 n))
+        (expensive (sub1 n))))))
+
+(print
+  (do 
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))
+    (expensive (sub1 (+ 6 (+ 5 5))))))

benchmarks/cse-bench.out

@@ -0,0 +1 @@
+258280326

benchmarks/hanoi.lisp

@@ -0,0 +1,27 @@
+(define (move-disk src des)
+    (pair
+        (right src)
+        (pair (left src) des))
+)
+
+(define (solve-hanoi n s d a)
+    (if (< 0 n)
+        (let ((src (left (solve-hanoi (sub1 n) s a d))))
+                (let ((aux (left (right (solve-hanoi (sub1 n) s a d)))))
+                    (let ((des (right (right (solve-hanoi (sub1 n) s a d)))))
+                        (let ((movedsd (move-disk src des)))
+                            (let ((res (solve-hanoi (sub1 n) aux (right movedsd) (left movedsd))))
+                                    (pair (right (right res)) (pair (left (right res)) (left res)))
+                    )))))
+        (pair s (pair d a))
+    )
+)
+
+(define (generate-hanoi n)
+    (if (< 0 n)
+        (pair n (generate-hanoi (sub1 n)))
+        ()
+    )
+)
+
+(print (solve-hanoi 11 (generate-hanoi 11) () ()))

benchmarks/inlining.out

@@ -0,0 +1 @@
+(pair 11 12)

benchmarks/plus_minus_tail.lisp

@@ -0,0 +1,7 @@
+(define (plusminus-tail n x mode)
+    (if (< 0 n)
+        (if mode (plusminus-tail (sub1 n) (- 1 x) (not mode)) (plusminus-tail (sub1 n) (+ 1 x) (not mode)))
+        x)
+)
+
+(print (plusminus-tail 10000000 5 false))

benchmarks/repeated-constant-prop.lisp

@@ -0,0 +1,6 @@
+(define (do-a-lot n) (if (= 0 n) 
+                         true 
+                         (do (let ((x (if false true false)))
+                                  (if x 1 2))
+                              (do-a-lot (- n 1)))))
+(do-a-lot 9999999999)

benchmarks/simplifying_ifs.in

@@ -0,0 +1 @@
+0

benchmarks/simplifying_ifs.lisp

@@ -0,0 +1,73 @@
+
+(define (slow1 x)
+  (+ (slow2 x) (slow2 x)))
+
+(define (slow2 x)
+  (+ (slow3 x) (slow3 x)))
+
+(define (slow3 x)
+  (+ (slow4 x) (slow4 x)))
+
+(define (slow4 x)
+  (+ (slow5 x) (slow5 x)))
+
+(define (slow5 x)
+  (+ (slow6 x) (slow6 x)))
+
+(define (slow6 x)
+  (+ (slow7 x) (slow7 x)))
+
+(define (slow7 x)
+  (+ (slow8 x) (slow8 x)))
+
+(define (slow8 x)
+  (+ (slow9 x) (slow9 x)))
+
+(define (slow9 x)
+  (+ (slow10 x) (slow10 x)))
+
+(define (slow10 x)
+  (+ (slow11 x) (slow11 x)))
+
+(define (slow11 x)
+  (+ (slow12 x) (slow12 x)))
+
+(define (slow12 x)
+  (+ (slow13 x) (slow13 x)))
+
+(define (slow13 x)
+  (+ (slow14 x) (slow14 x)))
+
+(define (slow14 x)
+  (+ (slow15 x) (slow15 x)))
+
+(define (slow15 x)
+  (+ (slow16 x) (slow16 x)))
+
+(define (slow16 x)
+  (+ (slow17 x) (slow17 x)))
+
+(define (slow17 x)
+  (+ (slow18 x) (slow18 x)))
+
+(define (slow18 x)
+  (+ (slow19 x) (slow19 x)))
+
+(define (slow19 x)
+  (+ (slow20 x) (slow20 x)))
+
+(define (slow20 x)
+  (+ (slow21 x) (slow21 x)))
+
+(define (slow21 x)
+  (+ (slow22 x) (slow22 x)))
+
+(define (slow22 x)
+  (+ x x))
+
+(define (slow x)
+  (+ (slow1 x) (+ (slow1 x) (+ (slow1 x) (+ (slow1 x) (+ (slow1 x) (+ (slow1 x) (+ (slow1 x) (+ (slow1 x) (slow1 x))))))))))
+
+(print (if (= (read-num) 0)
+           (slow 1)
+           (slow 2)))