Tietokoneen mysteeri ohjelmoitava kone

Transkriptio

1 Tietokoneen mysteeri ohjelmoitava kone Petteri Kaski Tietotekniikan laitos Aalto-yliopisto ICS-A1120 Ohjelmointi 2 7. maaliskuuta

2 Tietokoneen mysteeri (4 kierrosta) 2. Bitit ja data binäärilukujärjestelmä, bittien käsittely Scalalla 3. Kombinaatiologiikka 4. Sekventiaalilogiikka 5. Ohjelmoitava kone logiikkaporteista rakennettuja piirejä Scala-simuloituna kello ja takaisinkytkentä Scala-simulaatioon, prosessorin laskentapolku konekieliohjelmoimme 5574-porttista Scalalla rak. & simuloitua armlet -prosessoria

3 5. Ohjelmoitava kone

4 Millä periaatteilla tietokone toimii? (sekventiaalilogiikka kierros 4) Miten rakennetaan ohjelmoitava kone? Mitä on laskenta?

5 Sekventiaalilogiikan työkalusto NOT EI? (johtoa) 0 1 AND JA OR TAI (kelloliipaistuja (logiikkaportteja) (syöteelementtejä) takaisinkytkentöjä)

6 armlet-laskentapolku ( data path ) lcu_e C $0 $1 $2 $3 $4 $5 $6 $7 read_in Load completion unit instr_in mem_read_e mem_write_e mem_addr Arithmetic logic unit Memory interface unit Instruction decoder unit immed_in mem_data lcu_e C $0 $1 $2 $3 $4 $5 $6 $7

7 Käskykanta (laskentapolkua ohjaavat käskyt) nop # no operation mov $L, $A # $L = $A (copy the value of $A to $L) and $L, $A, $B # $L = bitwise AND of $A and $B ior $L, $A, $B # $L = bitwise (inclusive) OR of $A and $B eor $L, $A, $B # $L = bitwise exclusive-or of $A and $B not $L, $A # $L = bitwise NOT of $A add $L, $A, $B # $L = $A + $B sub $L, $A, $B # $L = $A - $B neg $L, $A # $L = -$A lsl $L, $A, $B # $L = $A shifted to the left by $B bits lsr $L, $A, $B # $L = $A shifted to the right by $B bits asr $L, $A, $B # $L = $A (arithmetically) shifted to the right by $B bits mov $L, I add $L, $A, I sub $L, $A, I and $L, $A, I ior $L, $A, I eor $L, $A, I lsl $L, $A, I lsr $L, $A, I asr $L, $A, I # $L = I (copy the immediate data I to $L) # $L = $A + I # $L = $A - I # $L = bitwise AND of $A and I # $L = bitwise (inclusive) OR of $A and I # $L = bitwise exclusive OR of $A and I # $L = $A shifted to the left by I bits # $L = $A shifted to the right by I bits # $L = $A (arithmetically) shifted to the right by I bits loa $L, $A # $L = [contents of memory word at address $A] sto $L, $A # [contents of memory word at address $L] = $A

8 Käskyjen binääriesitys (**) sub $2, $0, $ ior $7, $1,

9 Laskentapolku Trigger-työkalulla import armlet._ new DataPathTrigger()

10 Laskentapolku suorittaa annettuja käskyjä yksitellen Entäpä ohjelmoitavuus? Mitä puuttuu?

11 Scala-esimerkki ensimmäiseltä luennolta def test(m: Long) = { var i = 1L var s = 0L } while(i <= m) { s = s + i i = i + 1 } s // s = m val NANOS_PER_SEC = 1e9 val test_start_time = System.nanoTime test( l) val test_end_time = System.nanoTime val test_duration = test_end_time - test_start_time println("test took %.2f seconds".format(test_duration/nanos_per_sec))

12 [demo]

13 Ohjelma = muistiin tallennettu jono käskyjä 00000: : : : : : : : : : : : : : : : : : Kone suorittaa ohjelmaa, käsky kerrallaan, automaattisesti

14 Kuinka automatisoida suoritus? (sekventiaalilogiikan työkaluilla)

15 Mitä suoritus on?

16 1) Ladataan käskyjä muistista, yksi kerrallaan, ja 2) Ohjataan käsky laskentapolun käsiteltäväksi

17 Tässäkö kaikki?

18 Käskyjä ladataan muistista, yksi kerrallaan Mutta missä järjestyksessä? Täsmälleen mistä ladataan seuraava käsky?

19 Ohjelmalaskuri ( Program Counter, PC ) = rekisteri, jonka arvo ajanhetkellä t kertoo missä ohjelman suoritus on (= mistä muistiosoitteesta ajanhetkenä t suoritettava käsky ladattiin)

