Computerarchitectuur en netwerken. Memory management Assembler programmering

Transcriptie

1 Computerarchitectuur en netwerken 2 Memory management Assembler programmering Lennart Herlaar 10 september 2018

2 Inhoud 1 Protectie: Hoe het O.S. programma s tegen elkaar kan beschermen modes memory management 2 Assemblerprogrammeren: Programmeren voor een simpele CPU Met een assemblertaaltje Gebruik van een stack

3 Protectie We willen het O.S. beschermen tegen foute of kwaadwillende programma s (programmeurs). 1 Gewone programma s mogen niet het geheugen van andere programma s manipuleren 2 Gewone programma s mogen niet het geheugen van het O.S. veranderen 3 Het O.S. mag wel aan andere programma s komen 4 Gewone programma s mogen niet speciale registers veranderen 5 Gewone programma s mogen niet rechtstreeks aan interfaces komen zonder toestemming van het O.S.

4 Protectie: modes 1 User/system mode 2 Geheugenbeheer

5 Protectie: modes 1 User/system mode 2 Geheugenbeheer User mode = uitvoeren van gewone programma s Gevaarlijke operaties (o.a. I/O) niet toegestaan

6 Protectie: modes 1 User/system mode 2 Geheugenbeheer User mode = uitvoeren van gewone programma s Gevaarlijke operaties (o.a. I/O) niet toegestaan System mode = uitvoering O.S. onderdelen Alle operaties toegestaan

7 Protectie: modes 1 User/system mode 2 Geheugenbeheer User mode = uitvoeren van gewone programma s Gevaarlijke operaties (o.a. I/O) niet toegestaan System mode = uitvoering O.S. onderdelen Alle operaties toegestaan Soms nog fijnere verdeling zodat ook binnen het O.S. onderscheid gemaakt kan worden Bij een interrupt/trap overgang naar system mode Aanroep van het O.S. dan ook via een TRAP mechanisme of speciale controle De mode staat in het PSW

8 Adresruimte Adresruimte van een programma = de verzameling van alle adressen die een programma zou kunnen gebruiken uit te voeren instructies adressen van datastructuren en variabelen Op een 32-bits machine kan dat in principe 2 32 bytes (4GB) zijn In principe kan het meer zijn dan het aanwezige echte (fysieke) geheugen

9 Adresruimte Adresruimte van een programma = de verzameling van alle adressen die een programma zou kunnen gebruiken uit te voeren instructies adressen van datastructuren en variabelen Op een 32-bits machine kan dat in principe 2 32 bytes (4GB) zijn In principe kan het meer zijn dan het aanwezige echte (fysieke) geheugen Memory management: de adressen die in een programma gebruikt worden (virtuele adressen) hoeven niet hetzelfde te zijn als de echte adressen die in het fysieke geheugen gebruikt worden (fysieke adressen).

10 Memory management 1 Eenvoudige ontkoppeling: Het begin van een programma krijgt virtueel adres 0 Het fysieke adres waar het programma staat (BASE) wordt bij elk virtueel adres opgeteld Dit gebeurt tussen de CPU en de bus Het programma heeft dit niet in de gaten

11 Memory management 1 Eenvoudige ontkoppeling: Het begin van een programma krijgt virtueel adres 0 Het fysieke adres waar het programma staat (BASE) wordt bij elk virtueel adres opgeteld Dit gebeurt tussen de CPU en de bus Het programma heeft dit niet in de gaten fysieke adressen x+base 0 BASE LIMIT max programma virtuele adressen 0 x limit

12 Memory management 2 Voordelen: Je kunt het programma op ieder adres in het fysieke geheugen draaien Door ook de lengte op te nemen kan de rest van het geheugen beschermd worden (de electronica test virtuele adressen 0 <= x < limit)

13 Memory management 2 Voordelen: Je kunt het programma op ieder adres in het fysieke geheugen draaien Door ook de lengte op te nemen kan de rest van het geheugen beschermd worden (de electronica test virtuele adressen 0 <= x < limit) Nadelen: Grootte beperkt door fysiek geheugen Onmogelijk om te sharen (eenzelfde stuk geheugen in twee programma s te gebruiken)

14 Memory management 2 Voordelen: Je kunt het programma op ieder adres in het fysieke geheugen draaien Door ook de lengte op te nemen kan de rest van het geheugen beschermd worden (de electronica test virtuele adressen 0 <= x < limit) Nadelen: Grootte beperkt door fysiek geheugen Onmogelijk om te sharen (eenzelfde stuk geheugen in twee programma s te gebruiken) Oplossingen: 1 Segmentatie (segmentering) 2 Paginering

15 programma 1 programma 2 Segmentering fysiek geheugen instructies instructies data virtueel geheugen virtueel geheugen data

16 programma 1 programma 2 Segmentering fysiek geheugen instructies data virtueel geheugen virtueel geheugen instructies data Eigenschappen van segmenten: Segmenten kunnen geshared worden Elk programma kan aparte permissies hebben per segment vb. Read, Write, Execute Segmenten kunnen vast, of groeiend zijn. Elk segment moet in het fysieke geheugen passen

