drop some old commented out code

mandelbrot_hotspot_impl macro calls through to the
sqr16_impl and imul16_impl macros with the xe mode

this is backed by two realized functions, as
mandelbrot_hotspot and mandelbrot_hotspot_xe

these are also called via direct jmp instead of jsr/rts
because there's only one call site so we can save 6 cycles
per iteration by jmp/jmp

could save 6 more cycles per iter by specializing all of
the mandelbrot proc but there isn't room in ram right now

sqr16_func is removed as it is unused and we ran out of
code space adding the hotspot's extra implementations

imul16_func is kept, as it's called via zoom_factor
in a couple of places. this forwards to the xe version
at a cost of 3 cycles, as the call sites aren't patched

Makefile

@@ -2,8 +2,11 @@
 
 all : mandel.xex
 
-mandel.xex : mandel.o tables.o atari-asm-xex.cfg
-	ld65 -C ./atari-asm-xex.cfg -o $@ mandel.o tables.o
+mandel.xex : mandel.o mandel-core.o tables.o atari-xex.cfg
+	ld65 -C ./atari-xex.cfg --mapfile mandel.map -o $@ mandel.o mandel-core.o tables.o atari.lib
+
+mandel.s : mandel.c mandel.h
+	cc65 -o $@ mandel.c
 
 %.o : %.s
 	ca65 -o $@ $<
@@ -13,6 +16,7 @@ tables.s : tables.js
 
 clean :
 	rm -f tables.s
+	rm -f mandel.s
 	rm -f *.o
 	rm -f *.xex
-
+	rm -f mandel.map

atari-xex.cfg

@@ -0,0 +1,69 @@
+# Sample linker configuration for C programs using the Atari binary file support.
+# Use with: cl65 -tatari -Catari-xex.cfg prog.c -o prog.xex
+FEATURES {
+    STARTADDRESS: default = $8000;
+}
+SYMBOLS {
+    __SYSTEM_CHECK__:    type = import;  # force inclusion of "system check" load chunk
+    __STACKSIZE__:       type = weak, value = $0800; # 2k stack
+    __STARTADDRESS__:    type = export, value = %S;
+    __RESERVED_MEMORY__: type = weak, value = $0000;
+    __SYSCHKHDR__:       type = export, value = 0; # Disable system check header
+    __SYSCHKTRL__:       type = export, value = 0; # Disable system check trailer
+    __TABLESEG_START__:    type = weak, value = $2E00 + $0300;
+    __TABLESEG_SIZE__:     type = weak, value = 6 * $100;
+    __BANKSY_START__:  type = weak, value = $4000;
+    __BANKSY_SIZE__:   type = weak, value = $4000;
+    __FRAMEBUFFER_START__: type = weak, value = $A000;
+}
+MEMORY {
+# Note -- $80 and $81 (LOMEM) appear to be reserved in ZP.
+    ZP:         file = "", define = yes, start = $0082, size = $007E;
+# "system check" load chunk
+    SYSCHKCHNK: file = %O,               start = $2E00, size = $0300;
+# Note $a000-$bfff is against the BASIC cartridge, may require booting with OPTION.
+    TABLES:     file = %O, define = yes, start = __TABLESEG_START__, size = __TABLESEG_SIZE__;
+# We reserve $4000-7fff for the bank-switch window.
+# In theory we could keep data and code here that we only use on 48k/64k systems.
+    BANKSWITCH: file = "", define = yes, start = __BANKSY_START__, size = __BANKSY_SIZE__;
+# "main program" load chunk
+    MAIN:       file = %O, define = yes, start = %S, size = __FRAMEBUFFER_START__ - __STACKSIZE__ - __RESERVED_MEMORY__ - %S;
+}
+FILES {
+    %O: format = atari;
+}
+FORMATS {
+    atari: runad = start,
+           initad = SYSCHKCHNK: __SYSTEM_CHECK__;
+}
+SEGMENTS {
+    ZEROPAGE:  load = ZP,         type = zp;
+    EXTZP:     load = ZP,         type = zp,                optional = yes;
+    SYSCHK:    load = SYSCHKCHNK, type = rw,  define = yes, optional = yes;
+    TABLES:    load = TABLES,     type = ro,  optional = yes, align = 256;
+    BANKSWICH: load = BANKSWITCH, type = ro,  optional = yes;
+    STARTUP:   load = MAIN,       type = ro,  define = yes;
+    LOWBSS:    load = MAIN,       type = rw,                optional = yes;  # not zero initialized
+    LOWCODE:   load = MAIN,       type = ro,  define = yes, optional = yes;
+    ONCE:      load = MAIN,       type = ro,                optional = yes;
+    CODE:      load = MAIN,       type = ro,  define = yes;
+    RODATA:    load = MAIN,       type = ro;
+    DATA:      load = MAIN,       type = rw;
+    INIT:      load = MAIN,       type = rw,                optional = yes;
+    BSS:       load = MAIN,       type = bss, define = yes;
+}
+FEATURES {
+    CONDES: type    = constructor,
+            label   = __CONSTRUCTOR_TABLE__,
+            count   = __CONSTRUCTOR_COUNT__,
+            segment = ONCE;
+    CONDES: type    = destructor,
+            label   = __DESTRUCTOR_TABLE__,
+            count   = __DESTRUCTOR_COUNT__,
+            segment = RODATA;
+    CONDES: type    = interruptor,
+            label   = __INTERRUPTOR_TABLE__,
+            count   = __INTERRUPTOR_COUNT__,
+            segment = RODATA,
+            import  = __CALLIRQ__;
+}

