]> wirehaze git hosting - lifeboot.git/blobdiff - lifeboot.asm

wirehaze git hosting

projects / lifeboot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
microoptimization for update_cell
[lifeboot.git] / lifeboot.asm
diff --git a/lifeboot.asm b/lifeboot.asm
index e44a671b9c8e4644491e1422377419354509cad0..67e7ce99b56247f0e328aefbec5388a59c8d71af 100644 (file)
--- a/lifeboot.asm
+++ b/lifeboot.asm
@@ -6,15 +6,15 @@ org 7c00h
 ; settings --------------------------------------------------------------------
 
 %define DEAD ' '            ; char to represent a dead cell
 ; settings --------------------------------------------------------------------
 
 %define DEAD ' '            ; char to represent a dead cell
-%define ALIVE '#'           ; char to represent an alive cell
+%define ALIVE '.'           ; char to represent an alive cell
 %define PRINT_COLOR 07h     ; grey on black
 %define PRINT_COLOR 07h     ; grey on black
-%define WAIT_DELAY 02h      ; 0.131072 seconds
+%define ITER_LIM 500        ; reset the simulation after this # iterations
 
 ; constants -------------------------------------------------------------------
 
 %define COLS 80
 %define ROWS 25
 
 ; constants -------------------------------------------------------------------
 
 %define COLS 80
 %define ROWS 25
-%define VGAPGSZ (COLS * ROWS * 2 + 96)  ; why 96 ??????
+%define VGAPGSZ 1000h       ; (bytes)
 
 ; memory layout ---------------------------------------------------------------
 
 
 ; memory layout ---------------------------------------------------------------
 
@@ -26,18 +26,21 @@ org 7c00h
 
 %define xss DAT             ; xs() state (word)
 %define currvgapg DAT + 2   ; current vga page near pointer (word)
 
 %define xss DAT             ; xs() state (word)
 %define currvgapg DAT + 2   ; current vga page near pointer (word)
+%define iter DAT + 4        ; current iteration # (word)
 
 ; =============================================================================
 
 ; entry point -----------------------------------------------------------------
 
 
 ; =============================================================================
 
 ; entry point -----------------------------------------------------------------
 
+entry:
+
 ; initialize segment registers
 mov ax, VGA >> 4
 ; initialize segment registers
 mov ax, VGA >> 4
-mov es, ax
+mov es, ax                  ; es:0 -> video memory
 
 xor ax, ax
 
 xor ax, ax
-mov ds, ax
-mov ss, ax
+mov ds, ax                  ; ds = 0
+mov ss, ax                  ; ss = 0
 
 ; set stack pointers
 mov bp, ORG
 
 ; set stack pointers
 mov bp, ORG
@@ -49,19 +52,17 @@ cld
 ; disable cursor
 mov ch, 3fh                 ; cursor start and options
 mov ah, 01h                 ; set text-mode cursor shape
 ; disable cursor
 mov ch, 3fh                 ; cursor start and options
 mov ah, 01h                 ; set text-mode cursor shape
-int 10h                     ; video services
+int 10h                     ; bios video services
 
 ; initialize xss
 
 ; initialize xss
+.set_xss:
+    mov ah, 00h             ; get system time
+    int 1ah                 ; bios time services
+                            ; cx:dx = # clock ticks since midnight
+    or dx, dx
+    jz .set_xss             ; wait for something meaningful
 
 
-set_xss_seed:
-
-mov ah, 00h                 ; get
-int 1ah                     ;  system time
-
-cmp dx, 0
-je set_xss_seed             ; if seed is 0, xs wont work properly
-
-mov [xss], dx               ; cx:dx = number of clock ticks since midnight
+mov [xss], dx
 
 ; initialize currvgapg
 mov word [currvgapg], 0
 
 ; initialize currvgapg
 mov word [currvgapg], 0
@@ -71,64 +72,43 @@ mov word [currvgapg], 0
 start:
 
 call init_grid
 start:
 
 call init_grid
+mov word [iter], 0
+
+.next_state:
 
 
-; apply game of life's rules to determine the next state ----------------------
+    call vsync_wait
+    call update_grid
 
 
-next_state:
+    call vsync_wait
+    call flip_vgapg
 
 
-call vsync_wait
-call write_next_vga_page
-call wait_keypress
-call flip_vga_page
+    inc word [iter]
+    cmp word [iter], ITER_LIM
+    jl .next_state
 
 
-jmp next_state
+jmp start                   ; reset
 
 ; =============================================================================
 
 ; functions -------------------------------------------------------------------
 
 
 ; =============================================================================
 
 ; functions -------------------------------------------------------------------
 