17 CPU en stacks Voor het opslaan van tussenresultaten van ingewikkelde berekeningen wordt vaak een stack gebruikt. Voor het onthouden van een terugkeeradres van een functie- of methode-aanroep idem (terugkeeradres = waarde van PC) Een speciaal register wordt gebruikt om te onthouden waar de top van de stack staat (stack-pointer). LIFO = Last In First Out (wat er het laatst opgezet is gaat er het eerst weer af) Push(waarde) = zet waarde op stack en pas SP aan Pop() = return top van de stack en pas SP aan Objecten die niet in de LIFO discipline passen worden in een heap geplaatst.

18 Stack groei stack push/pop SP 0

19 Stack/heap segmenten instructies heap stack segment 0 segment 1 segment 2 Stack segment groeit naar beneden Heap segment groeit naar boven Code segment is vast en kan geshared worden Nog meer segmenten mogelijk voor shared data of libraries

20 Adresberekening Dit gebeurt in de hardware segment offset virtueel adres BASE LIMIT protect. etc. BASE LIMIT protect. etc. + fysiek adres

21 Paginering 1 virtueel geheugen A fysiek geheugen virtueel geheugen B

22 Paginering 2 De virtuele adresruimte en het fysieke geheugen worden opgedeeld in pagina s van vaste grootte Elke virtuele pagina kan in een willekeurige fysieke pagina staan De afbeelding van virtuele naar fysieke paginanummers gaat via een tabel (pagetable). Pagina s kunnen eigen protecties hebben Pagina s kunnen geshared worden Een pagina hoeft niet in het fysieke geheugen aanwezig te zijn: In dat geval gebeurt er een trap (page fault) Bij geheugengebrek kunnen pagina s bijv. op de harde schijf opgeslagen worden (demand paging), of in het netwerk. Page tables kunnen erg groot worden, dan opsplitsen via indirectie

23 Simpele page table virtueel adres page nr offset page nr = index page table fysiek pagina nr offset fysiek adres fysiek geheugen

24 Meer fysiek dan virtueel geheugen Wat doen we als het fysieke geheugen groter is dan de virtuele adresruimte? Bijvoorbeeld: oorspronkelijk MS-DOS/Intel bits machine, 1MB fysiek geheugen Eveneens oplosbaar met segmentering Virtueel geheugen is venster in het fysieke geheugen Venster hoeft niet aaneengesloten in fysieke geheugen te liggen (paginering).

25 Assemblerprogrammeren

26 Assembler programmeren Registers Memory PC SP Code 0 MP RR Stack 2000 We gebruiken een hypothetische CPU: Simple Stack Machine (SSM) De meeste operaties gebeuren op een stack Enkele registers: PC = program counter SP = stack pointer MP = mark pointer RR = resultaat register

27 Hexadecimale notatie Bij gewone decimale notatie betekent 237 : algemeen: pqr = p q r 10 0

28 Hexadecimale notatie Bij gewone decimale notatie betekent 237 : algemeen: pqr = p q r 10 0 Bij hexadecimale notatie gebruiken we 16 cijfers in plaats van 10: abcdef (of hoofdletters) a=10, b=11, c=12, d=13, e=14, f=15

29 Hexadecimale notatie Bij gewone decimale notatie betekent 237 : algemeen: pqr = p q r 10 0 Bij hexadecimale notatie gebruiken we 16 cijfers in plaats van 10: abcdef (of hoofdletters) a=10, b=11, c=12, d=13, e=14, f=15 hex: pqr = p q r 16 0 bijv: hex 2A = = 42(decimaal)

30 Hexadecimale notatie Bij gewone decimale notatie betekent 237 : algemeen: pqr = p q r 10 0 Bij hexadecimale notatie gebruiken we 16 cijfers in plaats van 10: abcdef (of hoofdletters) a=10, b=11, c=12, d=13, e=14, f=15 hex: pqr = p q r 16 0 bijv: hex 2A = = 42(decimaal) Om verwarring te voorkomen schrijven we soms pqr 10 of pqr 16 Voor hex wordt ook wel de notatie 0xpqr gebruikt Dus 0x2A = 42 10

31 Stack operaties Variabelen staan ergens in het geheugen (meestal in de stack) Operaties: bijv. aftrekken push a op de stack push b op de stack doe de sub operatie SP a b SP a b Voor de operatie Na de operatie

32 Push en Pop operaties Om een constante op de stack te pushen: ldc n n is de constante Om een variabele uit de stack te dupliceren naar de top van de stack (push): lds n n = offset (= afstand tussen stackpointer en variabele) voorbeeld: lds 2

33 Push en Pop operaties Om een constante op de stack te pushen: ldc n n is de constante Om een variabele uit de stack te dupliceren naar de top van de stack (push): lds n n = offset (= afstand tussen stackpointer en variabele) voorbeeld: lds SP a b c a b c SP a Voor de operatie Na de operatie

