Re: optimizing lazy sequences: srfi-41 vs delayed continuation with values + promise vs delayed continuation with cons + lambda

[Amirouche Boubekki <amirouche@hypermove.net>]

I figured how to benchmark this.

Here are the timings:

promise: 43s
lambda: 7s

And at the current 'max' value the srfi-41 streams can't complete
the benchmark with this error:

   Too many heap sections: Increase MAXHINCR or MAX_HEAP_SECTS

Here is the benchmark program:

(use-modules (srfi srfi-41))

(define max (expt 10 8))

(define (time-it thunk)
   (let ((start (current-time)))
     (thunk)
     (- (current-time) start)))

;; promise based lazy seq

(define (lazyseq-with-promise)
   (let loop ((v 1))
     (delay
       (values v (loop (+ 1 v))))))

(define (consume-promise promise)
   (let loop ((v 0)
              (promise promise))
     (unless (eq? v max)
       (call-with-values (lambda () (force promise))
         (lambda (v next)
           (loop (+ 1 v) next))))))

(define v1 (time-it (lambda () (consume-promise 
(lazyseq-with-promise)))))

;; lambda based lazy seq

(define (lazyseq-with-lambda)
   (let loop ((v 1))
     (lambda ()
       (values v (loop (+ 1 v))))))

(define (consume-lambda thunk)
   (let loop ((v 0)
              (thunk thunk))
     (unless (eq? v max)
       (call-with-values thunk
         (lambda (v n)
           (loop (+ 1 v) n))))))

(define v2 (time-it (lambda () (consume-lambda (lazyseq-with-lambda)))))

(display "promise: ")
(display v1)
(newline)
(display "lambda: ")
(display v2)
(newline)

(define (lazyseq-with-stream)
   (list->stream (iota max)))

(define (consume-stream stream)
   (let loop ((v 0)
              (stream stream))
     (unless (eq? v max)
       (loop (+ 1 v) (stream-cdr stream)))))

(define stream (lazyseq-with-stream))
(define v3 (time-it (lambda () (consume-stream stream))))

(display "stream: ")
(display v3)
(newline)

Happy hacking!