bitmul.s

@@ -0,0 +1,124 @@
+; the old 16-bit bit-and-shift multiplier
+; copied from old code, won't compile as-is
+
+; inner loop for imul16
+; bitnum < 8: 25 or 41 cycles
+; bitnum >= 8: 30 or 46 cycles
+.macro bitmul16 arg1, arg2, result, bitnum
+    .local zero
+    .local one
+    .local next
+
+    ; does 16-bit adds
+    ; arg1 and arg2 are treated as unsigned
+    ; negative signed inputs must be flipped first
+
+    ; 7 cycles up to the branch
+
+    ; check if arg1 has 0 or 1 bit in this place
+    ; 5 cycles either way
+    .if bitnum < 8
+        lda arg1                 ; 3 cyc
+        and #(1 << (bitnum))       ; 2 cyc
+    .else
+        lda arg1 + 1             ; 3 cyc
+        and #(1 << ((bitnum) - 8)) ; 2 cyc
+    .endif
+    bne one ; 2 cyc
+
+zero: ; 18 cyc, 23 cyc
+    lsr result + 3 ; 5 cyc
+    jmp next       ; 3 cyc
+
+one: ; 32 cyc, 37 cyc
+    ; 16-bit add on the top bits
+    clc            ; 2 cyc
+    lda result + 2 ; 3 cyc
+    adc arg2       ; 3 cyc
+    sta result + 2 ; 3 cyc
+    lda result + 3 ; 3 cyc
+    adc arg2 + 1   ; 3 cyc
+    ror a          ; 2 cyc - get a jump on the shift
+    sta result + 3 ; 3 cyc
+next:
+    ror result + 2 ; 5 cyc
+    ror result + 1 ; 5 cyc
+    .if bitnum >= 8
+        ; we can save 5 cycles * 8 bits = 40 cycles total by skipping this byte
+        ; when it's all uninitialized data
+        ror result ; 5 cyc
+    .endif
+
+.endmacro
+
+; 5 to 25 cycles
+.macro check_sign arg
+    ; Check sign bit and flip argument to postive,
+    ; keeping a count of sign bits in the X register.
+    .local positive
+    lda arg + 1   ; 3 cyc
+    bpl positive  ; 2 cyc
+    neg16 arg     ; 18 cyc
+    inx           ; 2 cyc
+positive:
+.endmacro
+
+; 518 - 828 cyc
+.macro imul16 dest, arg1, arg2
+    copy16 FR0, arg1  ; 12 cyc
+    copy16 FR1, arg2  ; 12 cyc
+    jsr imul16_func   ; 470-780 cyc
+    copy32 dest, FR2  ; 24 cyc
+.endmacro
+
+
+.macro shift_round_16 arg, shift
+    .repeat shift
+        shl32 arg
+    .endrepeat
+    round16 arg
+.endmacro
+
+.macro imul16_round dest, arg1, arg2, shift
+    copy16 FR0, arg1  ; 12 cyc
+    copy16 FR1, arg2  ; 12 cyc
+    jsr imul16_func   ; 470-780 cyc
+    shift_round_16 FR2, shift
+    copy16 dest, FR2 + 2  ; 12 cyc
+.endmacro
+
+; min 470 cycles
+; max 780 cycles
+.proc imul16_func
+    arg1 = FR0   ; 16-bit arg (clobbered)
+    arg2 = FR1   ; 16-bit arg (clobbered)
+    result = FR2 ; 32-bit result
+
+    ldx #0          ; 2 cyc
+    ; counts the number of sign bits in X
+    check_sign arg1 ; 5 to 25 cyc
+    check_sign arg2 ; 5 to 25 cyc
+    
+    ; zero out the 32-bit temp's top 16 bits
+    lda #0          ; 2 cyc
+    sta result + 2  ; 3 cyc
+    sta result + 3  ; 3 cyc
+    ; the bottom two bytes will get cleared by the shifts
+
+    ; unrolled loop for maximum speed, at the cost
+    ; of a larger routine
+    ; 440 to 696 cycles
+    .repeat 16, bitnum
+        ; bitnum < 8: 25 or 41 cycles
+        ; bitnum >= 8: 30 or 46 cycles
+        bitmul16 arg1, arg2, result, bitnum
+    .endrepeat
+
+    ; In case of mixed input signs, return a negative result.
+    cpx #1              ; 2 cyc
+    bne positive_result ; 2 cyc
+    neg32 result        ; 34 cyc
+positive_result:
+
+    rts ; 6 cyc
+.endproc