34 Voorbeeld sts n is de pop operatie: berg de top van de stack op in een variabele Code voor a = b c lds -1 // b lds -1 // c mul sts -3 // a = Omdat de stackpointer continu verandert moeten we de offsets iedere keer opnieuw bepalen.

35 Demo 1 Bereken c = (a-b)*(a+b)

36 Demo 1 Bereken c = (a-b)*(a+b) ldc 3 // a = 3 ldc 7 // b = 7 ldc 9 // c = 9 lds -2 // a lds -2 // b sub // a-b lds -3 // a lds -3 // b add // a+b mul // (a-b)*(a+b) sts -1 // c =

37 Markpointer Adresseren t.o.v stackpointer is niet handig Markpointer: wijst naar de locale variabelen van een methode Wordt tevens gebruikt voor de parameters MP a b ldl n voor pushen van variabele stl n voor poppen van variabele n is de offset t.o.v. MP

38 Demo 2 Zelfde berekening met MP

39 Demo 2 Zelfde berekening met MP ldc 3 // a = 3 ldc 7 // b = 7 ldc 9 // c = 9 ldl 1 // a ldl 2 // b sub // a-b ldl 1 // a ldl 2 // b add // a+b mul // (a-b)*(a+b) stl 3 // c =

40 Besturing If, while, for, methode-aanroep Bij sequentiele verwerking wordt telkens de volgende instructie uitgevoerd (PC wordt opgehoogd) Bij if, while etc. wordt een andere volgorde genomen Zogenaamde branch of sprong instructies Soms afhankelijk van een conditie (boolean) We hebben ook instructies om booleans uit te rekenen lt vervangt de top twee elementen van de stack (x en y) door de boolean x < y True = woord met allemaal 1-bits (FFFFFFFF), False = 0. Op dezelfde manier le, gt, ge, eq, ne

41 Besturing De instructie brt label springt naar instructie label als de waarde op de top van de stack True is ( 0) Ook zo brf label bra label springt altijd (kijkt niet naar de stack).

42 Demo 3 Spring als a < b

43 Demo 3 Spring als a < b label: ldc 3 // a = 3 ldc 7 // b = 7 ldc 9 // c = 9 ldl 1 // a ldl 2 // b lt // a<b brt label ldl 1 // a ldl 2 // b add // a+b stl 3 // c =

44 Loops (demo 4) for (int i=1; i<=10; i++) sum = sum+i

45 Loops (demo 4) for (int i=1; i<=10; i++) sum = sum+i ldc 0 // sum ldc 1 // i loop: ldl 2 // i ldc 10 le // i<=10 brf klaar ldl 1 // sum ldl 2 // i add // sum+i stl 1 // sum = ldl 2 // i ldc 1 add // i+1 stl 2 // i = bra loop klaar: halt

46 Methode-aanroep Bij een methode aanroep moeten we na afloop terugkeren (return) programma bsr methode methode ret return

47 Methode-aanroep Bij een methode aanroep moeten we na afloop terugkeren (return) programma bsr methode methode ret return bsr methode // hier gaan we later verder... methode:... ret

48 Stack bij bsr bsr label zet eerst de waarde van de PC op de stack Dit is het adres van de volgende instructie Springt dan naar label

49 Stack bij bsr bsr label zet eerst de waarde van de PC op de stack Dit is het adres van de volgende instructie Springt dan naar label ret popt het adres van de stack en zet het in de PC SP xxxx PC na de instructie SP xxxx Na de bsr instructie Na de ret instructie PC

50 Parameters en resultaat Parameters zetten we op de stack voor de bsr aanroep In de methode reserveren we ruimte voor de locale variabelen We moeten ook de markpointer goed zetten We beginnen de methode met de instructie link n n = aantal woorden voor locale variabelen Voorbeeld: methode vermenigvuldig met 2 parameters en 1 locale variabele (die we niet gebruiken) -3-2 a = 5 b = 12 oude PC MP oude MP +1 SP x

51 Demo 5 print vermenigvuldig(7,9)

52 Demo 5 print vermenigvuldig(7,9) ldc 7 // a ldc 9 // b bsr vermenigvuldig ajs -2 // verwijder parameters ldr RR // resultaat trap 0 halt

53 Demo 5 int vermenigvuldig(int a, int b) { int x; return a*b; }

54 Demo 5 int vermenigvuldig(int a, int b) { int x; return a*b; } vermenigvuldig: link 1 ldl -3 ldl -2 mul str RR unlink ret // a // b // a*b

55 Samenvatting 1 We hebben gezien hoe het O.S. programma s tegen elkaar kan beschermen en zichzelf kan beschermen met behulp van modes (system en user mode) memory management (segmentering en paginering) paginering geeft tevens de mogelijkheid om meer virtueel geheugen te gebruiken dan er fysiek aanwezig is 2 Assemblerprogrammeren: We hebben een simpele virtuele machine gebruikt Met assemblerprogrammeren kun je programma s schrijven die direct door de CPU uitgevoerd kunnen worden zonder dat er een ingewikkelde compiler nodig is. Maar C# is toch makkelijker! We hebben het gebruik van een stack gezien