:::::::::::::::::::::::::::::::::::::::::::::::::::::::: :: Metodicka smernica k implementacii vykonavania :: :: zakladnych matematickych operacii akcelerovanych :: :: ABCD kalkulackou v ramci LMN Coprocessor Unit FPGA :: :::::::::::::::::::::::::::::::::::::::::::::::::::::::: Alebo skratka pokec o LCU :) (25.10.2019) ---------------------------------------------------------- Poznamka: v FPGA MB03+ a eLeMeNt ZX byla ponechana jen cast UNSIGNED ---------------------------------------------------------- Obsah dokumentu ~~~~~~~~~~~~~~~ Ideologicky uvod Matematicky model Programatorsky model Prakticke priklady Detailna datova mapa Ideologicky uvod ~~~~~~~~~~~~~~~~ Procesor Z80 nema ziadne instrukcie pre nasobenie a delenie cisel. Preto vsetky operacie v ktorych je potrebne nieco nasobit alebo delit byvaju bud velmi pomale alebo su pametovo narocne. Pomale vtedy, ak sa operacie robia programovo, klasicke bit-shift nasobenie, a pametovo narocne v pripade ak sa pre ich urychlenie pouziju nejake tabulky. Interface MB03+ obsahuje programovatelny obvod FPGA ktory sa da naprogramovat na rozne cinnosti. Jednou z nich moze byt aj spomenute nasobenie a delenie. Tieto operacie uz nie je potrebne robit programovo alebo tabulkami, staci ak Z80 zapise do FPGA vstupne operandy a precita si vysledky ktore vypocitalo FPGA. Rychlost vypoctu je vzhladom na vykonavanie programu procesorom Z80 velmi rychla, to znamena, ze Z80 si moze po zapise operandov prakticky okamzite precitat vysledky. Matematicky model ~~~~~~~~~~~~~~~~~ ABCD kalkulacka implementovana v FPGA vykonava nasledujuce operacie: Nasobenie a scitanie: M = A*B+C Celociselne delenie: Q = INT (M/D) .... cela cast podielu R = M modulo D ... zvysok po deleni Kombinovany vypocet: Q = INT ((A*B+C)/D) .... cela cast podielu R = (A*B+C) modulo D ... zvysok po deleni Operacie mozu byt vykonavane s cislami bez znamienka alebo so znamienkom. Operandy A,B,C,D mozu byt az 32 bitove, medzivysledok M moze byt az 64 bitovy. Tym padom su dane aj rozsahy maximalnych hodnot: Hodnota Bez znamienka So znamienkom =========== ============= ================ A,B,C,D,Q,R 0 .. 2^32-1 -2^31 .. +2^31-1 M 0 .. 2^64-1 -2^63 .. +2^63-1 V pripade ze vysledok delenia pretecie, v podieli a zvysku budu ulozene maximalne mozne zobrazitelne hodnoty (2^32-1 alebo -2^31 alebo +2^31-1). Programatorsky model ~~~~~~~~~~~~~~~~~~~~ ABCD kalkulacka pouziva pametovy pristup, t.j. vsetky argumenty sa zapisuju do pameti a z pameti sa potom citaju vysledky. Pre pracu s ABCD kalkulackou je potrebne: - aktivovany Ultimate memory model - primapovane LCU Aktivacia ultimate memory modelu: OUT #203B,0 OUT #213B,4 Primapovanie LCU: OUT #53,#C2 Toto sposobi ze v druhej 8kB banke v romke (adresy #2000-#3FFF) nebude pristupna bezna pamet pre ulozenie programu a dat, ale objavi sa tu pametovo mapovane "periferne" zariadenie - LCU. Program, ktory pracuje s ABCD kalkulackou, nesmie preto lezat v tejto oblasti pamete. ABCD kalkulacka je v ramci aktivneho LCU dostupna v prvych 64 bajtoch LCU pameti - na adresach #2000..#203F. Tato oblast je rozdelena na dve 32 bajtove oblasti: #2000..#201F = Oblast pre vypocty bez znamienka #2020..#203F = Oblast pre vypocty so znamienkom Obe oblasti su strukturovane nasledovne: +00..+03 = Argument A pre nasobenie +04..+07 = Argument B pre nasobenie +08..+0B = Argument C pre pripocitanie +0C..+0F = Argument D pre delenie (delitel) +10..+17 = Medzivysledok M nasobenia a delenec pre delenie +18..+1B = Podiel Q po deleni (Q ako quotient) +1C..+1F = Zvysok R po deleni (R ako remainder) Vsetky hodnoty su little-endian, t.j. nizsi bajt na nizsej adrese. Vstupne argumenty A,B,C,D zapisuje iba CPU. FPGA ich hodnoty nemeni, iba si ich precita. Medzivysledok M moze byt zapisany: - z FPGA po nasobeni A*B+C - z CPU ako argument pre delenie Vysledky delenia Q,R su zapisovane iba FPGAckom. Zapis CPU do Q,R nema ziadny vyznam (ignoruje sa). Triger pre vykonanie nasobenia a scitania je zapis ktorehokolvek argumentu A,B,C. Triger pre vykonanie delenia je akykolvek zapis do A,B,C,D alebo M. Ak je potrebne iba nasobit a scitavat, staci zapisat argumenty A,B,C a precitat vysledok z M. Ak je potrebne iba delit, staci zapisat argumenty M a D a precitat vysledky Q a R. Ak je potrebne vypocitat cely vyraz (A*B+C)/D, treba zapisat vsetky argumenty A,B,C,D. Na poradi zapisovania argumentov nezalezi. CPU moze citat nielen vsetky vysledky (M,Q,R) ale aj vsetky argumenty A,B,C,D. Moze tak v pripade potreby spetne zistit ake argumenty boli zapisane do kalkulacky. Prakticke priklady ~~~~~~~~~~~~~~~~~~ Kedze zopar praktickych prikladov je castokrat lepsich nez 128 stran teorie, v tejto casti najdete konkretne ukazky ako pracovat s kalkulackou. Zaroven tu najdete aj nejake uzitocne tipy ako sa rychlo dopracovat k vysledkom. Postupnost instrukcii ld a,nejaka_hodnota ld (adresa),a je kvoli prehladnosti zjednodusena na jedinu (makro)instrukciu ld (adresa),nejaka_hodnota Inicializacia Ultimate memory modelu ld bc,#203B xor a out (c),a inc b ld a,#04 out (c),a Primapovanie kalkulacky do pametoveho priestoru CPU: ld a,#C2 out (port53),a Zaciatocne vynulovanie vsetkych argumentov: ld hl,#2030 xor a nuluj dec l ld (hl),a jr nz,nuluj Toto vynulovanie je uzitocne hlavne vtedy, ak nepotrebujete pocitat s az 32 bitovymi cislami. Staci potom v ramci argumentov zadavat iba tolko bajtov kolko treba, lebo ostatne budu nulove. Priklad 1 ========= Nasobenie dvoch 8-bitovych cisel bez znamienka Vdaka predchadzajucemu vynulovaniu staci zadat iba najnizsie bajty argumentov A a B a priamo si precitat 16-bitovy vysledok z M. ld (#2000),cislo_1 ld (#2004),cislo_2 ld hl,(#2010) ;; Vysledok HL = cislo1 * cislo2 Priklad 2 ========= Nasobenie dvoch 16-bitovych cisel bez znamienka Logicky take iste ako nasobenie dvoch osembitovych cisel, ale sirka zapisovanych operandov a vysledku je 2x vecsia. ld hl,cislo_1 ld (#2000),hl ld hl,cislo_2 ld (#2004),hl ld hl,(#2010) ld de,(#2012) ;; Vysledok DEHL = cislo1 * cislo2 Priklad 3 ========= Nasobenie dvoch 8-bitovych cisel s znamienkom Kedze znamienkove rozsirovanie 8-bitovych cisel na 32-bitove by bola zbytocna rezia navyse, da sa to obist tak, ze pouzijeme najvyssie bajty argumentov. Vysledok potom musime precitat z dvoch najvyssich bajtov M. Vsetky nizsie bajty uz mame nulove vdaka zaciatocnemu vynulovaniu. Matematicky je to to iste ako keby sme kazde cislo shiftli o 24 bitov vlavo. Vysledok potom logicky musime shiftnut o 48 bitov vpravo, co prakticky znamena ze preskocime 6 bajtov vysledku odspodu a vezmeme rovno len dva najvyssie bajty. ld (#2023),cislo_1 ld (#2027),cislo_2 ld hl,(#2036) ;; Vysledok HL = cislo1 * cislo2 Priklad 4 ========= Nasobenie dvoch 16-bitovych cisel s znamienkom Logicky take iste ako nasobenie dvoch osembitovych cisel so znamienkom, ale cisla zapisujeme do dvojic najvyssich bajtov v argumentoch. Vysledok potom najdeme v styroch najvyssich bajtoch medzivysledku M. Tym ako keby oba argumenty shiftneme o 16 bitov dolava a vysledok o 32 bitov doprava. ld hl,cislo_1 ld (#2022),hl ld hl,cislo_2 ld (#2026),hl ld hl,(#2034) ld de,(#2036) ;; Vysledok DEHL = cislo1 * cislo2 Priklad 5 ========= Bezznamienkove delenie 16-bitoveho delenca 8-bitovym delitelom Ak mame kalkulacku vynulovanu, staci zapisat len to co realne potrebujeme. Potrebujeme urobit operaciu M/D, preto delenec zapiseme do M a delitel do D. Argumenty A,B,C zapisovat nesmieme, lebo by nam prepisali delenec M. ld hl,delenec ld (#2010),hl ld a,delitel ld (#200C),a ld a,(#2018) ;; Celociselna cast podielu ld a,(#201C) ;; Zvysok po deleni Ak je moznost ze nastane pretecenie, t.j. delenec moze byt vecsi ako 255-nasobok delitela, mozeme pretecenie otestovat nacitanim dalsieho bajtu podielu. Pri preteceni bude nenulovy. ld a,(#2019) ;; Test na pretecenie: 0 = ok, ine = delenie pretieklo Priklad 6 ========= Mame 16-bitove cislo Z a chceme ho zmenit v pomere danom dvomi 16-bitovymi cislami X/Y. T.j. vysledok bude V = Z * X/Y Pre tento vypocet vyuzijeme kompletne vyhodnotenie vyrazu (A*B+C)/D kde argument C nechame nulovy z uvodneho vynulovania. ld hl,cislo_Z ld (#2000),hl ld hl,cislo_X ld (#2004),hl ld hl,cislo_Y ld (#200C),hl ld hl,(#2018) ;; Vysledok HL = Z * X/Y Kedze kalkulacka si pameta zadane argumenty A,B,C,D, preto ak potrebujeme v zadanom pomere X/Y zmenit viac cisel, staci ich iba zapisovat do argumentu A a rovno citat vysledky. ld hl,cislo_Z2 ld (#2000),hl ld hl,(#2018) ;; Vysledok HL = Z2 * X/Y ld hl,cislo_Z3 ld (#2000),hl ld hl,(#2018) ;; Vysledok HL = Z3 * X/Y ld hl,cislo_Z4 ld (#2000),hl ld hl,(#2018) ;; Vysledok HL = Z4 * X/Y .. .......... .. .......... Priklad 7 ========= Mame 16-bitove logicke cislo sektora (LBA) na diskovom mediu a mame ho prepocitat na 8-bitove cislo stopy (cylindra) a 8-bitove cislo sektora na danej stope. Kedze na kazdej stope je rovnaky pocet sektorov a sektory sa cisluju v poradi v akom su na mediu od nultej stopy, cislo stopy bude celociselna cast podielu cisla sektora poctom sektorov na stope a sektor na stope bude potom zvysok. Cislo_stopy = logicke_cislo_sektora / pocet_sektorov_na_stopu Sektor_na_stope = zvysok po predchadzajucom deleni ld hl,logicke_cislo_sektora ld (#2010),hl ld (#200C),pocet_sektorov_na_stopu ld a,(#2018) ;; Cislo_stopy ld a,(#201C) ;; Sektor_na_stope Priklad 8 ========= Nasobenie 32-bitoveho cisla 64-bitovym cislom Kedze kalkulacka podporuje velkost argumentov pre nasobenie iba do 32 bitov, je potrebne toto nasobenie rozdelit na dve ciastkove nasobenia po 32 krat 32 bitov. Najprv trosku matematickej teorie: Nech U je 32 bitova hodnota a V je 64 bitova hodnota. 64-bitovu hodnotu V si rozdelime na vyssich (H) a nizsich (L) 32 bitov. V = H<<32 + L Pre nasobenie potom plati: Sucin = U * V = U * (H<<32 + L) = (U * H) << 32 + U * L Tym padom sme problem jedneho nasobenia 32x64 bitov previedli na problem dvoch nasobeni 32x32 bitov, ktore pomocou kalkulacky uz lahko zvladneme urobit. Ciastkove nasobenie U * L nam da 64 bitovy vysledok, z ktoreho: - spodnych 32 bitov priamo zapiseme od vysledneho sucinu - hornych 32 bitov (tzv. prenos do vyssieho radu) pripocitame k 64 bit sucinu U * H Vyuzijeme pritom vlastnost, kde k vysledku nasobenia A*B je este mozne pripocitat hodnotu C. cislo32bit ds 4 ;; 32 bitove cislo (zadane) cislo64bit ds 8 ;; 64 bitove cislo (zadane) sucin96bit ds 12 ;; 96 bitovy sucin (mame vypocitat) ld hl,cislo32bit ;; DEHL = nase 32 bitove cislo ld de,#2000 ;; zapiseme ako argument A ld bc,4 ldir ld hl,cislo64bit ;; 32 spodnych bitov zo 64 bitoveho cisla ld de,#2004 ;; zapiseme ako argument B ld bc,4 ldir ld hl,#00 ld (#2008),hl ;; Argument C bude zatial nulovy ld (#200A),hl ;; (nemusime robit, ak sme mali kalkulacku vynulovanu) ld hl,#2010 ;; Spodnych 32 bitov medzivysledku M ld de,sucin96bit ;; zapiseme do spodnych 32 bitov vysledneho sucinu ld bc,4 ldir ld hl,(#2014) ld de,(#2016) ;; Hornych 32 bitov medzivysledku M ld (#2008),hl ;; zapiseme ako argument C ld (#200A),de ;; (to bude prenos do vyssieho 32-bitoveho radu) Tu je velmi dolezite, aby sme cely medzivysledok M precitali este predtym, nez budeme zapisovat do argumentov. Prenos z medzivysledku do argumentu sa preto nerobi LDIRom, pretoze LDIR najprv zapise prvy bajt a az potom cita druhy bajt. Zapisom do argumentu sa nam vysledok M znovu prepocita a stratili by sme jeho predchadzajucu spravnu hodnotu. Dalsie bajty argumentu by boli potom nespravne. ld hl,cislo64bit+4 ;; 32 hornych bitov zo 64 bitoveho cisla ld de,#2004 ;; zapiseme ako argument B ld bc,4 ldir ld hl,#2010 ;; Vysledok nasobenia s pripocitanym prenosom ld de,sucin96bit+4 ;; skopirujeme do dalsich 8-mych bajtov vysledneho sucinu ld bc,8 ldir ;; A tym je 96-bitovy vysledok nasobenia 64 * 32 bitov hotovy. Detailna datova mapa ~~~~~~~~~~~~~~~~~~~~ (pre vytlacenie a zalaminovanie :) ) Vypocet bez znamienka ===================== Vstupne argumenty (nastavuje iba CPU) #2000 = Argument A pre nasobenie - najnizsi bajt #2001 = Argument A pre nasobenie - nizsi bajt #2002 = Argument A pre nasobenie - vyssi bajt #2003 = Argument A pre nasobenie - najvyssi bajt #2004 = Argument B pre nasobenie - najnizsi bajt #2005 = Argument B pre nasobenie - nizsi bajt #2006 = Argument B pre nasobenie - vyssi bajt #2007 = Argument B pre nasobenie - najvyssi bajt #2008 = Argument C pre pripocitanie - najnizsi bajt #2009 = Argument C pre pripocitanie - nizsi bajt #200A = Argument C pre pripocitanie - vyssi bajt #200B = Argument C pre pripocitanie - najvyssi bajt #200C = Argument D pre delenie (delitel) - najnizsi bajt #200D = Argument D pre delenie (delitel) - nizsi bajt #200E = Argument D pre delenie (delitel) - vyssi bajt #200F = Argument D pre delenie (delitel) - najvyssi bajt Medzivysledok (nastavuje CPU aj FPGA) - vysledok nasobenia a scitania M = A*B+C - argument pre delenie (delenec) #2010 = Medzivysledok M - najnizsi bajt nizsieho DWORDu #2011 = Medzivysledok M - nizsi bajt nizsieho DWORDu #2012 = Medzivysledok M - vyssi bajt nizsieho DWORDu #2013 = Medzivysledok M - najvyssi bajt nizsieho DWORDu #2014 = Medzivysledok M - najnizsi bajt vyssieho DWORDu #2015 = Medzivysledok M - nizsi bajt vyssieho DWORDu #2016 = Medzivysledok M - vyssi bajt vyssieho DWORDu #2017 = Medzivysledok M - najvyssi bajt vyssieho DWORDu Vysledky delenia (nastavuje iba FPGA) - Podiel po deleni M/D alebo INT(M/D) - Zvysok po deleni M/D alebo M modulo D #2018 = Podiel po deleni Q - najnizsi bajt #2019 = Podiel po deleni Q - nizsi bajt #201A = Podiel po deleni Q - vyssi bajt #201B = Podiel po deleni Q - najvyssi bajt #201C = Zvysok po deleni R - najnizsi bajt #201D = Zvysok po deleni R - nizsi bajt #201E = Zvysok po deleni R - vyssi bajt #201F = Zvysok po deleni R - najvyssi bajt Vypocet so znamienkom ===================== Vstupne argumenty (nastavuje iba CPU) #2020 = Argument A pre nasobenie - najnizsi bajt #2021 = Argument A pre nasobenie - nizsi bajt #2022 = Argument A pre nasobenie - vyssi bajt #2023 = Argument A pre nasobenie - najvyssi bajt #2024 = Argument B pre nasobenie - najnizsi bajt #2025 = Argument B pre nasobenie - nizsi bajt #2026 = Argument B pre nasobenie - vyssi bajt #2027 = Argument B pre nasobenie - najvyssi bajt #2028 = Argument C pre pripocitanie - najnizsi bajt #2029 = Argument C pre pripocitanie - nizsi bajt #202A = Argument C pre pripocitanie - vyssi bajt #202B = Argument C pre pripocitanie - najvyssi bajt #202C = Argument D pre delenie (delitel) - najnizsi bajt #202D = Argument D pre delenie (delitel) - nizsi bajt #202E = Argument D pre delenie (delitel) - vyssi bajt #202F = Argument D pre delenie (delitel) - najvyssi bajt Medzivysledok (nastavuje CPU aj FPGA) - vysledok nasobenia a scitania M = A*B+C - argument pre delenie (delenec) #2030 = Medzivysledok M - najnizsi bajt nizsieho DWORDu #2031 = Medzivysledok M - nizsi bajt nizsieho DWORDu #2032 = Medzivysledok M - vyssi bajt nizsieho DWORDu #2033 = Medzivysledok M - najvyssi bajt nizsieho DWORDu #2034 = Medzivysledok M - najnizsi bajt vyssieho DWORDu #2035 = Medzivysledok M - nizsi bajt vyssieho DWORDu #2036 = Medzivysledok M - vyssi bajt vyssieho DWORDu #2037 = Medzivysledok M - najvyssi bajt vyssieho DWORDu Vysledky delenia (nastavuje iba FPGA) - Podiel po deleni M/D alebo INT(M/D) - Zvysok po deleni M/D alebo M modulo D #2038 = Podiel po deleni Q - najnizsi bajt #2039 = Podiel po deleni Q - nizsi bajt #203A = Podiel po deleni Q - vyssi bajt #203B = Podiel po deleni Q - najvyssi bajt #203C = Zvysok po deleni R - najnizsi bajt #203D = Zvysok po deleni R - nizsi bajt #203E = Zvysok po deleni R - vyssi bajt #203F = Zvysok po deleni R - najvyssi bajt