20 Ohjelmalaskurin eteneminen Oletus: PC t + 1 = PC t + 1 (aloitus: PC 0 = 0) Oletusjärjestystä voidaan muuttaa erillisillä suoritusta ohjaavilla käskyillä: Hyppykäskyt ( jump ) PC t + 1 = hypyn kohdeosoite Haarautumiskäskyt ( branch ) PC t + 1 = hypyn kohdeosoite jos haarautumisehto on tosi; muuten oletusjärjestys (PC t + 1)

21 Tilarekisteri ( Program Status Register, PSR ) = rekisteri, jossa tallennettuna tuoreimman vertailukäskyn määräämän vertailun tulos (haarautumiskäskyt käyttävät tulosta ohjaamaan suoritusta)

22 Hyppy Hyppykäsky määrää jatkamaan suoritusta määrätystä osoitteesta Hyppy vastaa käytännössä hypyn kohdeosoitteen siirtämistä ohjelmalaskuriin jmp >target # jump to #... some code #... some further code here...

23 Vertailu + Haarautuminen Vertaillaan kahta arvoa (rekisteri vs rekisteri tai rekisteri vs vakio) Ehdollinen haarautuminen viimeisimmän vertailun tuloksen perusteella Hyppy suoritetaan jos ja vain jos haarautumisehto on tosi Muuten jatketaan suoritusta oletusjärjestyksessä cmp $7, 0 beq >done # compare $7 (left) and 0 (right) # jump to if left == right #... some code #... some further code here...

24 armlet-prosessori (*) lcu_e C $0 $1 $2 $3 $4 $5 $6 $7 PC PS Load completion unit read_in mem_read_e mem_write_e mem_addr Arithmetic logic unit Memory interface unit Control and execution unit reset_e mem_data hlt_f lcu_e C $0 $1 $2 $3 $4 $5 $6 $7 PC PS

25 Kierros 5: Ohjelmoitava kone Suoritusta ohjaavat käskyt (hyppy ja ehdollinen haarautuminen) Konekieli (binääri) ja symbolinen konekieli ( assembly language ) Symbolinen konekieliohjelmointi Konekieliohjelmointi- ja simulaatioympäristö armlet -arkkitehtuurille ( Ticker -työkalu)

26 Käskykanta (suoritusta ohjaavat käskyt) cmp $A, $B # compare $A (left) and $B (right) cmp $A, I # compare $A (left) and I (right) jmp $A # jump to address $A beq $A #... if left == right (in the most recent comparison) bne $A #... if left!= right bgt $A #... if left > right (signed) blt $A #... if left < right (signed) bge $A #... if left >= right (signed) ble $A #... if left <= right (signed) bab $A #... if left > right (unsigned) bbw $A #... if left < right (unsigned) bae $A #... if left >= right (unsigned) bbe $A #... if left <= right (unsigned) jmp I # jump to address I beq I #... if left == right (in the most recent comparison) bne I #... if left!= right bgt I #... if left > right (signed) blt I #... if left < right (signed) bge I #... if left >= right (signed) ble I #... if left <= right (signed) bab I #... if left > right (unsigned) bbw I #... if left < right (unsigned) bae I #... if left >= right (unsigned) bbe I #... if left <= right (unsigned) hlt # halt execution trp # trap (break out of execution for debugging) Vertailu Hyppy (jump) ja haarautuminen (branch) tuoreimman vertailun tuloksen perusteella Hyppy (jump) ja haarautuminen (branch) tuoreimman vertailun tuloksen perusteella Pysäytys

27 Ensimmäinen armlet-ohjelmamme var t = 10 var i = 1 var s = 0 while(t!= 0) { s = s + i i = i + 1 t = t - 1 }

28 Symbolinen mov $0, 10 mov $1, 1 mov $2, 0 cmp $0, 0 beq >done add $2, $2, $1 add $1, $1, 1 sub $0, $0, 1 jmp >loop hlt armletkonekieliohjelma Konekielikääntäjä Assembler Konekieliohjelma (armlet-binääri) 00000: : : : : : : : : : : : : : : : : : Assembly-language program (Loadable/executable) armlet binary

29 Esimerkkejä lukemistossa Taulukosta summa Taulukon maksimi Taulukon lajittelu kasvavaan järjestykseen Pinon ( stack ) käyttö rekisterien loppuessa

30 Suorituksen keskeyttäminen ja pysäyttäminen Keskeyttäminen ( trap, käsky trp) (ohjelmointiympäristöstä voidaan seurata miltä suoritus näyttää trp-käskyn kohdalla ja sitten jatkaa suoritusta näppärä tuholaistorjuntatarkoituksissa ) Pysäyttäminen ( halt, käsky hlt) (suoritus pysähtyy, vailla mahdollisuutta jatkaa)

