Re: [MIT-Scheme-devel] A tellurion for the faithful.

[Matt Birkholz]

> From: "Arthur A. Gleckler" <address@hidden>
> Date: Mon, 15 Apr 2013 15:36:33 -0700
> 
> [...]
> 
> Beautiful!

Thanks.  Yes, it reminds me of my own home.

Nice data set!  The riv and bdy data are gone?

The app is intentionally trashy, passing all flonums to Cairo through
a simple, coordinate-per-argument mode, thus copying them all to the
heap (into flo:vectors of length 1!).

The rest of the code keeps flonums in short flo:vectors (points,
matrices).  The LAP for procedures like 3d-transform! (below) looks
nice and tight, not even an interrupt check(!).  (But what are the
three float->object instructions about?  Can I punt them?)

So I am eager to see how much rendering time drops simply by switching
to a friendlier library function, e.g.

    void cairo_stroke_me (cairo_t *cr, SCHEME_OBJECT list);

Here's the 3d-transform! LAP&RTL:

        (entry-point 3d-transform!-50)
        (scheme-object |CONSTANT-0| debugging-info)
        (scheme-object |CONSTANT-1| environment)
        ;; (procedure-header 3d-transform!-47 4 4)
        (equate 3d-transform!-50 3d-transform!-47)
        (word u #x404)
        (block-offset 3d-transform!-47)
3d-transform!-47:
        ;; (assign (register #x10) (offset (register 4) (machine-constant 0)))
        (mov w (r 0) (@r 4))
        ;; (assign (register #x11) (object->address (register #x10)))
        (and w (r 0) (r 5))
        ;; (assign (register #x13) (float-offset (offset-address (register 
#x11) (machine-constant 1)) (machine-constant 2)))
        (fld d (@ro b 0 #x14))
        (fstp (st 1))
        ;; (assign (register #x14) (float->object (register #x13)))
        (mov w (@r 7) (&u #x9c000002))
        (fst d (@ro b 7 4))
        (lea (r 1) (@ro uw 7 #x18000000))
        (add w (r 7) (& #xc))
        ;; (assign (pre-increment (register 4) -1) (register #x14))
        (push (r 1))
        ;; (assign (register #x18) (float-offset (offset-address (register 
#x11) (machine-constant 1)) (machine-constant 1)))
        (fld d (@ro b 0 #xc))
        (fstp (st 2))
        ;; (assign (register #x19) (float->object (register #x18)))
        (mov w (@r 7) (&u #x9c000002))
        (fld (st 1))
        (fstp d (@ro b 7 4))
        (lea (r 1) (@ro uw 7 #x18000000))
        (add w (r 7) (& #xc))
        ;; (assign (pre-increment (register 4) -1) (register #x19))
        (push (r 1))
        ;; (assign (register #x1d) (float-offset (offset-address (register 
#x11) (machine-constant 1)) (machine-constant 0)))
        (fld d (@ro b 0 4))
        (fstp (st 3))
        ;; (assign (register #x1e) (float->object (register #x1d)))
        (mov w (@r 7) (&u #x9c000002))
        (fld (st 2))
        (fstp d (@ro b 7 4))
        (lea (r 0) (@ro uw 7 #x18000000))
        (add w (r 7) (& #xc))
        ;; (assign (pre-increment (register 4) -1) (register #x1e))
        (push (r 0))
        ;; (assign (register #x20) (offset (register 4) (machine-constant 4)))
        (mov w (r 0) (@ro b 4 #x10))
        ;; (assign (register #x21) (object->address (register #x20)))
        (and w (r 0) (r 5))
        ;; (assign (register #x26) (register #x1d))
        ;; (assign (register #x27) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 0)))
        (fld d (@ro b 0 4))
        (fstp (st 4))
        ;; (assign (register #x28) (flonum-2-args flonum-multiply (register 
#x26) (register #x27) #f))
        (fld (st 2))
        (fmulp (st 4) (st 0))
        ;; (assign (register #x30) (register #x18))
        ;; (assign (register #x31) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 1)))
        (fld d (@ro b 0 #xc))
        (fstp (st 5))
        ;; (assign (register #x32) (flonum-2-args flonum-multiply (register 
#x30) (register #x31) #f))
        (fld (st 1))
        (fmulp (st 5) (st 0))
        ;; (assign (register #x3a) (register #x13))
        ;; (assign (register #x3b) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 2)))
        (fld d (@ro b 0 #x14))
        (fstp (st 6))
        ;; (assign (register #x3c) (flonum-2-args flonum-multiply (register 
#x3a) (register #x3b) #f))
        (fmul (st 5) (st 0))
        ;; (assign (register #x3e) (register #x32))
        ;; (assign (register #x40) (flonum-2-args flonum-add (register #x3e) 
(register #x3c) #f))
        (fld (st 4))
        (faddp (st 6) (st 0))
        ;; (assign (register #x42) (register #x28))
        ;; (assign (register #x44) (flonum-2-args flonum-add (register #x42) 
(register #x40) #f))
        (fld (st 3))
        (faddp (st 6) (st 0))
        ;; (assign (register #x9b) (offset (register 4) (machine-constant 5)))
        (mov w (r 1) (@ro b 4 #x14))
        ;; (assign (register #x9c) (object->address (register #x9b)))
        (and w (r 1) (r 5))
        ;; (assign (float-offset (offset-address (register #x9c) 
(machine-constant 1)) (machine-constant 0)) (register #x44))
        (fld (st 5))
        (fstp d (@ro b 1 4))
        ;; (assign (register #x4d) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 3)))
        (fld d (@ro b 0 #x1c))
        (fstp (st 6))
        ;; (assign (register #x4e) (flonum-2-args flonum-multiply (register 
#x26) (register #x4d) #f))
        (fld (st 2))
        (fmulp (st 6) (st 0))
        ;; (assign (register #x57) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 4)))
        (fld d (@ro b 0 #x24))
        (fstp (st 4))
        ;; (assign (register #x58) (flonum-2-args flonum-multiply (register 
#x30) (register #x57) #f))
        (fld (st 1))
        (fmulp (st 4) (st 0))
        ;; (assign (register #x61) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 5)))
        (fld d (@ro b 0 #x2c))
        (fstp (st 5))
        ;; (assign (register #x62) (flonum-2-args flonum-multiply (register 
#x3a) (register #x61) #f))
        (fmul (st 4) (st 0))
        ;; (assign (register #x64) (register #x58))
        ;; (assign (register #x66) (flonum-2-args flonum-add (register #x64) 
(register #x62) #f))
        (fld (st 3))
        (faddp (st 5) (st 0))
        ;; (assign (register #x68) (register #x4e))
        ;; (assign (register #x9a) (flonum-2-args flonum-add (register #x68) 
(register #x66) #f))
        (fld (st 5))
        (faddp (st 5) (st 0))
        ;; (assign (float-offset (offset-address (register #x9c) 
(machine-constant 1)) (machine-constant 1)) (register #x9a))
        (fld (st 4))
        (fstp d (@ro b 1 #xc))
        ;; (assign (register #x73) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 6)))
        (fld d (@ro b 0 #x34))
        (fstp (st 5))
        ;; (assign (register #x74) (flonum-2-args flonum-multiply (register 
#x26) (register #x73) #f))
        (fld (st 2))
        (fmulp (st 5) (st 0))
        ;; (assign (register #x7d) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 7)))
        (fld d (@ro b 0 #x3c))
        (fstp (st 3))
        ;; (assign (register #x7e) (flonum-2-args flonum-multiply (register 
#x30) (register #x7d) #f))
        (fld (st 1))
        (fmulp (st 3) (st 0))
        ;; (assign (register #x87) (float-offset (offset-address (register 
#x21) (machine-constant 1)) (machine-constant 8)))
        (fld d (@ro b 0 #x44))
        (fstp (st 2))
        ;; (assign (register #x88) (flonum-2-args flonum-multiply (register 
#x3a) (register #x87) #f))
        (fmul (st 0) (st 1))
        ;; (assign (register #x8a) (register #x7e))
        ;; (assign (register #x8c) (flonum-2-args flonum-add (register #x8a) 
(register #x88) #f))
        (fadd (st 0) (st 2))
        ;; (assign (register #x8e) (register #x74))
        ;; (assign (register #x95) (flonum-2-args flonum-add (register #x8e) 
(register #x8c) #f))
        (fadd (st 0) (st 4))
        ;; (assign (float-offset (offset-address (register #x9c) 
(machine-constant 1)) (machine-constant 2)) (register #x95))
        (fst d (@ro b 1 #x14))
        ;; (assign (offset (register 6) (machine-constant 2)) (constant 
#!unspecific))
        (mov w (@ro b 6 8) (&u #x20000001))
        ;; (assign (register 4) (offset-address (register 4) (machine-constant 
6)))
        (add w (r 4) (& #x18))
        ;; (pop-return)
        (pop (r 0))
        (and w (r 0) (r 5))
        (jmp (r 0))