-; delay() - suspend program execution temporarily -----------------------------
-
-; clobbers ah, cx, dx
-
-delay:
-
-mov cx, WAIT_DELAY          ; cx:dx = interval in microseconds
-mov dx, 0
-
-mov ah, 86h
-int 15h                     ; wait
-
-ret
+; vsync_wait() - wait for display to enter the next retrace cycle -------------
 
 
-; wait_keypress() - wait for any keypress -------------------------------------
-
-; clobbers: ax
-
-wait_keypress:
-
-mov ah, 00h         ; read key press
-int 16h             ; keyboard services
-
-ret
-
-; vsync_wait() - wait for display to enter the next VBlank cycle --------------
-
-; clobbers ax, dx
+; clobbers al, dx
 
 vsync_wait:
 
 mov dx, 3dah                ; input status #1 register
 
 
 vsync_wait:
 
 mov dx, 3dah                ; input status #1 register
 
-.wait_on:
+.wait_retrace_end:
     in al, dx
     test al, 08h            ; vertical retrace bit
     in al, dx
     test al, 08h            ; vertical retrace bit
-    jnz .wait_on
+    jnz .wait_retrace_end
 
 
-.wait_off:
+.wait_retrace_start:
     in al, dx
     test al, 08h
     in al, dx
     test al, 08h
-    jz .wait_off
+    jz .wait_retrace_start
 
 ret
 
 
 ret
 
@@ -136,6 +116,7 @@ ret
 
 ; output:
 ; [xss]     = updated state
 
 ; output:
 ; [xss]     = updated state
+; bx        = [xss]
 
 ; clobbers bx, dx
 
 
 ; clobbers bx, dx
 
@@ -169,38 +150,39 @@ mov di, [currvgapg]         ; es:di -> grid start
 mov cx, COLS * ROWS         ; for each cell
 
 .write_cell:                ; do {
 mov cx, COLS * ROWS         ; for each cell
 
 .write_cell:                ; do {
-    call xs                 ;     [xss] = rand
+    call xs                 ;     bx = random value
     mov al, DEAD            ;     al = DEAD (likely)
 
     mov al, DEAD            ;     al = DEAD (likely)
 
-    test word [xss], 0b11
+    test bx, 0b11
 
 
-    jnz  .nz                ;     if ([xss] % 4 == 0)
+    jnz  .nz                ;     if (bx % 4 == 0)
     mov al, ALIVE           ;         al = ALIVE
 
 .nz:
     mov al, ALIVE           ;         al = ALIVE
 
 .nz:
-    stosw                   ;     [es:di] = ax ; di += 2
+    stosw                   ;     [es:di] = ax, di += 2
 
     loop .write_cell        ; } while (--cx)
 
 ret
 
 
     loop .write_cell        ; } while (--cx)
 
 ret
 
-; flip_vga_page() - flip active display page ----------------------------------
+; flip_vgapg() - flip active display page -------------------------------------
 
 
-; clobbers ax, dx
+; output:
+; [currvgapg] ^= VGAPGSZ
 
 
-flip_vga_page:
+; clobbers ax
 
 
-call vsync_wait
+flip_vgapg:
 
 
-xor word [currvgapg], VGAPGSZ   ; flip currvgapg
-setnz al                        ; al = !(currvgapg == 0)
+xor word [currvgapg], VGAPGSZ
 
 
+setnz al                    ; al = !(currvgapg == 0)
 mov ah, 05h                 ; select active display page
 mov ah, 05h                 ; select active display page
-int 10h                     ; video services
+int 10h                     ; bios video services
 
 ret
 
 
 ret
 
-; alive_neighbours() ----------------------------------------------------------
+; alive_neighbours() - get number of alive adjacent cells ---------------------
 
 ; input:
 ; es:si     -> current grid
 
 ; input:
 ; es:si     -> current grid
@@ -222,7 +204,7 @@ enter 5, 0
 
 mov ax, cx                  ; ax = idx
 mov bl, COLS                ; bl = COLS
 
 mov ax, cx                  ; ax = idx
 mov bl, COLS                ; bl = COLS
-div bl                      ; al = idx / COLS ; ah = idx % COLS
+div bl                      ; al = idx / COLS, ah = idx % COLS
 
 mov [bp - 1], al            ; row = idx / COLS
 mov [bp - 2], ah            ; row = idx % COLS
 
 mov [bp - 1], al            ; row = idx / COLS
 mov [bp - 2], ah            ; row = idx % COLS
