Add support for S7 scheme

[mgubi]

It would be interesting to have S7 scheme in the benchmark. It is a interpreted scheme, successor of Tinyscheme, but much faster. S7 has a compatibility layer for r7rs, see below a possible prelude.

I've performed some preliminary tests on my machine (MacBookAir 2019) and the results are the following (comparison with Guile 1.8 and 3.0.4).

test	S7	Guile1.8.8	Guile3.0.4
browse	24.27	80.32	12.060597
deriv	25.194	61.39	18.581995
destruc	52.077	TIMELIM	7.143701
diviter	9.685	77.85	15.453743
divrec	11.803	78.55	17.41294
puzzle	27.716	191.35	18.086531
triangl	33.931	98.16	8.519252
tak	12.925	134.2	4.757643
takl	20.968	TIMELIM	9.456034
ntakl	17.073	TIMELIM	9.516082
cpstak	103.358	221.03	59.444873
ctak	44.139	TIMELIM	TIMELIM
fib	10.218	195.78	12.090909
fibc	25.799	TIMELIM	TIMELIM
fibfp	1.885	45.98	22.001634
sum	6.637	281.63	6.866215
sumfp	2.499	105.1	42.058511
fft	32.198	TIMELIM	7.685201
mbrot	24.403	TIMELIM	50.086067
mbrotZ	18.556	TIMELIM	67.011491
nucleic	19.946	67.46	15.347245
pi	NO	TIMELIM	0.564552
pnpoly	17.981	TIMELIM	24.886723
ray	20.455	TIMELIM	18.51229
simplex	46.344	TIMELIM	13.895531
ack	10.572	TIMELIM	8.413945
array1	11.483	160.88	9.241778
string	1.714	1.82	1.872806
sum1	0.47	1.63	4.427402
cat	1.187	TIMELIM	28.396944
tail	1.188	TIMELIM	9.821691
wc	8.266	57.91	16.963138
read1	406	0.95	5.804979
compiler	41.155	TIMELIM	5.149011
conform	51.031	TIMELIM	10.508732
dynamic	22.736	69.58	7.374259
earley	TIMELIM	TIMELIM	9.489885
graphs	127.611	TIMELIM	23.026826
lattice	139.275	292.7	15.937364
matrix	72.073	TIMELIM	9.881781
maze	23.258	TIMELIM	4.70391
mazefun	19.51	129.61	9.664338
nqueens	55.11	TIMELIM	19.372148
paraffins	31.424	TIMELIM	4.24542
parsing	39.443	TIMELIM	10.687959
peval	29.677	98.91	15.644764
primes	7.73	39.33	7.521318
quicksort	93.996	TIMELIM	13.252736
scheme	71.462	TIMELIM	15.142413
slatex	32.069	48.96	45.047143
chudnovski	NO	TIMELIM	0.306648
nboyer	39.274	151.42	5.10214
sboyer	31.537	168.81	4.755798
gcbench	20.54	TIMELIM	3.511493
mperm	173.33	TIMELIM	10.650118
equal	781	TIMELIM	TIMELIM
bv2string	10.782	TIMELIM	4.489627

chudnovski and pi fails but should be easy to arrange for that.

This is the s7.prelude I'm using

(define (this-scheme-implementation-name) "s7")
(define exact-integer? integer?)        
(define (exact-integer-sqrt i) (let ((sq (floor (sqrt i)))) (values sq (- i (* sq sq)))))
(define inexact exact->inexact)
(define exact inexact->exact)
(define (square x) (* x x))
(define (vector-map f v) (copy v)) ; for quicksort.scm
(define-macro (import . args) #f)
(define (jiffies-per-second) 1000)
(define (current-jiffy) (round (* (jiffies-per-second) (*s7* 'cpu-time))))
(define (current-second) (floor (*s7* 'cpu-time)))

(define read-u8 read-byte)
(define write-u8 write-byte) 
(define u8-ready? char-ready?) 
(define peek-u8 peek-char)
(define* (utf8->string v (start 0) end) 
  (if (string? v)
      v
      (substring (byte-vector->string v) start (or end (length v)))))
(define* (string->utf8 s (start 0) end) 
  (if (byte-vector? s)
      s
      (string->byte-vector (utf8->string s start end))))
(define write-simple write)

(define* (string->vector s (start 0) end)
  (let ((stop (or end (length s)))) 
    (copy s (make-vector (- stop start)) start stop)))

(define vector-copy string->vector)
(define* (vector-copy! dest at src (start 0) end) ; end is exclusive
  (let ((len (or end (length src))))
    (if (or (not (eq? dest src))
            (<= at start))
        (do ((i at (+ i 1))
             (k start (+ k 1)))
            ((= k len) dest)
          (set! (dest i) (src k)))
        (do ((i (- (+ at len) start 1) (- i 1))
             (k (- len 1) (- k 1)))
            ((< k start) dest)
          (set! (dest i) (src k))))))

(define make-bytevector make-byte-vector)
(define bytevector-ref byte-vector-ref)
(define bytevector-set! byte-vector-set!)
(define bytevector-copy! vector-copy!)
(define bytevector-u8-ref byte-vector-ref)
(define bytevector-u8-set! byte-vector-set!)

;; records
(define-macro (define-record-type type make ? . fields)
  (let ((obj (gensym))
        (args (map (lambda (field)
                     (values (list 'quote (car field))
                             (let ((par (memq (car field) (cdr make))))
                               (if (pair? par) (car par) #f))))
                   fields)))
    `(begin
       (define (,? ,obj)
         (and (let? ,obj)
              (eq? (let-ref ,obj 'type) ',type)))

       (define ,make 
         (inlet 'type ',type ,@args))

       ,@(map
          (lambda (field)
            (when (pair? field)
              (if (null? (cdr field))
                  (values)
                  (if (null? (cddr field))
                      `(define (,(cadr field) ,obj)
                         (let-ref ,obj ',(car field)))
                      `(begin
                         (define (,(cadr field) ,obj)
                           (let-ref ,obj ',(car field)))
                         (define (,(caddr field) ,obj val)
                           (let-set! ,obj ',(car field) val)))))))
          fields)
       ',type)))

[ecraven]

How do you actually run/compile s7? it doesn't seem to come with any obvious build system for a standalone executable.

[lassik]

Here's how we build a standalone command-line interpreter: https://github.com/scheme-containers/s7

It is normally embedded in a C program, but I assume that's not relevant for the benchmarks.

[ecraven]

Closed by cd6ea87a6fa7d20424449b5d08dcd5bf990f26e4