31 armlet-ohjelmointia Tickerkonekieliohjelmointi- ympäristöllä [demo] import armlet._ new Ticker() (tai ajamalla Eclipse-tehtäväpaketin launchticker -olio)

32 Harjoituksissa Vakuutumme, että suunnittelemamme armlet-prosessori on kuin onkin ohjelmoitava kone Ohjelmointi (symbolisella) konekielellä on ohjelmoijalle työlästä puuhaa Tehtävät ratkaistuasi osaat arvostaa nykyaikaisia ohjelmointikieliä

33 Tehtävät (armlet-konekielellä) expression yhteen- ja vähennyslaskua rekistereillä wordops rekisterien bittien käsittelyä range kokonaislukutaulukon vaihteluväli (= max min) multiply kertolaskualirutiini (armlet ei tue kertolaskua laitteistotasolla) mostfrequent taulukossa useimmin esiintyvä arvo (lajittelualirutiini annettu) gcd (haastetehtävä) kahden rekisterin suurin yhteinen tekijä -alirutiini

34 Tietokoneen mysteeri selvitetty?

35 Kyllä Laitteiston periaatteiden ja (laitteistoläheisen) ohjelmoinnin tasolla Osaamme rakentaa ohjelmoitavan koneen

36 Laskennan ja ohjelmoitavuuden yleisyysperiaate: Ohjelmoitava kone voi, sopivasti ohjelmoituna, simuloida toista ohjelmoitavaa konetta

37 Laskenta ja ohjelmointi ovat laitteistosta ja ohjelmointikielestä riippumattomia käsitteitä (käytännössä fyysinen laitteisto, esimerkiksi käytettävissä olevan muistin määrä, ja simulaation tehokkuus rajaavat edellistä väitettä jonkin verran)

38 Tietokoneen mysteeri selvitetty?

39 Ei laitteiston yksityiskohtien ja ohjelmistojen tasolla

40 Ohjelmisto ( software ) Käyttöjärjestelmä Laitteisto ( hardware )

41 Mutta olisiko Scala-ohjelmointi sittenkin ilmaisuvoimaisempaa kuin ohjelmointi (symbolisella) armlet-konekielellä?

42 Ei Periaatteellisesti ei, laitteistotasolla Scalaa suoritetaan likipitäen armletkonekieltä vastaavalla konekielellä (Java-tavukoodista ajonaikaisesti käännettynä) (**)

43 Esimerkki Javatavukoodista (*) var i = 1L var s = 0L while(i <= L) { s = s + i i = i + 1 } (lukemistossa laajemmin) Scala 0: lconst_1 1: lstore_2 2: lconst_0 3: lstore 4 5: lload_2 6: ldc2_w #15; //long l 9: lcmp 10: ifgt 26 13: lload 4 15: lload_2 16: ladd 17: lstore 4 19: lload_2 20: lconst_1 21: ladd 22: lstore_2 23: goto 5 26:

44 Java-tavukoodista konekieleksi (**) 0: lconst_1 1: lstore_2 2: lconst_0 3: lstore 4 5: lload_2 6: ldc2_w #15; //long l 9: lcmp 10: ifgt 26 13: lload 4 15: lload_2 16: ladd 17: lstore 4 19: lload_2 20: lconst_1 21: ladd 22: lstore_2 23: goto 5 26: JVM xorq incq xorq L1: addq incq cmpq jne L2: %rax, %rax %rax %rdx, %rdx %rax, %rdx %rax , %rax L1 (Intel Core i7 konekieltä, tässä ihmisluettavuuden vuoksi symbolisesti esitettynä kone tottelee vain binääriä)

45 Binäärinä (**) [heksadesimaalina] xorq %rax, %rax incq %rax xorq %rdx, %rdx addq %rax, %rdx incq %rax cmpq , %rax jne C0 48FFC0 4831D2 4801C2 48FFC0 483D01E1F505 75F2 4831C048FFC04831D24801C248FFC0483D01E1F50575F2 (23 x 8 =184 bittiä Intel Core i7 konekieltä)

46 Mutta olisiko Scala-ohjelmointi sittenkin ilmaisuvoimaisempaa kuin ohjelmointi (symbolisella) armlet-konekielellä?

47 Kyllä Käytännössä kyllä, Scala on ohjelmoijan tuottavuuden kannalta huomattavasti näppärämpi työkalu kuin konekieli Scala on kuitenkin vain ohjelma, jolla laitteisto saadaan näppärämmin ohjelmoijan määräämään käyttöön

