whee

not working at present

Makefile

@@ -2,11 +2,8 @@
 
 all : mandel.xex
 
-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
+mandel.xex : mandel.o tables.o
+	ld65 -C ./atari-asm-xex.cfg -o $@ $+
 
 %.o : %.s
 	ca65 -o $@ $<
@@ -16,7 +13,6 @@ tables.s : tables.js
 
 clean :
 	rm -f tables.s
-	rm -f mandel.s
 	rm -f *.o
 	rm -f *.xex
-	rm -f mandel.map
+

atari-asm-xex.cfg

@@ -1,28 +0,0 @@
-FEATURES {
-    STARTADDRESS: default = $2E00;
-}
-SYMBOLS {
-    __STARTADDRESS__: type = export, value = %S;
-}
-MEMORY {
-    ZP:      file = "", define = yes, start = $0082, size = $007E;
-    MAIN:    file = %O, define = yes, start = %S,    size = $4000 - %S;
-    # Keep $4000-7fff clear for expanded RAM access window
-    TABLES:  file = %O, define = yes, start = $8000, size = $a000 - $8000;
-    # Keep $a000-$bfff clear for BASIC cartridge
-}
-FILES {
-    %O: format = atari;
-}
-FORMATS {
-    atari: runad = start;
-}
-SEGMENTS {
-    ZEROPAGE: load = ZP,      type = zp,  optional = yes;
-    EXTZP:    load = ZP,      type = zp,  optional = yes; # to enable modules to be able to link to C and assembler programs
-    CODE:     load = MAIN,    type = rw,                  define = yes;
-    RODATA:   load = MAIN,    type = ro   optional = yes;
-    DATA:     load = MAIN,    type = rw   optional = yes;
-    BSS:      load = MAIN,    type = bss, optional = yes, define = yes;
-    TABLES:   load = TABLES,  type = ro,  optional = yes, align = 256;
-}

atari-xex.cfg

@@ -1,69 +0,0 @@
-# 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

@@ -1,124 +0,0 @@
-; 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

@@ -1,15 +0,0 @@
-/**
- * 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

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

readme.md

@@ -14,37 +14,32 @@ Non-goals:
 
 Enjoy! I'll probably work on this off and on for the next few weeks until I've got it producing fractals.
 
--- brooke, january 2023 - december 2024
+-- brooke, january 2023 - february 2024
 
 ## Current state
 
-Basic rendering is functional, with interactive zoom/pan (+/-/arrows) and 6 preset viewports via the number keys.
+Basic rendering is functional, but no interactive behavior (zoom/pan) or benchmarking is done yet.
 
-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.
+The 16-bit signed integer multiplication works; it 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.
 
-* 16-bit multiplies are decomposed into 4 8-bit unsigned multiplies and some addition
-* an optimized case for squares uses a table of 8-bit squares to reduce the number of 8-bit multiplication sub-ops
-* 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 main loop is a basic add-and-shift, using 16-bit adds which requires flipping the sign of negative inputs (otherwise you'd have to add all those sign-extension bits). Runs in 470-780 cycles depending on input.
 
-The mandelbrot calculations are done using 3.13-precision fixed point numbers with 6.26-precision intermediates.
+The mandelbrot calculations are done using 4.12-precision fixed point numbers. It may be possible to squish this down to 3.13.
 
 Iterations are capped at 255.
 
 The pixels are run in a progressive layout to get the basic shape on screen faster.
 
-There is a running counter of ms/px using the vertical blank interrupts as a timer, used to track our progress. :D
+## Next steps
 
-There's a check for cycles in (zx,zy) output when in the 'lake'; if values repeat, they cannot escape. This is a big time saver in fractint.
+Add a running counter of ms/px using the vertical blank interrupts as a timer. This'll show how further work improves it!
 
-There's some cute color cycling.
+Check for cycles in (zx,zy) output when in the 'lake'; if values repeat, they cannot escape. This is a big time saver in fractint.
+
+I may be able to do a faster multiply using tables of squares for 8-bit component multiplication.
 
 ## Deps and build instructions
 
 I'm using `ca65` as a macro assembler, and have a Unix-style `Makefile` for building. Should work fairly easily on Linux and Mac. Might work on "raw" Windows but I use WSL for that.
 
 Currently produces a `.xex` executable, which can be booted up in common Atari emulators and some i/o devices.
-
-## Todo
-
-See ideas in `todo.md`.

tables.js

@@ -11,40 +11,23 @@ function db(func) {
     return lines.join('\n');
 }
 
-let squares = [];
-for (let i = 0; i < 512; i++) {
-    squares.push(Math.trunc((i * i + 1) / 2));
-}
-
 console.log(
 `.segment "TABLES"
 
 .export mul_lobyte256
 .export mul_hibyte256
 .export mul_hibyte512
-.export sqr_lobyte
-.export sqr_hibyte
 
-; (i * i + 1) / 2 for the multiplier
 .align 256
 mul_lobyte256:
-${db((i) => squares[i] & 0xff)}
+${db((x) => Math.round(x * x / 2) & 0xff)}
 
 .align 256
 mul_hibyte256:
-${db((i) => (squares[i] >> 8) & 0xff)}
+${db((x) => (Math.round(x * x / 2) >> 8) & 0xff)}
 
 .align 256
 mul_hibyte512:
-${db((i) => (squares[i + 256] >> 8) & 0xff)}
-
-; (i * i) for the plain squares
-.align 256
-sqr_lobyte:
-${db((i) => (i * i) & 0xff)}
-
-.align 256
-sqr_hibyte:
-${db((i) => ((i * i) >> 8) & 0xff)}
+${db((x) => (Math.round((x + 256) * (x + 256) / 2) >> 8) & 0xff)}
 
 `);

todo.md

@@ -1,17 +0,0 @@
-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
-
-* 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
-
-* extract viewport for display & re-input via keyboard
-
-* fujinet screenshot/viewport uploader