Vlákno názorů k článku Aritmetické operace s hodnotami uloženými binárně i ve formátu BCD od _dw - Upravil jsem jeste https://github.com/tisnik/8bit-fame/blob/master/Speccy-asm/77-add-hex-numbers.asm bez toho, ze bych...
-
Upravil jsem jeste https://github.com/tisnik/8bit-fame/blob/master/Speccy-asm/77-add-hex-numbers.asm bez toho, ze bych pouzil trik s DAA.
Zvlastni, ze se i pres to, ze vypisujes list toho vysledku, se nikdo nepozastavuje nad tim, ze pro druhy CALL pouzivas JP kvuli optimalizaci, ale pritom delas "nulovy" skok.
8028:C32B80 JP 802B 802B: label print_hex_digit
Protoze mas spravne umistenou rutinu print_hex_number nad print_hex_digit. Takze ten kod automaticky spravne "propadne" do print_hex_digit. Neni potreba vubec nic delat. Spravne umisteni rutin za sebou je v asembleru dulezite. Nekdy se dokonce o to misto nad pouzivanou rutinou poperou mezi sebou vic rutin a musis si zvolit, ktera se pouzije casteji.
Dalsi vec je pouziti call na rutiny new_line a space. Obe rutiny zabiraji bez RET 3 bajty (nevim jestli tohle ale normalni clovek hned vidi) a ten CALL samotny je na 3 bajty taky. Takze je to zbytecnych 17 taktu na CALL + 10 taktu na RET a kdyz se to "inkludne" tak ti odpadne i jeden bajt za ten RET.
Dalsi vec je trojnasobne pouziti B = 11. To uz se ti vyplati pouzit BC = 11*257 a k tomu 2x pouzit B = C.
Posledni vec je to neohrabene testovani zda mohu tisknout mezeru za cislo.
print_numbers: next_item: ld A, (HL) ; načíst hodnotu z pole inc HL ; přechod na další prvek pole call print_hex_number ; vytisknout hexa hodnotu ld A, B cp 1 ; za poslední hodnotou už nechceme tisknout mezeru jr Z, skip ; přeskočení tisku mezery u poslední hodnoty call space skip: djnz next_item ; zpracování dalšího prvku pole retTo jde napsat mnohem lepe pouhym preskupenim kodu. Tisk mezery das pred fci a vstupni bod bude az za tiskem mezery. Ale smycka bude skakat/se vracet na tisk mezery. Tim zarucis, ze mezera se netiskne jako prvni znak, ani jako posledni.
ENTRY_POINT equ $8000 ROM_CLS equ $0DAF OUT_NUM_1 equ $1A1B org ENTRY_POINT start: call ROM_CLS ; smazání obrazovky a otevření kanálu číslo 2 (screen) ld HL, array1 ; vytištění 11 hodnot z pole array1 v hexadecimálním formátu ld BC, 0x0B0B ; B = 11, C = 11 call print_numbers ld HL, array2 ; vytištění 11 hodnot z pole array2 v hexadecimálním formátu ld B, C call print_numbers ; odřádkování ld A, 0x0d ; kód znaku pro odřádkování rst 0x10 ; zavolání rutiny v ROM ld A, 0x0d ; kód znaku pro odřádkování rst 0x10 ; zavolání rutiny v ROM ld DE, array1 ; adresa pole s první řadou sčítanců ld HL, array2 ; adresa pole se druhou řadou sčítanců ld B, C next_add: ld A, (DE) ; načíst první sčítanec z pole add A, (HL) ; načíst druhý sčítanec z pole inc DE ; posun ukazatele na další sčítanec inc HL ; dtto call print_hex_number ; vytisknout hexa hodnotu výsledku ld A, 32 ; kód mezery rst 0x10 ; zavolání rutiny v ROM djnz next_add ; kontrola počtu zobrazených výsledků ret ; podprogram pro tisk sekvence numerických hodnot v hexadecimálním formátu ; vstupy: ; HL - ukazatel na pole s hodnotami ; B - počet hodnot (délka pole) next_item: ld A, 32 ; kód mezery rst 0x10 ; zavolání rutiny v ROM print_numbers: ; entry point ld A, (HL) ; načíst hodnotu z pole inc HL ; přechod na další prvek pole call print_hex_number ; vytisknout hexa hodnotu djnz next_item ; zpracování dalšího prvku pole ret array1: db 0x00, 0x01, 0x05, 0x09, 0x09, 0x09, 0x10, 0x10, 0xa0, 0xfe, 0xff array2: db 0x01, 0x02, 0x05, 0x01, 0x06, 0x07, 0x09, 0x10, 0x01, 0x01, 0x01 print_hex_number: push AF ; uschovat A pro pozdější využití rrca ; rotace o čtyři bity doprava rrca rrca rrca and $0f ; zamaskovat horní čtyři bity call print_hex_digit; vytisknout hexa číslici pop AF ; obnovit A and $0f ; zamaskovat horní čtyři bity ; jp print_hex_digit ; vytisknout hexa číslici a návrat z podprogramu ; fall to print_hex_digit print_hex_digit: cp 0x0a ; test, jestli je číslice menší než 10 jr c, print_0_to_9 ; ok, hodnota je menší než 10, budeme tedy tisknout desítkovou číslici add A, 65-10-48 ; ASCII kód znaku 'A', ovšem začínáme od desítky, ne od nuly (+ update pro další ADD) print_0_to_9: add A, 48 ; ASCII kód znaku '0' rst 0x10 ; zavolání rutiny v ROM pro tisk jednoho znaku ret ; návrat ze subrutiny end ENTRY_POINTZe 118 bajtu se dostanes na 101 bajtu.
-
Pavel TišnovskýZlatý podporovatelno vidíš, toho jsem si nevšiml. Zase ale pokud by někdo neznalý toho triku udělal refactoring a strčil si subrutiny někam do dalšího souboru, už by to takto nešlo (ale tím v žádném případě, neříkám, že nemáš pravdu - máš!)
OT: se tak dívám, že příště budu psát o Tvé doméně, pokud se tedy dívám na Tvoje repo s FP subrutinami (a není to shoda nicků).
-
Jestli tim trikem myslis nepouzivat skok a umistit rutina za sebe tak jsem to zkousel jeste krome komentare ze ty rutiny jsou "slepene" :
; fall to print_hex_digit
osetrit pres nejaky
if ($ != print_hex_digit)
.error Blabla
endifale to pasmo nezvladne protoze print_hex_digit pry jeste nezna i kdyz lezi pod tim a nekdy se sam prepne do vic pruchodu.
Tak jsem se to snazil obejit pres
omg equ print_hex_digit
if ($ != omg)
.error Blabla
endifale to selze stejne uz u omg. Mozna to jde jinym trikem, ale nevim jak.
PS: Tu bfloat, danagy a binary16 floating-point knihovnu jsem psal. Na FB existovala (mozna jeste existuje) skupina lidi z celeho sveta stale programujici pro ZX. A krome ruznych soutezi tam ukazoval Daniel Nagy i Ray tracing pro ZX. Chtel jsem jen vedet zda to nebude lepsi kdyz pouziji jiny format, ale stale 16 bitovy. On zvolil 8 bitu mantisu ja testoval jak 9 bitu tak 7 bitu. Drzel jsem se jeho navrhu "api" a drzel vstupy a vystupy ce stejnych registrech. Delal jsem to zamerene na rychlost, ale snazil se zaroven, aby pokud to jde po operaci byly vzdy vsechny bity mantisy i ten nejnizsi spravne zaokrouhlene. Co on nemel, takze jsem nakonec prepsal i jeho kod. Pak jsem to zpomalil uz jen tim, ze jsem vracel pri preteceni nebo podteceni priznaky.
Psal jsem to cely rok, nez se mi podarilo konecne vygenerovat ten obrazek. Byla tam spousta triku jak to delat pres male tabulky. Zjistil jsem ze napriklad nasobeni je snazsi nez scitani a odcitaniu FP. Deleni je problem, ale jde to pres 1/mantisa tabulku s tim, ze nekdy nejnizsi bit neni dobre. LN je silenost. Delat to nejakym vzorcem pomoci uz vytvorenych operaci jen ztracis bity a bude to pomale. Takze pouzit tabulku s mezivysledky a nejaka interpolace? Je tam i zavislost na exponentu. U nekterych vstupnich hodnot bylo nakonec vic bitu spatne na vystupu.
Z toho githubu se da spoustu veci odvodit, ale neni tam vsechno. Treba nektere tabulky jsem vytvarel pomoci spatlaneho programu v C co me to pocital iteracne (nahodne jsem drobne menil hodnoty tabulky a opravoval zbytek pro nejmensi chyby, mel vic variant a pak nejlepsi ponechal a opakoval) a snazil se mit pro vsechny vstupy minimalni chybu nebo zadnou na vystupu. Aby probehlo vsude spravne zaokrouhleni. Zkousel jsem ruzne verze tabulek. Pocital to kolikrat hodiny co byl v praci na modernim CPU. Proste neco co by pred 40 lety neslo udelat.
Ale uz jsou to 3 roky, moc si toho nepamatuji. Jen ze danagyho format to vyhral. binary16 melo vubec problem to vykreslit, tam uz temer nevyslo pro rozsah exponentu. A byl pomaly a i kdyz nejpresnejsi rozbrazeni stale mel chyby oproti bezchybne basic verzi. Bfloat nepresny a stejne rychly jak Danagy. Ale mensi tabulky, kdyz je mensi mantisa.
1 BORDER 0: PAPER 0: INK 9: BRIGHT 1: CLS: POKE 23672,0: POKE 23673,0: POKE 23674,0 10 LET spheres=2: IF spheres THEN DIM c(spheres,3): DIM r(spheres): DIM q(spheres) 20 FOR k=1 TO spheres: READ c(k,1),c(k,2),c(k,3),r: LET r(k)=r: LET q(k)=r*r: NEXT k 30 DATA -0.3,-0.8,3,0.6 40 DATA 0.9,-1.1,2,0.2 50 FOR i=0 TO 175: FOR j=0 TO 255 60 LET x=0.3: LET y=-0.5: LET z=0 70 LET dx=j-128: LET dy=88-i: LET dz=300: LET dd=dx*dx+dy*dy+dz*dz 80 GO SUB 100: NEXT j: NEXT i 90 PAUSE 1: LET s=PEEK 23672+256*PEEK 23673+65536*PEEK 23674: LET s=s/50: LET m=INT (INT s/60): LET h=INT (m/60): PRINT "Time: ";h;"h ";m-60*h;"min ";INT((s-60*m)*100)/100;"s ";PAUSE 0:STOP 100 LET n=-(y>=0 OR dy<=0): IF NOT n THEN LET s=-y/dy 110 FOR k=1 TO spheres 120 LET px=c(k,1)-x: LET py=c(k,2)-y: LET pz=c(k,3)-z 130 LET pp=px*px+py*py+pz*pz 140 LET sc=px*dx+py*dy+pz*dz 150 IF sc<=0 THEN GO TO 200 160 LET bb=sc*sc/dd 170 LET aa=q(k)-pp+bb 180 IF aa<=0 THEN GO TO 200 190 LET sc=(SQR bb-SQR aa)/SQR dd: IF sc<s OR n<0 THEN LET n=k: LET s=sc 200 NEXT k 210 IF n<0 THEN RETURN 220 LET dx=dx*s: LET dy=dy*s: LET dz=dz*s: LET dd=dd*s*s 230 LET x=x+dx: LET y=y+dy: LET z=z+dz 240 IF n=0 THEN GO TO 300 250 LET nx=x-c(n,1): LET ny=y-c(n,2): LET nz=z-c(n,3) 260 LET nn=nx*nx+ny*ny+nz*nz 270 LET l=2*(dx*nx+dy*ny+dz*nz)/nn 280 LET dx=dx-nx*l: LET dy=dy-ny*l: LET dz=dz-nz*l 290 GO TO 100 300 FOR k=1 TO spheres 310 LET u=c(k,1)-x: LET v=c(k,3)-z: IF u*u+v*v<=q(k) THEN RETURN 320 NEXT k 330 IF (x-INT x>.5)<>(z-INT z>.5) THEN PLOT j,i 340 RETURN
Ta trva vic jak 8 hodin a 46 minut.