mandel.c

@@ -0,0 +1,15 @@
+/**
+ * The UI and I/O wrapper for the Mandelbrot runner, in C.
+ *
+ * For the moment *all* logic is in mandel-core.s, I'm just
+ * trying to get this to run within a cc65 environment.
+ * Eventually just the inner loop fun will live in there.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "mandel.h"
+
+void main(void) {
+    mandel_start();
+}

mandel.h

@@ -0,0 +1,4 @@
+#include <inttypes.h>
+
+// From mandel-core.s:
+extern void mandel_start(void);

readme.md

@@ -18,7 +18,7 @@ Enjoy! I'll probably work on this off and on for the next few weeks until I've g
 
 ## Current state
 
-Basic rendering is functional, with interactive zoom/pan (+/-/arrows) and 4 preset viewports via the number keys.
+Basic rendering is functional, with interactive zoom/pan (+/-/arrows) and 6 preset viewports via the number keys.
 
 The 16-bit signed integer multiplication takes two 16-bit inputs and emits one 32-bit output in the zero page, using the Atari OS ROM's floating point registers as workspaces. Inputs are clobbered.
 
@@ -27,7 +27,7 @@ The 16-bit signed integer multiplication takes two 16-bit inputs and emits one 3
 * when expanded RAM is available as on 130XE, a 64KB 8-bit multiplication table accelerates the remaining multiplications
 * without expanded RAM, a table of half-squares is used to implement the algorithm from https://everything2.com/title/Fast+6502+multiplication
 
-The mandelbrot calculations are done using 4.12-precision fixed point numbers. It may be possible to squish this down to 3.13.
+The mandelbrot calculations are done using 3.13-precision fixed point numbers with 6.26-precision intermediates.
 
 Iterations are capped at 255.
 
@@ -47,4 +47,4 @@ Currently produces a `.xex` executable, which can be booted up in common Atari e
 
 ## Todo
 
-See ideas in `todo.md`.
+See ideas in `todo.md`.

todo.md

@@ -1,15 +1,17 @@
 things to try:
 
+* fix status bar to show elapsed time, per-iter time, per-pixel iter count
+
+* 'turbo' mode disabling graphics in full or part
+
 * patch the entire expanded-ram imul8xe on top of imul8 to avoid the 3-cycle thunk penalty :D
 
-* try 3.13 fixed point instead of 4.12 for more precision
-  * can we get away without the extra bit?
+* maybe clean up the load/layout of the big mul table
+
+* consider alternate lookup tables in the top 16KB under ROM
 
 * y-axis mirror optimization
 
-* 'wide pixels' 2x and 4x for a fuller initial image in the tiered rendering
-  * maybe redo tiering to just 4x4, 2x2, 1x1?
-
 * extract viewport for display & re-input via keyboard
 
 * fujinet screenshot/viewport uploader