Tämä luento poikkeuksellisesti salissa TU2, TUAS-talo, Maarintie 7 01110111010110 11110101010101 00101011010011 01010111010101 01001010101010 10101010101010 Tietokoneen mysteeri ohjelmoitava kone Petteri Kaski Tietotekniikan laitos Aalto-yliopisto CS-A1120 Ohjelmointi 2 6. maaliskuuta 2017 10101011110101 01010101011101 01010111010110 10101101010110 10101110101010 11101010101101 01110111010110 10111011010101 11110101010101 00010101010101 01011010101110
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
5. Ohjelmoitava kone
Millä periaatteilla tietokone toimii? (sekventiaalilogiikka kierros 4) Miten rakennetaan ohjelmoitava kone? Mitä on laskenta?
Sekventiaalilogiikan työkalusto NOT EI? (johtoa) 0 1 AND JA OR TAI (kelloliipaistuja (logiikkaportteja) (syöteelementtejä) takaisinkytkentöjä)
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
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
Käskyjen binääriesitys (**) sub $2, $0, $1 0001000010000111 ior $7, $1, 12345 0000001111011100 0011000000111001
Laskentapolku Trigger-työkalulla import armlet._ new DataPathTrigger()
Laskentapolku suorittaa annettuja käskyjä yksitellen Entäpä ohjelmoitavuus? Mitä puuttuu?
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 = 1 + 2 +... + m val NANOS_PER_SEC = 1e9 val test_start_time = System.nanoTime test(4000000000l) 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))
[demo]
Ohjelma = muistiin tallennettu jono käskyjä 00000: 0000000000011010 00001: 0000000000001010 00002: 0000000001011010 00003: 0000000000000001 00004: 0000000010011010 00005: 0000000000000000 00006: 0000000000100011 00007: 0000000000000000 00008: 0000000000100101 00009: 0000000000010001 00010: 0001010010000110 00011: 0000001001011110 00012: 0000000000000001 00013: 0000000000011111 00014: 0000000000000001 00015: 0000000000100100 00016: 0000000000000110 00017: 0000000000111111 Kone suorittaa ohjelmaa, käsky kerrallaan, automaattisesti
Kuinka automatisoida suoritus? (sekventiaalilogiikan työkaluilla)
Mitä suoritus on?
1) Ladataan käskyjä muistista, yksi kerrallaan, ja 2) Ohjataan käsky laskentapolun käsiteltäväksi
Tässäkö kaikki?
Käskyjä ladataan muistista, yksi kerrallaan Mutta missä järjestyksessä? Täsmälleen mistä ladataan seuraava käsky?
Ohjelmalaskuri ( Program Counter, PC ) = rekisteri, jonka arvo ajanhetkellä t kertoo missä ohjelman suoritus on (= mistä muistiosoitteesta ajanhetkenä t suoritettava käsky ladattiin)
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)
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)
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 label @target #... some code here... @target: #... some further code here...
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 label @done if left == right #... some code here... @done: #... some further code here...
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
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)
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
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 }
Symbolinen @loop: @done: 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: 0000000000011010 00001: 0000000000001010 00002: 0000000001011010 00003: 0000000000000001 00004: 0000000010011010 00005: 0000000000000000 00006: 0000000000100011 00007: 0000000000000000 00008: 0000000000100101 00009: 0000000000010001 00010: 0001010010000110 00011: 0000001001011110 00012: 0000000000000001 00013: 0000000000011111 00014: 0000000000000001 00015: 0000000000100100 00016: 0000000000000110 00017: 0000000000111111 Assembly-language program (Loadable/executable) armlet binary
Esimerkkejä lukemistossa Taulukosta summa Taulukon maksimi Taulukon lajittelu kasvavaan järjestykseen Pinon ( stack ) käyttö rekisterien loppuessa
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)
armlet-ohjelmointia Tickerkonekieliohjelmointiympäristöllä [demo] import armlet._ new Ticker() (tai ajamalla Eclipse-tehtäväpaketin launchticker -olio)
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ä
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
Tietokoneen mysteeri selvitetty?
Kyllä Laitteiston periaatteiden ja (laitteistoläheisen) ohjelmoinnin tasolla Osaamme rakentaa ohjelmoitavan koneen
Laskennan ja ohjelmoitavuuden yleisyysperiaate: Ohjelmoitava kone voi, sopivasti ohjelmoituna, simuloida toista ohjelmoitavaa konetta
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)
Tietokoneen mysteeri selvitetty?
Ei laitteiston yksityiskohtien ja ohjelmistojen tasolla
Ohjelmisto ( software ) Käyttöjärjestelmä Laitteisto ( hardware )
Mutta olisiko Scala-ohjelmointi sittenkin ilmaisuvoimaisempaa kuin ohjelmointi (symbolisella) armlet-konekielellä?
Ei Periaatteellisesti ei, laitteistotasolla Scalaa suoritetaan likipitäen armletkonekieltä vastaavalla konekielellä (Java-tavukoodista ajonaikaisesti käännettynä) (**)
Esimerkki Javatavukoodista (*) var i = 1L var s = 0L while(i <= 100000000L) { 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 100000000l 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:
Java-tavukoodista konekieleksi (**) 0: lconst_1 1: lstore_2 2: lconst_0 3: lstore 4 5: lload_2 6: ldc2_w #15; //long 100000000l 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 100000001, %rax L1 (Intel Core i7 konekieltä, tässä ihmisluettavuuden vuoksi symbolisesti esitettynä kone tottelee vain binääriä)
Binäärinä (**) [heksadesimaalina] xorq %rax, %rax incq %rax xorq %rdx, %rdx addq %rax, %rdx incq %rax cmpq 100000001, %rax jne -14 4831C0 48FFC0 4831D2 4801C2 48FFC0 483D01E1F505 75F2 4831C048FFC04831D24801C248FFC0483D01E1F50575F2 (23 x 8 =184 bittiä Intel Core i7 konekieltä)
Mutta olisiko Scala-ohjelmointi sittenkin ilmaisuvoimaisempaa kuin ohjelmointi (symbolisella) armlet-konekielellä?
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
Epilogi: Laitteiston tulevaisuudesta (***) http://arc.research.umich.edu/wp-content/ uploads/2011/10/2011-future-of-computing- Performance-NRC.pdf http://dx.doi.org/10.2200/ S00516ED2V01Y201306CAC024 http://darksilicon.org/papers/ taylor_dark_silicon_horsemen_dac_2012.pdf
http://spectrum.ieee.org/static/special-report-50-years-of-moores-law
https://en.wikipedia.org/wiki/tick-tock_model
Intel Haswell (***) 22 nm Haswell AVX2 suoritusydin: 2 x 8 = 16 liukulukulaskentayksikköä (binary32) Intel Xeon E5-2690 v3 12 x AVX2 suoritusydintä = 192 liukulukulaskentayksikköä (2.6 GHz base, 3.5 GHz boost) [1.0 Tflops base, 1.3 Tflops boost] http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf http://ark.intel.com/products/81713/intel-xeon-processor-e5-2690-v3-30m-cache-2_60-ghz
Intel Skylake / Kaby Lake (***) Skylake AVX2 suoritusydin: 2 x 8 = 16 liukulukulaskentayksikköä (binary32) Intel Core i7-7700k 4 x AVX2 suoritusydintä = 64 liukulukulaskentayksikköä (4.2 GHz base, 4.6 GHz boost) [0.54 Tflops base, 0.59 Tflops boost] 14 nm http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf http://ark.intel.com/products/97129/intel-core-i7-7700k-processor-8m-cache-up-to-4_50-ghz
Intel Knights Landing (***) Knights Landing AVX512 suoritusydin: 2 x 32 = 64 liukulukulaskentayksikköä (binary32) 2 x 16 = 32 liukulukulaskentayksikköä (binary64) 14 nm Intel Xeon Phi 7290F 72 x AVX512 suoritusydintä = 4608 liukulukulaskentayksikköä (binary32) (1.5 GHz base, 1.7 GHz boost) [6.9 Tflops base, 7.8 Tflops boost] = 2304 liukulukulaskentayksikköä (binary64) (1.5 GHz base, 1.7 GHz boost) [3.5 Tflops base, 3.9 Tflops boost] http://www.hotchips.org/wp-content/uploads/hc_archives/hc27/hc27.25-tuesday-epub/hc27.25.70-processors-epub/hc27.25.710-knights-landing-sodani-intel.pdf https://software.intel.com/sites/default/files/managed/05/f6/intel%20xeon%20phi%20processor%20software%20optimization%20guide.pdf http://ark.intel.com/products/95831/intel-xeon-phi-processor-7290f-16gb-1_50-ghz-72-core
Intel Haswell konekieliesimerkki (***) 1029: c4 e2 7d 19 02 vbroadcastsd (%rdx),%ymm0 102e: c4 e2 7d 19 0c 0a vbroadcastsd (%rdx,%rcx,1),%ymm1 1034: c4 e2 7d 19 14 4a vbroadcastsd (%rdx,%rcx,2),%ymm2 103a: 48 83 c2 08 add $0x8,%rdx 103e: c5 fd 28 18 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 28 58 20 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 28 58 40 vmovapd 0x40(%rax),%ymm3 106a: c4 62 fd b8 d3 vfmadd231pd %ymm3,%ymm0,%ymm10 106f: c4 62 f5 b8 db vfmadd231pd %ymm3,%ymm1,%ymm11 1074: c4 62 ed b8 e3 vfmadd231pd %ymm3,%ymm2,%ymm12 1079: c5 fd 28 58 60 vmovapd 0x60(%rax),%ymm3 107e: c4 62 fd b8 eb vfmadd231pd %ymm3,%ymm0,%ymm13 1083: c4 62 f5 b8 f3 vfmadd231pd %ymm3,%ymm1,%ymm14 1088: c4 62 ed b8 fb vfmadd231pd %ymm3,%ymm2,%ymm15 108d: 48 01 c8 add %rcx,%rax 1090: 48 ff cb dec %rbx 1093: 75 94 jne 1029 Esimerkki: Matriisikertolaskualirutiinin sisin silmukka Intel x86 64 konekielellä käyttäen hyväksi Haswell- mikroarkkitehtuurin tukemia AVX2 & FMA -käskykantalaajennuksia
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 http://international.download.nvidia.com/pdf/kepler/nvidia-kepler-gk110-gk210-architecture-whitepaper.pdf
NVIDIA Pascal (***) 16 nm 15.3 mrd transistoria 610 mm 2 SM: 64 liukulukulaskentayksikköä (binary32) 32 liukulukulaskentayksikköä (binary64) Tesla P100 Pascal GP100 (56 SM) = 3584 liukulukulaskentayksikköä (binary32) (1328 MHz base, 1480 MHz boost) [9.5 Tflops base, 10.6 Tflops boost] = 1792 liukulukulaskentayksikköä (binary64) (1328 MHz base, 1480 MHz boost) [4.8 Tflops base, 5.3 Tflops boost] https://images.nvidia.com/content/pdf/tesla/whitepaper/pascal-architecture-whitepaper.pdf http://www.anandtech.com/show/10588/hot-chips-2016-nvidia-gp100-die-shot-released
NVIDIA Kepler konekieliesimerkki (***) /*00c8*/ LOP.AND R2, R4, R19; /* 0xe2000000099c100a */ /*00d0*/ LOP.AND R28, R4, R12; /* 0xe2000000061c1072 */ /*00d8*/ LOP.AND R27, R5, R18; /* 0xe2000000091c146e */ /*00e0*/ LOP.AND R29, R5, R19; /* 0xe2000000099c1476 */ /*00e8*/ LOP.AND R26, R5, R15; /* 0xe2000000079c146a */ /*00f0*/ LOP.AND R25, R6, R14; /* 0xe2000000071c1866 */ /*00f8*/ LOP.AND R3, R4, R13; /* 0xe2000000069c100e */ /* 0x0880808010888010 */ /*0108*/ LOP.XOR R31, R2, R27; /* 0xe20020000d9c087e */ /*0110*/ LOP.AND R20, R5, R12; /* 0xe2000000061c1452 */ /*0118*/ LOP.AND R2, R5, R16; /* 0xe2000000081c140a */ /*0120*/ LOP.AND R21, R6, R15; /* 0xe2000000079c1856 */ /*0128*/ LOP.XOR R25, R26, R25; /* 0xe20020000c9c6866 */ /*0130*/ LOP.AND R24, R7, R14; /* 0xe2000000071c1c62 */ /*0138*/ LOP.AND R32, R5, R13; /* 0xe2000000069c1482 */ /* 0x0884808010a01098 */ /*0148*/ LOP.XOR R28, R28, R29; /* 0xe20020000e9c7072 */ /*0150*/ LOP.AND R29, R4, R17; /* 0xe2000000089c1076 */ /*0158*/ LOP.XOR R27, R21, R24; /* 0xe20020000c1c546e */ /*0160*/ LOP.XOR R3, R3, R20; /* 0xe20020000a1c0c0e */ /*0168*/ LOP.XOR R2, R29, R2; /* 0xe2002000011c740a */ /*0170*/ LOP.AND R20, R4, R18; /* 0xe2000000091c1052 */ /*0178*/ LOP.AND R21, R5, R17; /* 0xe2000000089c1456 */ /* 0x0880808080109810 */ /*0188*/ LOP.AND R26, R6, R18; /* 0xe2000000091c186a */ /*0190*/ LOP.AND R30, R6, R17; /* 0xe2000000089c187a */ /*0198*/ LOP.AND R29, R4, R14; /* 0xe2000000071c1076 */ /*01a0*/ LOP.XOR R21, R20, R21; /* 0xe20020000a9c5056 */ /*01a8*/ LOP.AND R24, R7, R13; /* 0xe2000000069c1c62 */ /*01b0*/ LOP.XOR R28, R28, R26; /* 0xe20020000d1c7072 */ /*01b8*/ IADD R23, R23, 0x1; /* 0xc0800000009c5c5d */ /* 0x088080808010a010 */ Esimerkki: Osa bittirinnakkaistettua 8-bittisen äärellisen kunnan kertolaskualirutiinia NVIDIA Kepler GK110 konekielellä (Compute Capability 3.5 / sm_35)
Intel käyttää tällä hetkellä 14 nanometrin valmistusprosessia 5 nanometriä pidetään rajana tavanomaisille puolijohteille 6.10.2016 Berkeley Lab julkistaa yhden nanometrin portin 1 nanometri = 1 10 9 m = 0.000 000 001 m Piiatomin kovalentti säde on 0.11 nanometriä Piiatomihilan hilakuution sivunpituus on 0.54 nanometriä (300 K lämpötilassa)
Tuhat miljoonaa käskyä sekunnissa, jokaisella laskentaytimellä, tehdashallillisella tietokoneita (***) http://www.google.com/about/datacenters/inside/locations/hamina/ http://dx.doi.org/10.2200/s00516ed2v01y201306cac024
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 6. 7. 8. 9. III Funktionaalinen ohjelmointityyli Suorituskykyanalyysi Rekursio Algoritmit ja informaation esitykset Uuden äärellä 10. Rinnakkaisuus ja samanaikaisuus 11. Virtualisointi ja skaalautuvuus 12. Ohjelmoitava vai oppiva kone?
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ö
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
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
Moduuli 2 Ohjelmoinnin abstraktiot ja analyysi
Kysyttävää, kommentteja, palautetta liittyen Moduuliin 1?