Welcome to the CHICKEN Scheme pasting service

;;; testing base64 encoding algorithm (the non-padding part, anyway)
;;; chicken5.4.0 is at around 200MB/s and c6 is at around 100MB/s. a C implementation is
;;; included for reference, which , on my machine, does at around 2000MB/s for both C5 and C6.
;;;
;;; csc6git -v -m main -O5 bench64.scm
;;; pv -Ss 8G /dev/zero | ./bench64 >/dev/null
;;;  0:00:42 [93.3MiB/s] ...
;;;
;;; csc5 -m main -O5 bench64.scm -o bench64-c5
;;; pv -Ss 64G /dev/zero | ./bench64-c5 >/dev/null
;;;  0:00:14 [ 215MiB/s] ...
;;; csc6git -v -m main -O5 bench64.scm -o bench64-c
;;; [csi6g] klm@rex ~/p/chicken-base64 > pv -Ss 8G /dev/zero | ./bench64-c >/dev/null
;;;   0:00:04 [1.96GiB/s] ...
;;;
;;; 2 questions:
;;; (1) why does C6 perform worse than C5? I tried to dodge all UTF8/encoding mechanisms.
;;; (2) I might have expected this to do bettar than 10% of its C counterpart. Is there anything
;;;     that could be done to allow the Chicken compiler to improve on this?
;;;
;;; Note that I don't need to consider trailing or padding, I'm just interested in encoding
;;; large base64 chunks fast-ish. The corner-cases (padding, non-multiples of 3 byte input etc)
;;; doesn't warrant optimization. I'd love to see if the Scheme version of this alrogithm could
;;; compete with C, but I don't know if that's realistic.
;;;

(import chicken.bitwise srfi-4 ;;scheme.base
        chicken.fixnum chicken.foreign chicken.io
        srfi-4)

;; more or less taken from https://base64.dev/articles/base64-c
(foreign-declare "
static const char b64_enc_table[] =
    \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"
    \"abcdefghijklmnopqrstuvwxyz\"
    \"0123456789+/\";

int base64_encode(const uint8_t *in, const int in_start, const int in_end,
		   uint8_t *out, int out_start, int out_end) {

    size_t i, j;
    for (i = in_start, j = out_start; i + 2 < in_end; i += 3) {
        uint32_t n = ((uint32_t)in[i] << 16)
                   | ((uint32_t)in[i + 1] << 8)
                   |  (uint32_t)in[i + 2];
        out[j++] = b64_enc_table[(n >> 18) & 0x3F];
        out[j++] = b64_enc_table[(n >> 12) & 0x3F];
        out[j++] = b64_enc_table[(n >>  6) & 0x3F];
        out[j++] = b64_enc_table[ n        & 0x3F];
    }
    return j;
}
")

(define base64e/c (foreign-lambda int "base64_encode"
                             u8vector int int
                             u8vector int int))
(define base64e/scheme
  (let ()

    (define alphabet/default
      (list->u8vector
       (map char->integer
            (string->list
             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))))
    (define (lookup i) (u8vector-ref alphabet/default i))
    
    (lambda (in in-start in-end dest dest-start dest-end)
      (let ((stop (- in-end 2)))
        (let loop ((in-pos in-start)
                   (dest-pos dest-start))
          (if (fx<= in-pos stop)
              (let ((w (fx+      (fxshl (u8vector-ref in (fx+ in-pos 0)) 16)
                            (fx+ (fxshl (u8vector-ref in (fx+ in-pos 1))  8)
                                 (fxshl (u8vector-ref in (fx+ in-pos 2))  0)))))
                (u8vector-set! dest (fx+ dest-pos 0) (lookup (fxand (fxshr w -18) #x3F)))
                (u8vector-set! dest (fx+ dest-pos 1) (lookup (fxand (fxshr w -12) #x3F)))
                (u8vector-set! dest (fx+ dest-pos 2) (lookup (fxand (fxshr w  -6) #x3F)))
                (u8vector-set! dest (fx+ dest-pos 3) (lookup (fxand (fxshr w  -0) #x3F)))

                (loop (fx+ in-pos 3) (fx+ dest-pos 4)))
              dest-pos))))))

(let ((in  (make-u8vector 4096 0))
      (out (make-u8vector (* (quotient (+ 2 4096) 3) 4))))
  (let loop ()
    (let* ((in-read (cond-expand (chicken-6 (read-bytevector! in))
                                 (chicken-5 (read-u8vector! #f in))
                                 (else (error "bad bad no 6"))))
           (dest-read
            ( ;; base64e/scheme
              base64e/c
             in 0 in-read  out 0 (u8vector-length out))))
      (unless (zero? in-read)
        (cond-expand
         (chicken-6 (write-bytevector out (current-output-port) 0 dest-read))
         (chicken-5 (write-u8vector   out (current-output-port) 0 dest-read)))
        (loop)))))
Your nick:
The title of your paste:
Your paste (mandatory) :

What's the Makefile target to generate the bootstrap compiler of CHICKEN?