Transcript 4.4
4.4 Mikro-ohjelmoitava tietokone Piireistä komponenteiksi: Aritmetiikkayksikkö: – puolisummain->kokosummain – kompementoija Muisti: – kiikku->rekisteri Väylät – – signaalivahvistimet, loogiset portit, johdot Loogisten vertailujen yksikkö: – loogiset piirit Kello: – looginen piiri, joka tuottaa ohjaussignaalit syklissä Syöttö ja tulostus: - elektronisia komponentteja (ei käsitellä sen tarkemmin) Yhdistämällä nämä komponentit yhteen ja luomalla komponenttien ohjaussäännöt saadaan yleiskäyttöinen tietokone rakennetuksi. © Lammi-Niskala-Kossarev 1 Ohjelmoitavuus Komponenttien ohjaussäännöt kertovat, miten komponentit hallitaan ohjaussäännöille on määriteltävissä ohjausjärjestys(kontrolli): kyse on itseasiassa ohjelmoinnista! tietokone on siis käyttäjän ohjelmoitavissa oleva laite, toisin kuin erikoiskäyttöiset järjestelmät kuten – automaattipesukone – liikennevalojen ohjausjärjestelmä – lämmönsäätäjä omakotitalossa osa laitteessa kulkevasta tiedosta ohjaa laitteen itsensä toimintaa – tietokoneen looginen piirii muuttuu kaiken aikaa, kun komponentteja ohjataan aktiiviseen/passiviseen tilaan © Lammi-Niskala-Kossarev 2 Mikro-ohjelmointi konekielessä suoritetaan alkeisoperaatioita kuten: – päämuistin muistipaikan ja suorittimen rekisterin yhteen-, vähennys-, jako- ja kertolasku – kontrollin siirto toiseen muistipaikkaan – tiedon tallentaminen rekisteristä päämuistin muistipaikkaan esim. rekisterin arvo+muistipaikan arvo: – arvo ensin haettava keskusmuistista (ei pystytä käsittelemään suoraan) – arvot vietävä aritmeettiseen yksikköön ja yhteenlaskun tulos vietävä johonkin rekisteriin – jos arvo halutaan takaisiin keskusmuistiin, se on vietävä sinne erillisellä komennolla yhteenlasku ei siis ole atominen (osiksi jakamaton) operaatio jos halutaan tietokoneen ymmärtävän konekieltä suoraan, konekielen monivaiheiset käskyt on tarkennettava yksivaiheisten (atomisten) toimintojen tasolle laitteistolliseti loogisten piirien paljos kallista mutta voitetaan suoritusnopeudessa © Lammi-Niskala-Kossarev 3 Mikro-ohjelmointi entäs jos otetaan atomiset, alemman tason käskyt erilleen omalle abstraktiotasolleen? – esim. arvon vieminen rekisteristä ALU:n väylälle saadaan uusi ohjelmointikieli, ns. mikro-kieli aikaan, joka koostuu mikrokäskyistä taloudellisempaa, koska loogisten piirien määrä pienenee mikrokäskyistä voidaan laatia konekielen tulkki, joka osaa tulita (lukea, ymmärtää, suorittaa) konekielisiä käskyjä mikrokäskyillä toimiva tietokone on ns. mikro-ohjelmoitava tietokone mikro-ohjelma = laitelmisto = firmware tulkki sijaitsee mikro-ohjelmamuistissa, joka on lukumuistia (poltetaan tietokoneen rakentamisen yhdeydessä), ROM, Read-Only-Memory © Lammi-Niskala-Kossarev 4 Tietokoneen luokat Suurtietokoneet – mainframes Minitietokoneet – esim. www-palvelimet, hytti, cs, messi Mikrotietokoneet – PC:t, Macit – Pentium I,II,III ovat hybridisuorittimia, joissa osa käskyistä suoritetaan mikrokoodin avulla ja osa suoraan konekielestä © Lammi-Niskala-Kossarev 5 Mikro-ohjelmoitavan tietkoneen rakenne ja ohjaus rakennekaavio liite 1 ohjausbitit sivu 127 SimO:n käyttöönotto © Lammi-Niskala-Kossarev 6 4.4.2 Yhteenveto mikroohjelmoitavan tietokoneen rakenteesta 4 kokonaisuutta: 1. 2. 3. 4. MIR+MPM+MPC, kello – mikrokäskyjen suoritus MDR, MM, MAR – päämuistin käsittely ALU - laskutoimitukset rekisterit A, B, C, D (A erikoisasemassa) – mikroohjelman suorassa käytössä olevat ”muuttujat” toiminnot eri kellonaikoina: 1 ja 2: ALU:n käyttö – datan aritmeettista käsittelyä 3 keskusmuistin, RAM:n käsittely 4 ja 5: ohjauksen (ohjelmakontrollin) toteutus: MPC:=uusi arvo, (MPC) MIR © Lammi-Niskala-Kossarev 7 4.4.3 Mikro-ohjelmointi Päämuistin tallennetaan konekielen ohjelmaa, jota tulkataan mikroohjelmamuistissa sijaitsevan tulkin avulla tavan käyttäjällä ei siis mahdollisuutta ohjelmoida mikrokäskyillä seuraavassa ensin tutustutaan mikrokäskyihin, joista rakennetaan mikro-ohjelma: tulkki konekielelle © Lammi-Niskala-Kossarev 8 JTT-mikro-ohjlemoitavan tietokoneen kyvyt: – tiedon siirto rekisterien ja rekisterin ja RAM:in välillä suora siirto kahden keskusmuistin muistipaikan välillä ei mahdollinen – yhteen- ja vähennyslasku A-MDR mahdollinen, mutta ei MDR-A vähennyslaskussa vähentäjän oltava MDR:ssä – kahdella kertominen, shiftleft, yhden bitin vasemmalle siirto seurauksena oikeanpuolimmaisin bitti hukku – loogiset vertailut A<0 ja A=0. vain A:lle – ohjausrakenteiden toteutus siirrytään seuraavaan käskyyn - peräkkäisyys ehdollinen ylihyppy (skip) – valinta – loogiset vertailut mahdollistavat tämän ehdoton hyppy (jump) - toisto Näillä toteutettava kaikki konekielen operaatiot. © Lammi-Niskala-Kossarev 9 mikro-ohjelmointi tavallista ohjelmointia: – on annettu kiinteä operaatoiden joukko, joita luovasti yhdistelemällä saadaan haluttu toiminnallisuus aikaan Jokainen mikrokäsky sisältää 5 alikäskyä – – – – suoritetaan peräkkäin kellosyklissä vain yksi rekisteri väylälle kerrallaan laskun tulos mahdollista sijoittaa useampaan rekisteriin kaikki mikrokäskyt ovat itseasiassa asetuslauseita asetettu ongelma ratkeaa jopa haarautuminen toteutetaan asetuslauseessa ohjelmointi on koneenläheistä: raakaa arvojen siirtelyä Implisiittiset (sisäänrakennetut vakiotoiminnot) – kello 1 jälkeen väylä 1 ja väylä 2 lasketaan yhteen ja tulos laitetaan väylään 3: V1 + V2 V3 – kello 4 jälkeen myös V1 + V2 V3 lasketaan seuraavaksi suoritettavan mikrokäskyn osoite MPM:ssä – kello 5 tehdään aina sama: V3 MPC, (MPC) MIR © Lammi-Niskala-Kossarev 10 Esim: 1-bittien määrä muistipaikan luvussa Syöte: D=RAM:n osoite Tuloste: C=1-bittien määrä Ratkaisuperiaate: – vain vasemmanpuolimaista bittiä voidaan tutkia se on etumerkkibitti, ja jos on 1, niin luku on negatiivinen (voidaan testata A<0) – lasketaan ykköset siirtämällä sanaa toistuvasti vasemmalle ja kasvattamalla laskuria aina kun se bitti on ykkönen © Lammi-Niskala-Kossarev 11 1-bittien määrä C:=0 (* nollataan laskuri *) A := hae(D) (*haetaan arvo RAM:ista*) WHILE A≠0 DO IF A<0 THEN C:=C+1 ENDIF shiftleft(A) (*siirretään A 1 bittti vasemmalle *) ENDWHILE © Lammi-Niskala-Kossarev 12 tarkennetaan edelleen: käskyjen abstraktiotaso vielä liian korkea: – aliohjelmia eikä toistorakenteita pystytä käyttämään suoraan – käskyjen tarkennukset joudutaan tekemään samaan paikkaan hae(), WHILE-ENDWHILE korvataan vastaavilla mikrokäskyrakenteilla © Lammi-Niskala-Kossarev 13 C:=0 A := hae(D) WHILE A≠0 DO IF A<0 THEN C:=C+1 ENDIF shiftleft(A) ENDWHILE C:=0 MAR := D MDR := (MAR) A:=MDR if: IF A = 0 THEN jump ohi ENDIF IF A<0 THEN C:=C+1 ENDIF shiftleft(A) jump if ohi: IF-valintarakennetta ei olemassa mikrokäskyissä => IF:n tarkennus: skip ohittaa seuraavan käskyn ja jatkaa sitä seuraavasta, jos ehto ei toteudu vrt. ohjausbitteihin c19 ja c20 C:=0 MAR := D MDR := (MAR) A:=MDR if: skip A = 0 jump ohi skip A < 0 ohi: C := C+1 shiftleft(A) jump if © Lammi-Niskala-Kossarev 14 viimeinen versio on suoraan käännettävissä ohjausbiteiksi – käskyt ovat nyt triviaaleja mikro-käskyjen kannalta – MPM:ssä jokaisella mikro-käskyllä on järjestysnumero (osoite), joten nimiöt korvataan osoitteilla muutetaan kuitenkin ensin symboliselle mikrokielelle: kello 1: arvo V1, arvo v2, V1+V2 V3 kello 2: yhteenlaskun tulos V3 maalirekisteri kello 3: (MAR) MDR tai MDR (MAR) (MAR): luku kirjataan muistipaikkaan, jonka osoite on MAR:in arvo kello 4: arvo V1, arvo v2, V1+V2 V3 kello 5: V3 MPC, (MPC) MIR © Lammi-Niskala-Kossarev 15 kello 1: 0V1, 0 V2, V1+V2V3; kello 2: V3C; kello 3: ; kello 4:1V1, MPC V2, V1+V2V3; kello 5: V3 MPC, (MPC) MIR; voidaan kirjoittaa lyhyemmin, jos jätetään implisiittiset operaatiot kirjoittamatta: 1: 0+0 C;; 1+MPC MPC 2: kello 1: 0V1, D V2, V1+V2V3; 4: kello 4: (A=0)V1, MPCV2, kello 2: V3MAR; V1+V2V3; kello 3: (MAR)MDR; kello 5: V3MPC, (MPC)MIR kello 4:1V1, MPC V2, V1+V2V3; (A=0) antaa 1, jos A=0 kello 5: V3 MPC, (MPC) MIR; (A=0) antaa 2, jos A<>0 ja lyhyemmin: 0+D MAR; (MAR) MDR; 1+MPC MPC 3: MDR+0 A;; 1+MPC MPC 8: kello 1: 0V1, AV2,(V1+V2)*2V3; 4: ;; (A=0) + MPC MPC kello 2: V3A; 5: ;;10102 MPC kello 3: ; 6: ;; (A<0) + MPC MPC kello 4: 1V1, MPCV2, V1+V2V3; 7: 1+C C;; 1+MPC MPC kello 5: V3MPC, (MPC)MIR; 8: (0+A)x2 A;; 1+MPC MPC 9: ;; 1002 MPC © Lammi-Niskala-Kossarev 16 10: Käännetään symbolinen esitys bitti-esitykseksi: – aluksi MIR-käsky on 22 nollaa: 0000000000000000000000 – asetetaan ne bitit päälle, jotka vastaavat tarvituista toiminnoista, esim 1. rivi: 1: kello 1: 0V1, 0 V2, V1+V2V3; ei ohjausbitteja päälle, koska 0:t menevät väylille oletuksena kello 2: V3C; c11 päälle kello 3: ; kello 4:1V1, MPC V2, V1+V2V3; c17, c22 päälle kello 5: V3 MPC, (MPC) MIR; implisiittinen – ei tarvitse ohjelmoida erikseen – 1.rivi näyttää nyt täältä: 0000000000100000100001 © Lammi-Niskala-Kossarev 17 1-bittien määrä.. ohjausbittien asettelu jokaisella käskyrivillä suoritus SimO:lla A:n muutos, kun A:han sovelletaan shiftlefttoimintoa toistuvasti: 0000 0000 0000 0000 ... 1110 1100 1000 0000 0000 0000 0000 0000 0000 0000 0001 0011 0111 1110 1100 1000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 © Lammi-Niskala-Kossarev 18 Kertolasku välttämätön operaatio konekielen tulkin kannalta – konekielessä määritelty yhtenä (triviaalina) käskynä MULTIPLY D koska ALU ei osaa tehdä sitä suoraan, pitää toteuttaa ohjelmallisesti käytetään kertolaskun määritelmää: – A*C = C + C + … + C (C summataan A kertaa) – kertoja A:ssa, kerrottava C:ssä tulos rekisteriin MDR © Lammi-Niskala-Kossarev 19 MDR:=0 WHILE A ≠ O DO MDR := MDR + C A := A -1 ENDWHILE 1: 5: MDR := 0 skipA = 0 jump 5 MDR := MDR + C A := A - 1; jump 1 Viimeinen hyppy (jump 1) voidaan toteuttaa kello 4 asettamalla 1 väylään 1. Näin säästetään yksi mikrokäsky. 0: 1: 2: 3: 4: 0+0 MDR ; ; 1+MPC MPC ;; (A=0)+MPC MPC ;;5+0 MPC MDR+CMDR;;1+MPCMPC -1+A A;; 1+0 MPC MDR:lle alkuarvo; siirry seuraavaan käskyyn. Haaraudu sen mukaan, onko A = 0 vai ei. A = 0: Poistu silmukasta (c1..c8: 00000101) A ≠ 0: Lisää C MDR:ään. Pienennä A:ta, ja hyppää silmukan alkuun • suoritus SimO:lla. Algoritmi toimii myös kun C (ei A!) negatiivinen. • T(n): käskyjä: (1,3,4) * max(A) = 3 * (216-1) = 3 * 65535 = 196605 ≈ 200 000 kellopulsseja: 200000 * 5 = 106. 7 pulssia sekunnissa, T(n)=106 * 10-7=0,1 s Jos kellotaajuus 10MHZ=10 * 106 = 10 © Lammi-Niskala-Kossarev 20 Kertolasku parempi esitetyn algoritmin aikavaativuus on siis 3*n – asymptoottisesti lineaarinen voidaanko algoritmin parantaa? käytetään koulualgoritmia, esim huomataan, että kerrottava lisätään osasummaan 0 tai 1 kertaa © Lammi-Niskala-Kossarev 21 vain oikeanpuolimmainen bitti on tarkasteltavissa erikseen (c19 ja c20) – kertojabitit käytävä läpi vasemmalta oikealle – osasummat muodostuu silloin myös päinvastaisessa järjestyksessä – käsitelty kertojabitti siirretään pois tieltä shiftleft-operaatiolla, jolloin uusi bitti tulee käsiteltäväksi korkeintaan 2 arvoa pystytään laskemaan yhteen samalla kerralla – osasumma lisättävä loppusummaan heti, kun se on laskettu on käytössä vain shiftleft operaatio, eli siirto vasemmalle – uusi osasumma pitäisi siirtää oikealle ennen lisäämistä summaan (ks. ed. kalvon osasummat alhaalta ylöspäin) – saavutetaan sama tulos, kun siirretään vanha summa ensin vasemmalle ennen uuden osasumman lisäämistä © Lammi-Niskala-Kossarev 22 sananpituus 16 => 16 osasummaa erillislaskuri pitäisi kirjaa siitä, kuinka monta bittiä on jo käsitelty voidaan tehdä toisin: – lisätään luvun oikeaan päähän terminaattoribitti (valeykkönen), jonka tultua vasemmanpuolimmaiseksi tiedetään, että kaikki bitit on käsitelty Terminaattoribitin lisäys – algoritmi: – luku on A:ssa – käsitellään A:n alin bitti erikseen – shiftleft (A) nyt A:n alin bitti on 0 – lisätään 1 alimmaksi bitiksi – kun A=1000..00000, tiedetään, että se on lisäämämme terminaattoribitti eli A:n alkuperäiset bitit on silloin käsitelty loppuun suoritus voi päättyä © Lammi-Niskala-Kossarev 23 aikavaativuus: silmukan pituus on joko 4 (käskyt 4-6-7-8) tai 6 (käskyt 4-5-9-11-12-13) askelta. Jokaisella kierroksella käsitellään 1 bitti 15:sta. Näin suoritetaan entintään 4 + 15*6 + 4 = 98 käskyä kellotaajuus = 10 MHz T(n) = 98 * 5 * 10-7 ≈ 0,00005 s aikavaativus on lähes vakioaikainen (ei riipu kertojan suuruudesta!!) ja 2000 kertaa edellistä algoritmia nopeampi. © Lammi-Niskala-Kossarev 24 Konekieli konekielen abstraktiotaso on korkeampi kuin mikrokäskyjen – konekielen käsky koostuu useasta mikrokäskystä – lähempänä ihmisen ajattelutapaa ei tarvitse välittää mikro-ohjelmoitavan tietokoneen yksityiskohdista konekieltä on helpompaa käyttää © Lammi-Niskala-Kossarev 25 Konekielikone B MDR A 3 erikoisrekisteriä: – PC (Program Counter) – ohjelmalaskuri – IR (Instruction Register) – käskyrekisteri – ACC (Accumulator) – yleiskäyttöinen rekisteri, akku päämuisti RAM: – sisältää niin konekielen käskyt kuin tiedon © Lammi-Niskala-Kossarev 26 Konekielikäskyt Symbolinen käsky_________Toiminto____________________________ LOAD M ACC <- (M) STORE M (M) <- ACC ADD M ACC <- ACC + (M) SUBTRACT M ACC <- ACC - (M) MULTIPLY M ACC <-ACC* (M) DIVIDE M ACC <- ACC / (M) (kokonaislukujakolasku) JUMP M Hyppää M:ään JUMPZERO M Hyppää M:ään, jos ACC = 0 JUMPNEG M Hyppää M:ään, jos ACC < 0 JUMPSUB M Hyppää M:stä alkavaan aliohjelmaan RETURN M Palaa M:stä alkaneesta aliohjelmasta yksiosoitekieli: – toinen operandeista on aina jokin muistipaikka M – toinen operandeista on aina sama ja implisiittinen, ACC on olemassa kaksi- ja kolmiosoitekieliä – toisena operandina ei välttämättä akku – 3-osoitekielissä tulos voidaan viedä määrättyyn muistipaikkaan © Lammi-Niskala-Kossarev 27 talletetaan päämuistiin käskyt suoritetaan yksi kerrallaan peräkkäin, ellei suoritusjärjestystä muuteta erikseen kun kaikki tieto tietokoneessa on numeerista, miten käskyt on koodattu biteksi? tietokoneen sananpituus on 16 bittiä, eli muistipaikka pitää sisällään 16 bittiä kurssin konekieli on yksiosoitekieli – konekielikäsky sijaitsee yhdessä osoitteessa kokonaan kun RAM:n osoitteet ovat 12bittisiä, jää 4 bittiä käskyn koodille osoitteita on siis 212=4096 kpl – 0..4095 käsky bittimuodossa 0001 m1..m12 0010 m1..m12 0011 m1..m12 0100 m1..m12 0101 m1..m12 0110 m1..m12 0111 m1..m12 1000 m1..m12 1001 m1..m12 1010 m1..m12 1011 m1..m12 © Lammi-Niskala-Kossarev Symbolinen käsky LOAD M STORE M ADD M SUBTRACT M MULTIPLY M DIVIDE M JUMP M JUMPZERO M JUMPNEG M JUMPSUB M RETURN M 28 Suoritusjärjestyksen ohjaus ehdoton hyppy: JUMP M – hyppää osoiteeseen M ehdollisia hyppyjä: JUMPZERO M – hyppää osoitteeseen M, jos ACC=0 – muuten jatka seuraavasta JUMPNEG M – hyppää osoitteeseen M, jos ACC<0 – muuten jatka seuraavasta hyppy aliohjelmaan: JUMPSUB M – hyppää osoitteeseen M, josta alkaa aliohjelma RETURN M – palaa aliohjelmasta, joka alkoi osoitteesta M © Lammi-Niskala-Kossarev 29 M0DULE exp(n) RETURNS 2n arvo := 1 WHILE n > 0 DO n :=n-1 arvo := arvo + arvo ENDWHILE RETURN arvo ENDMODULE 371 372 373 374 375 376 377 378 379 380 381 382 383 LOAD 383 STORE 382 LOAD 381 JUMPZERO 384 SUBTRACT 383 STORE 381 LOAD 382 ADD 382 STORE 382 JUMP 373 n 0 1 Esim: 2n konekielellä -tuttu tuttualgoritmi algoritmi2:n 2:npotenssin potenssinlaskemiseksi laskemiseksi -toteutetaan toteutetaankonekielellä konekielellä -ohjelma ohjelmaosoitteissa osoitteissa371-380 371-380 -dataa dataaosoitteissa osoitteissa381-383 381-383 Hae ykkönen akkuun. Talleta ykkönen funktion alkuarvoksi Hae n akkuun. Jos n = 0, hyppää muistipaikkaan 384 Vähennä n:stä yksi. Talleta n:n uusi arvo. ACC arvo ACC arvo + arvo arvo ACC Hyppää silmukan alkuun funktion arvo © Lammi-Niskala-Kossarev laskennassa tarvittava lukuvakio 30 Esim: 2x + 2y MODULE summa(x, y) RETURNS 2x + 2y RETURN exp(x) + exp(y) ENDMODULE 287 LOAD 314 288 STORE 311 289 JUMPSUB 299 290 LOAD 312 291 STORE 316 292 LOAD 315 293 STORE 311 294 JUMPSUB 299 295 LOAD 312 296 ADD 316 297 STORE 316 298 JUMP 317 Hae x akkuun. Talleta x aliohjelman syötteeksi. Suorita aliohjelma, ts. laske 2X. Hae aliohjelman tulos 2X akkuun. Talleta lopputuloksen arvoksi. Hae y akkuun. Talleta y aliohjelman syötteeksi. Suorita aliohjelma, ts. laske 2y. Hae aliohjelman tulos 2y akkuun. Lisää 2x akun (= 2y) arvoon. Talleta lopputulos. Lopeta ohjelman suoritus Aliohjelma: 299 0/290/295 alku, paluuosoite 300 LOAD 313 aliohjleman koodi 301 STORE 312 302 LOAD 311 303 JUMPZER 310 304 SUBTRACT 313 305 STORE 311 306 LOAD 312 307 ADD 312 308 STORE 312 309 JUMP 302 310 RETURN 299 paluu pääohjelm. 311 0 aliohjelman syöte 312 0 aliohjelman tuloste 313 1 314 x ohjelman syöte x 315 y ohjelman syöte y 316 0 lopputulos © Lammi-Niskala-Kossarev 31 Mikro-ohjelmoitu tulkki konekielelle tulkin toimintaperiaate: 1. 2. 3. 4. – – seuraavaksi suoritettavan käskyn osoite on muistettava. Rekisteri B toimii ohjelmalaskurina PC – C tai D myös kelpaisi ohjelmalaskuriksi A toimii akkuna ACC – hae konekäsky päämuistista selvittää käskyn sisältö suorita käsky siirry seuraavaan käskyyn tehtävä loogiset vertailut, jotka mahdollisia vain A:lle MDR toimii käskyrekisterinä IR siinä on suoritettavana olevan käskyn sisältö MDR:ään saa päämuistin muistipaikan sisältö suoraan © Lammi-Niskala-Kossarev 32 MODULE tulkki REPEAT MDR:=(B) (*opr=MDR15-12 , opd=MDR11-0 *) B:=B + 1 Suorita opr(opd,A,B) (*hyppykäskyissä myös B voi muuttua *) UNTIL 0=1 ENDMODULE © Lammi-Niskala-Kossarev 33 haetaan päämuistista seuraavaksi suoritettava käsky, jonka osoite on B:ssä B:tä kasvatetaan valmiiksi yhdellä – jos käsky on hyppykäsky, B saa uuden arvon, kun hyppykäskyä suoritetaan päämuistista luettu konekielikäsky talletetaan MDR:ään 4 eniten merkitsevän bitin (15-12) erotus MDR:stä onnistuu ohjausbitillä c21 © Lammi-Niskala-Kossarev 34 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 B+0 => MAR; (MAR) => MDR; MPC+1 => MPC; B+1 => B; MPC+MDR[1..4] => MPC 13 => MPC 15 => MPC 17 => MPC 19 => MPC 21 => MPC 38 => MPC 61 => MPC 62 => MPC 65 => MPC 68 => MPC 71 => MPC 0+MDR => MAR; (MAR) => MDR; MPC+1 => MPC 0+MDR => A; 0+0 => MPC 0+MDR => MAR; MPC+1 => MPC A+0 => MDR; MDR => (MAR); 0+0 => MPC 0+MDR => MAR; (MAR) => MDR; MPC+1 => MPC A+MDR => A; 0+0 => MPC 0+MDR => MAR; (MAR) => MDR; MPC+1 => MPC A-MDR => A; 0+0 => MPC 0+MDR => MAR; (MAR) => MDR; MPC+1 => MPC 0+MDR => C; MPC+1 => MPC 0+0 => MDR; (A<0)+MPC => MPC C+MDR => MDR: MPC+1 => MPC (A+0)*2 => A; MPC+1 => MPC A+1 => A; MPC+1 => MPC MPC+(A<0) => MPC 32 => MPC (0+MDR)*2 => MDR; MPC+1 => MPC (A+0)*2 => A; MPC+1 => MPC 27 => MPC (A+0)*2 => A; MPC+(A=0) => MPC 37 => MPC (0+MDR)*2 => MDR; MPC+1 => MPC C+MDR => MDR; MPC+1 => MPC 27 => MPC 0+MDR => A; 0+0 => MPC 38 0+MDR => MAR; (MAR) => MDR; MPC+1 => MPC 39 0+0 => C; MPC+1 => MPC 40 A-MDR => A; MPC+(A<0) => MPC 41 C+0 => A; 0+0 => MPC 42 0+0 => D; MPC+1 => MPC 43 (0+MDR)*2 => MDR; MPC+1 => MPC 44 A-MDR => A; MPC+(A<0) => MPC 45 48 => MPC 46 (D+1)*2 => D; MPC+1 => MPC 47 43 => MPC 48 A+MDR => A; MPC+1 => MPC 49 D+1=>MDR; MPC+1 => MPC 50 C+MDR => C; (MAR) => MDR; MPC+1 => MPC 51 40 => MPC 52 (C+0)*2 => C; MPC+1 => MPC 53 B-MDR => A; MPC+(A<0) => MPC 54 59 => MPC 55 C+1 => C; MPC+1 => MPC 56 (A+0)*2 => B; MPC+1 => MPC 57 49 => MPC 58 (A+MDR)*2 => B; MPC+1 => MPC 59 49 => MPC 60 C+0 => A; 0+0 => MPC 61 0+MDR => B; 0+0 => MPC 62 MPC+(A=0) => MPC 63 0+MDR => B; 0+0 => MPC 64 0+0 => MPC 65 MPC+(A<0) => MPC 66 0+MDR => B; 0+0 => MPC 67 0+0 => MPC 68 0+MDR => C => MAR; MPC+1 => MPC 69 B+0 => MDR; MDR => (MAR); MPC+1 => MPC 70 C+1 => B; 0+0 => MPC 71 0+MDR => MAR; (MAR) => MDR; MPC+1 => MPC35 © Lammi-Niskala-Kossarev 72 0+MDR => B; 0+0 => MPC 4.5.2. Monimutkaisemmat konelkielet pino-operaatiot – helpottavat aritmeettisten lausekkeiden ja aliohjelmien toteuttamista esim (a + b) * (c + d) – osatulos (a + b) voidaan laittaa pinoon (c + d):n laskun ajaksi aliohjelmaa kutsuttaessa kustuvan ohjelman parametrit laitetaan pinoon talteen rekisterien lukumäärä ja koko suurempi – monta yleiskäyttöistä rekisteriä – rekisterin koko 32 tai 64 syöttö- ja tulostusoperaatiot – ilman niitä tietokoneen käyttö hankalaa osoitustavat… © Lammi-Niskala-Kossarev 36 Osoitustavoista osoitustapa = – millä tavalla konekielen käskyn osoiteosa määrää käskyn todellisen operandin monisteen konekielessä suora osoitustapa käytössä – osoitetaan kohdemuistipaikka suoraan mutta muistipaikan sisältö voisi viitata haettavan arvon asemesta johonkin toiseen muistipaikkaan, mistä haluttu arvo löytyy – esim muistipaikan 13 sisältö on 15, muistpaikan 15 sisältö on 7 silloin merkintä (13) tarkoittaisi viittausta muistipaikan 13 arvoon 15 mutta merkintä ((13)) tarkoittaisi, että arvo haetaan siitä muistipaikasta, jonka osoite on muistpaikassa 13: – ((13))=(15)=7 © Lammi-Niskala-Kossarev 37 tälläisiä kehittyneempiä osoitustapoja käytetään LOAD- ja STOREkäskyjen sekä aritmeettisten operaattoreiden yhteydessä – lisää konekielen ilmaisuvoimaa yleensä operaattorinimen loppuliite kertoo osoitustavan välitön (Immediate) operandi on haettu tieto LOADI oso oso -> ACC suora (direct) operandi on muistipaikan osoite, josta tieto löytyy LOAD oso (oso) -> ACC epäsuora (InDirect) operandi on osoite, jossa on osoite, josta tieto löytyy LOADID oso ((oso)) -> ACC indeksoitu (IndeXed) kun operandi lisätään indeksirekisteriin arvoon, saadaan osoite, josta tieto löytyy LOADIX oso (oso+X)->ACC epäsuora indeksoitu (InDirect indeXed) operandi ilmoittaa osoitteen, jonka sisältö lisätään indeksirekisteriin, ja saadaan osoite, josta tieto löytyy LOADIDX oso ((oso)+X)->ACC © Lammi-Niskala-Kossarev 38