@@ -235,26 +217,26 @@ mov byte [bp - 4], -1       ; i = -1
 .j:                                 ; do {
 
         mov al, [bp - 4]
 .j:                                 ; do {
 
         mov al, [bp - 4]
-        or al, [bp - 5]
-        jz .continue                    ; if (!i && !j) continue
+        or al, [bp - 5]                 ; if (!i && !j)
+        jz .continue                    ;     continue
 
         mov al, [bp - 1]
         add al, [bp - 4]                ; al = row + i
 
 
         mov al, [bp - 1]
         add al, [bp - 4]                ; al = row + i
 
-        cmp al, 0
-        jl .continue                    ; if (row + i < 0) continue
+        cmp al, 0                       ; if (row + i < 0)
+        jl .continue                    ;     continue
 
 
-        cmp al, ROWS
-        jge .continue                   ; if (row + i >= ROWS) continue
+        cmp al, ROWS                    ; if (row + i >= ROWS)
+        jge .continue                   ;     continue
 
         mov ah, [bp - 2]
         add ah, [bp - 5]                ; ah = col + j
 
 
         mov ah, [bp - 2]
         add ah, [bp - 5]                ; ah = col + j
 
-        cmp ah, 0
-        jl .continue                    ; if (col + j < 0) continue
+        cmp ah, 0                       ; if (col + j < 0)
+        jl .continue                    ;     continue
 
 
-        cmp ah, COLS
-        jge .continue                   ; if (col + j >= COLS) continue
+        cmp ah, COLS                    ; if (col + j >= COLS)
+        jge .continue                   ;     continue
 
         movzx bx, ah                    ; bx = col + j
 
 
         movzx bx, ah                    ; bx = col + j
 
@@ -266,8 +248,8 @@ mov byte [bp - 4], -1       ; i = -1
 
         mov dx, [es:si + bx]            ; dl = cell state
 
 
         mov dx, [es:si + bx]            ; dl = cell state
 
-        cmp dl, ALIVE                   ; if (!ALIVE) continue
-        jne .continue
+        cmp dl, ALIVE                   ; if (!ALIVE)
+        jne .continue                   ;     continue
 
         inc byte [bp - 3]               ; neighbours++
 
 
         inc byte [bp - 3]               ; neighbours++
 
@@ -285,7 +267,7 @@ movzx ax, byte [bp - 3]     ; ax = # alive neighbours
 leave
 ret
 
 leave
 ret
 
-; write_next_cell_state() -----------------------------------------------------
+; update_cell() - write next cell state ---------------------------------------
 
 ; input:
 ; es:si     -> current grid
 
 ; input:
 ; es:si     -> current grid
@@ -297,7 +279,7 @@ ret
 
 ; clobbers ax, bx, dx
 
 
 ; clobbers ax, bx, dx
 
-write_next_cell_state:
+update_cell:
 
 call alive_neighbours       ; ax = # alive neighbours
 
 
 call alive_neighbours       ; ax = # alive neighbours
 
@@ -309,11 +291,9 @@ mov dx, [es:si + bx]        ; dl = cell current state
 cmp dl, ALIVE               ; if (ALIVE) {
 jne .else
 
 cmp dl, ALIVE               ; if (ALIVE) {
 jne .else
 
-cmp ax, 2                   ;     if (n < 2)
-jl .dead                    ;         return DEAD
-
-cmp ax, 3                   ;     if (n > 3)
-jg .dead                    ;         return DEAD
+shr ax, 1
+xor ax, 1                   ;     if (n != 2 || n != 3)
+jnz .dead                   ;         return DEAD (likely)
 
 jmp .alive                  ;     return ALIVE
 
 
 jmp .alive                  ;     return ALIVE
 
@@ -334,25 +314,25 @@ mov [es:di + bx], dx
 
 ret
 
 
 ret
 
-; write_next_vga_page() -------------------------------------------------------
+; update_grid() - write next grid (inactive vga page) -------------------------
 
 ; clobbers di, si, ax, bx, cx, dx
 
 
 ; clobbers di, si, ax, bx, cx, dx
 
-write_next_vga_page:
+update_grid:
 
 mov si, [currvgapg]         ; es:si -> current page
 
 mov di, VGAPGSZ
 xor di, si                  ; es:di -> next page
 
 
 mov si, [currvgapg]         ; es:si -> current page
 
 mov di, VGAPGSZ
 xor di, si                  ; es:di -> next page
 
-xor cx, cx                  ; i = 0
+mov cx, COLS * ROWS - 1     ; for each cell (index)
+
+.update_loop:               ; do {
 
 
-.update_loop:
-call write_next_cell_state
+    call update_cell
 
 
-inc cx
-cmp cx, COLS * ROWS
-jl .update_loop             ; for i in [0 .. COLS * ROWS - 1]
+    dec cx
+    jns .update_loop        ; } while (--cx > 0)
 
 ret
 
 
 ret