48 Epilogi: Laitteiston tulevaisuudesta (***) uploads/2011/10/2011-future-of-computing- Performance-NRC.pdf S00516ED2V01Y201306CAC024 taylor_dark_silicon_horsemen_dac_2012.pdf

49 [Patterson, Hennessy: Computer Organization and Design, 5th ed., 2014, p. 40]

50 [Patterson, Hennessy: Computer Organization and Design, 5th ed., 2014, p. 44]

51

52 Intel Haswell (***) 22 nm Haswell AVX2 suoritusydin: 2 x 8 = 16 liukulukulaskentayksikköä (binary32) Intel Xeon E v3 12 x AVX2 suoritusydintä = 192 liukulukulaskentayksikköä (2.6 GHz base, 3.5 GHz boost) [1.0 Tflops base, 1.3 Tflops boost]

53 Intel Haswell konekieliesimerkki (***) 1029: c4 e2 7d vbroadcastsd (%rdx),%ymm0 102e: c4 e2 7d 19 0c 0a vbroadcastsd (%rdx,%rcx,1),%ymm1 1034: c4 e2 7d a vbroadcastsd (%rdx,%rcx,2),%ymm2 103a: c2 08 add $0x8,%rdx 103e: c5 fd vmovapd (%rax),%ymm3 1042: c4 e2 fd b8 e3 vfmadd231pd %ymm3,%ymm0,%ymm4 1047: c4 e2 f5 b8 eb vfmadd231pd %ymm3,%ymm1,%ymm5 104c: c4 e2 ed b8 f3 vfmadd231pd %ymm3,%ymm2,%ymm6 1051: c5 fd vmovapd 0x20(%rax),%ymm3 1056: c4 e2 fd b8 fb vfmadd231pd %ymm3,%ymm0,%ymm7 105b: c4 62 f5 b8 c3 vfmadd231pd %ymm3,%ymm1,%ymm8 1060: c4 62 ed b8 cb vfmadd231pd %ymm3,%ymm2,%ymm9 1065: c5 fd vmovapd 0x40(%rax),%ymm3 106a: c4 62 fd b8 d3 vfmadd231pd %ymm3,%ymm0,%ymm10 106f: c4 62 f5 b8 db vfmadd231pd %ymm3,%ymm1,%ymm : c4 62 ed b8 e3 vfmadd231pd %ymm3,%ymm2,%ymm : c5 fd vmovapd 0x60(%rax),%ymm3 107e: c4 62 fd b8 eb vfmadd231pd %ymm3,%ymm0,%ymm : c4 62 f5 b8 f3 vfmadd231pd %ymm3,%ymm1,%ymm : c4 62 ed b8 fb vfmadd231pd %ymm3,%ymm2,%ymm15 108d: c8 add %rcx,%rax 1090: 48 ff cb dec %rbx 1093: jne 1029 Esimerkki: Matriisikertolaskualirutiinin sisin silmukka Intel x86 64 konekielellä käyttäen hyväksi Haswell- mikroarkkitehtuurin tukemia AVX2 & FMA -käskykantalaajennuksia

54 NVIDIA Kepler (***) SMX: 6 x 32 = 192 liukulukulaskentayksikköä (binary32) Tesla K40 Kepler GK110 (15 SMX) = 2880 liukulukulaskentayksikköä (745 MHz base, 875 MHz boost) [4.3 Tflops base, 5.0 Tflops boost] Tesla K80 2 x Kepler GK210 (13 SMX) = 2 x 2496 = 4992 liukulukulaskentayks. (562 MHz base, 875 MHz boost) [5.6 Tflops base, 8.7 Tflops boost] 28 nm

