Don't use external data files in benchmark

We want to measure the speed of the crypto functions, not how fast the Lisp
implementation can read/write from/to files.

2 files changed, 43 insertions, 83 deletions

diff --git a/benchmark/benchmark-implementation.lisp b/benchmark/benchmark-implementation.lisp
index ffb9eee..536b836 100644
--- a/benchmark/benchmark-implementation.lisp
+++ b/benchmark/benchmark-implementation.lisp
@@ -1,11 +1,10 @@
 (asdf:load-system "ironclad")
 
-(defparameter *file-size*
+(defparameter *data-size*
   #+sbcl (expt 10 8)
   #+(or allegro ccl ecl) (expt 10 7)
   #-(or allegro ccl ecl sbcl) (expt 10 6))
-(defparameter *data-file* "/tmp/data-clr")
-(defparameter *encrypted-file* "/tmp/data-enc")
+(defparameter *buffer-size* 32768)
 (defparameter *iterations* 100)
 (defparameter *implementation-result-file* "benchmark-tmp")
 (defparameter *result* (acons "version"
@@ -24,7 +23,7 @@
             (,result ,@body)
             (,end-time (get-internal-real-time))
             (,duration (/ (- ,end-time ,start-time) internal-time-units-per-second))
-            (,speed (round *file-size* ,duration)))
+            (,speed (round *data-size* ,duration)))
        (values ,speed ,result))))
 
 (defmacro get-speed-ops (&body body)
@@ -43,70 +42,55 @@
 (defun benchmark-ciphers ()
   (let ((speeds '()))
     (dolist (cipher-name (ironclad:list-all-ciphers))
-      (with-open-file (plaintext *data-file*
-                                 :element-type '(unsigned-byte 8))
-        (with-open-file (ciphertext *encrypted-file*
-                                    :direction :output
-                                    :element-type '(unsigned-byte 8)
-                                    :if-exists :supersede)
-          (flet ((stream-cipher-p (cipher-name)
-                   (= 1 (ironclad:block-length cipher-name))))
-            (let* ((key (ironclad:random-data (car (last (ironclad:key-lengths cipher-name)))))
-                   (cipher (ironclad:make-cipher cipher-name
-                                                 :key key
-                                                 :mode (if (stream-cipher-p cipher-name)
-                                                           :stream
-                                                           :ecb)))
-                   (buffer (make-array 32768 :element-type '(unsigned-byte 8)))
-                   (speed (get-speed-data (loop for buffer-length = (read-sequence buffer plaintext)
-                                                until (zerop buffer-length)
-                                                do (progn
-                                                     (ironclad:encrypt-in-place cipher buffer :end buffer-length)
-                                                     (write-sequence buffer ciphertext :end buffer-length))))))
-              (setf speeds (acons cipher-name speed speeds)))))))
+      (flet ((stream-cipher-p (cipher-name)
+               (= 1 (ironclad:block-length cipher-name))))
+        (let* ((key (ironclad:random-data (car (last (ironclad:key-lengths cipher-name)))))
+               (cipher (ironclad:make-cipher cipher-name
+                                             :key key
+                                             :mode (if (stream-cipher-p cipher-name)
+                                                       :stream
+                                                       :ecb)))
+               (buffer (ironclad:random-data *buffer-size*))
+               (speed (get-speed-data (dotimes (i (ceiling *data-size* *buffer-size*))
+                                        (ironclad:encrypt-in-place cipher buffer)))))
+          (setf speeds (acons cipher-name speed speeds)))))
     (setf *result* (acons "ciphers" speeds *result*))))
 
 (defun benchmark-digests ()
   (let ((speeds '()))
     (dolist (digest-name (ironclad:list-all-digests))
-      (with-open-file (plaintext *data-file*
-                                 :element-type '(unsigned-byte 8))
-        (let* ((digest (ironclad:make-digest digest-name))
-               (buffer (make-array 32768 :element-type '(unsigned-byte 8)))
-               (speed (get-speed-data (loop for buffer-length = (read-sequence buffer plaintext)
-                                            until (zerop buffer-length)
-                                            do (ironclad:update-digest digest buffer :end buffer-length)
-                                            finally (ironclad:produce-digest digest)))))
-          (setf speeds (acons digest-name speed speeds)))))
+      (let* ((digest (ironclad:make-digest digest-name))
+             (buffer (ironclad:random-data *buffer-size*))
+             (speed (get-speed-data (dotimes (i (ceiling *data-size* *buffer-size*)
+                                                (ironclad:produce-digest digest))
+                                      (ironclad:update-digest digest buffer)))))
+        (setf speeds (acons digest-name speed speeds))))
     (setf *result* (acons "digests" speeds *result*))))
 
 (defun benchmark-macs ()
   (let ((speeds '()))
     (dolist (mac-name (ironclad:list-all-macs))
-      (with-open-file (plaintext *data-file*
-                                 :element-type '(unsigned-byte 8))
-        (let* ((key-length (ecase mac-name
-                             (ironclad:blake2-mac 64)
-                             (ironclad:blake2s-mac 32)
-                             (ironclad:cmac 32)
-                             (ironclad:gmac 32)
-                             (ironclad:hmac 32)
-                             (ironclad:poly1305 32)
-                             (ironclad:skein-mac 64)))
-               (key (ironclad:random-data key-length))
-               (iv (case mac-name
-                     (ironclad:gmac (ironclad:random-data 12))))
-               (extra-args (case mac-name
-                             (ironclad:cmac '(:aes))
-                             (ironclad:gmac (list :aes iv))
-                             (ironclad:hmac '(:sha256))))
-               (mac (apply #'ironclad:make-mac mac-name key extra-args))
-               (buffer (make-array 32768 :element-type '(unsigned-byte 8)))
-               (speed (get-speed-data (loop for buffer-length = (read-sequence buffer plaintext)
-                                            until (zerop buffer-length)
-                                            do (ironclad:update-mac mac buffer :end buffer-length)
-                                            finally (ironclad:produce-mac mac)))))
-          (setf speeds (acons mac-name speed speeds)))))
+      (let* ((key-length (ecase mac-name
+                           (ironclad:blake2-mac 64)
+                           (ironclad:blake2s-mac 32)
+                           (ironclad:cmac 32)
+                           (ironclad:gmac 32)
+                           (ironclad:hmac 32)
+                           (ironclad:poly1305 32)
+                           (ironclad:skein-mac 64)))
+             (key (ironclad:random-data key-length))
+             (iv (case mac-name
+                   (ironclad:gmac (ironclad:random-data 12))))
+             (extra-args (case mac-name
+                           (ironclad:cmac '(:aes))
+                           (ironclad:gmac (list :aes iv))
+                           (ironclad:hmac '(:sha256))))
+             (mac (apply #'ironclad:make-mac mac-name key extra-args))
+             (buffer (ironclad:random-data *buffer-size*))
+             (speed (get-speed-data (dotimes (i (ceiling *data-size* *buffer-size*)
+                                                (ironclad:produce-mac mac))
+                                      (ironclad:update-mac mac buffer)))))
+        (setf speeds (acons mac-name speed speeds))))
     (setf *result* (acons "macs" speeds *result*))))
 
 (defun benchmark-diffie-hellman ()
diff --git a/benchmark/benchmark.lisp b/benchmark/benchmark.lisp
index 677262d..d487754 100644
--- a/benchmark/benchmark.lisp
+++ b/benchmark/benchmark.lisp
@@ -8,27 +8,9 @@
     ("Clisp" "clisp -i benchmark-implementation.lisp")
     ("ECL" "ecl --load benchmark-implementation.lisp")
     ("SBCL" "sbcl --load benchmark-implementation.lisp")))
-(defparameter *data-file* "/tmp/data-clr")
-(defparameter *encrypted-file* "/tmp/data-enc")
 (defparameter *implementation-result-file* "benchmark-tmp")
 (defparameter *result-file* "benchmark.org")
 
-(defun make-data-file (size)
-  (with-open-file (data-file *data-file*
-                             :direction :output
-                             :element-type '(unsigned-byte 8)
-                             :if-exists :supersede)
-    (loop with remaining = size
-          until (zerop remaining)
-          do (let ((n (min remaining 1000)))
-               (write-sequence (ironclad:random-data n) data-file)
-               (decf remaining n)))))
-
-(defun delete-data-files ()
-  (uiop:delete-file-if-exists *data-file*)
-  (uiop:delete-file-if-exists *encrypted-file*)
-  (uiop:delete-file-if-exists *implementation-result-file*))
-
 ;;; results format:
 ;;;
 ;;; (("lisp1" (("version" "...")
@@ -241,12 +223,6 @@
             (command (cadr implementation)))
         (format t "Benchmarking ~a..." lisp)
         (finish-output)
-        (make-data-file (cond ((member lisp '("SBCL") :test #'string=)
-                               (expt 10 8))
-                              ((member lisp '("AllegroCL" "ClozureCL" "ECL") :test #'string=)
-                               (expt 10 7))
-                              (t
-                               (expt 10 6))))
         (let ((result (ignore-errors
                         (uiop:run-program command)
                         (with-open-file (file *implementation-result-file*)
@@ -254,7 +230,7 @@
           (if (null result)
               (format t " FAILED~%")
               (format t " OK~%")))
-        (delete-data-files)))
+        (uiop:delete-file-if-exists *implementation-result-file*)))
     (write-result-file results)
     (format t "Benchmark result written to \"~a\"~%" *result-file*)))