55 NVIDIA Kepler konekieliesimerkki (***) /*00c8*/ LOP.AND R2, R4, R19; /* 0xe c100a */ /*00d0*/ LOP.AND R28, R4, R12; /* 0xe c1072 */ /*00d8*/ LOP.AND R27, R5, R18; /* 0xe c146e */ /*00e0*/ LOP.AND R29, R5, R19; /* 0xe c1476 */ /*00e8*/ LOP.AND R26, R5, R15; /* 0xe c146a */ /*00f0*/ LOP.AND R25, R6, R14; /* 0xe c1866 */ /*00f8*/ LOP.AND R3, R4, R13; /* 0xe c100e */ /* 0x */ /*0108*/ LOP.XOR R31, R2, R27; /* 0xe d9c087e */ /*0110*/ LOP.AND R20, R5, R12; /* 0xe c1452 */ /*0118*/ LOP.AND R2, R5, R16; /* 0xe c140a */ /*0120*/ LOP.AND R21, R6, R15; /* 0xe c1856 */ /*0128*/ LOP.XOR R25, R26, R25; /* 0xe c9c6866 */ /*0130*/ LOP.AND R24, R7, R14; /* 0xe c1c62 */ /*0138*/ LOP.AND R32, R5, R13; /* 0xe c1482 */ /* 0x a01098 */ /*0148*/ LOP.XOR R28, R28, R29; /* 0xe e9c7072 */ /*0150*/ LOP.AND R29, R4, R17; /* 0xe c1076 */ /*0158*/ LOP.XOR R27, R21, R24; /* 0xe c1c546e */ /*0160*/ LOP.XOR R3, R3, R20; /* 0xe a1c0c0e */ /*0168*/ LOP.XOR R2, R29, R2; /* 0xe c740a */ /*0170*/ LOP.AND R20, R4, R18; /* 0xe c1052 */ /*0178*/ LOP.AND R21, R5, R17; /* 0xe c1456 */ /* 0x */ /*0188*/ LOP.AND R26, R6, R18; /* 0xe c186a */ /*0190*/ LOP.AND R30, R6, R17; /* 0xe c187a */ /*0198*/ LOP.AND R29, R4, R14; /* 0xe c1076 */ /*01a0*/ LOP.XOR R21, R20, R21; /* 0xe a9c5056 */ /*01a8*/ LOP.AND R24, R7, R13; /* 0xe c1c62 */ /*01b0*/ LOP.XOR R28, R28, R26; /* 0xe d1c7072 */ /*01b8*/ IADD R23, R23, 0x1; /* 0xc c5c5d */ /* 0x a010 */ Esimerkki: Osa bittirinnakkaistettua 8-bittisen äärellisen kunnan kertolaskualirutiinia NVIDIA Kepler GK110 konekielellä (Compute Capability 3.5 / sm_35)

56 Tuhat miljoonaa käskyä sekunnissa, jokaisella laskentaytimellä, tehdashallillisella tietokoneita (***)

57 Sisältö (kierrokset ja moduulit) I 1. Lämmittelykierros Tietokoneen mysteeri 2. Bitit ja data 3. Kombinaatiologiikka 4. Sekventiaalilogiikka 5. Ohjelmoitava kone II Abstraktiot ja analyysi III Funktionaalinen ohjelmointityyli Suorituskykyanalyysi Rekursio Algoritmit ja informaation esitykset Uuden äärellä 10. Rinnakkaisuus ja samanaikaisuus 11. Virtualisointi ja skaalautuvuus 12. Ohjelmoitava vai oppiva kone?

58 Yhteenveto (1/3) Laitteisto Ohjelmisto -rajapinta, pohjalta ponnistaen bitit, porttitaso, väylätaso, kombinaatiopiirit, takaisinkytkennät ja kello, sekventiaalipiirit, laskentapolku, prosessori, muisti, ohjelmoitava kone käskykanta, mikroarkkitehtuuri konekieli, symbolinen konekieli, konekielikääntäjä (assembler), ohjelmointiympäristö

59 Yhteenveto (2/3) Mitä opimme, ohjelmoinnista? (mm.) Tuhat miljoonaa käskyä sekunnissa (!) Perimmiltään kaikki koostuu biteistä Laitteistosuunnittelukin on ohjelmointia Ohjelma, suoritus, laskenta Laskenta ja ohjelmointi ovat varsinaisesta laitteistosta ja ohjelmointikielestä riippumattomia käsitteitä ohjelmoitava kone voi, sopivasti ohjelmoituna, simuloida toista ohjelmoitavaa konetta Simulaation hyödyllisyys opetusvälineenä ja ammattimaisesti

60 Yhteenveto (3/3) Mitä opimme, ohjelmoinnista? (mm.) Ohjelmointi on taito valjastaa laskenta haluttuun tarkoitukseen, tarvittaessa omat työkalut rakentaen, olemassaolevia työkaluja hyödyntäen Leikki ( testaaminen ) ja työkalujen kriittinen arviointi on tärkeää Kapselointi ja harkitut ohjelmalliset abstraktiot (funktiot, oliot, pakkaukset, jne.) auttavat monimutkaisempien kokonaisuuksien ohjelmallisessa hallinnassa Ohjelmointikielet (kuten Scala) ovat vain ohjelmallisia työkaluja valjastaa laitteisto ohjelmoijan määräysvaltaan

61 Moduuli 2 Ohjelmoinnin abstraktiot ja analyysi

62 Kysyttävää, kommentteja, palautetta liittyen Moduuliin 1?