Informatica. Deel II: les 9 OS & AVL. Jan Lemeire. Informatica deel II. februari mei Informatica II: les 9

Transcriptie

1 Informatica Deel II: les 9 OS & AVL Jan Lemeire Informatica deel II februari mei 2014

2 Hoofdstuk 8: Operating Systems Jan Lemeire Pag. 2 / 64

3 Bedrijfscomputers Initieel waren er voornamelijk bedrijfscomputers Centrale computer mainframe systemen Voornaamste fabrikant: IBM Jan Lemeire Pag. 3 / 64

4 Interactiviteit via Terminal Scherm van 24 lijnen van 80 tekens groot Gebruikers Informatica II: werken les 9 op de centrale computer via domme terminals die enkel het scherm tonen en de input van de gebruiker (via toetsenbord) doorgeven. Jan Lemeire Pag. 4 / 64

5 Toepassingen mainframe Gegevens (bvb boekhouding) van banken, bedrijven, winkels etc Gegevens worden bijgehouden in database Database = gestructureerd bijhouden van gegevens Eigenschappen mainframe: Betrouwbaarheid (heel belangrijk) Robuust (crasht bijna nooit) Veiligheid (security) van gegevens (bvb bankgegevens) Jan Lemeire Pag. 5 / 64

6 IBM gaat voor Personal Computer Computer voor thuis Kan op eigen kracht werken (niet geconnecteerd met centrale computer) De PC is geboren! IBM: op dat moment het grootste informaticabedrijf Concentreert zich op hardware De PC ontketent een nieuwe revolutie in de informatica 1981 Jan Lemeire Pag. 6 / 64

7 IBM gaat langs bij Bill Gates en vrienden Zitten thuis te programmeren Steken DOS in elkaar MicroSoft is geboren Nog steeds terug te vinden in Windows Cmd-window Programma s start je met commando (en eventueel argumenten)

8 IBM heeft Operating System nodig IBM gaat langs bij Bill Gates en zijn hippie -vrienden Zitten thuis te programmeren MicroSoft is geboren Steken DOS (Disc Operating System) in elkaar Nog steeds terug te vinden in Windows Cmd-window Programma s start je met commando (en eventueel argumenten dit zijn de String[] args van de main) Jan Lemeire Pag. 8 / 64

9 Commando-based: Je geeft commando s In de terminal of shell Jan Lemeire Pag. 9 / 64

10 Bill Gates wordt rijkste man ter wereld 0.1 Jan Lemeire Pag. 10 / 64

11 Macht ligt vanaf nu bij software en vooral het besturingsysteem 1984 IBM maakt historische vergissing door op hardware te blijven mikken Ze mist de softwareboot compleet Jan Lemeire Pag. 11 / 64

12 IBM Jan Lemeire Pag. 12 / 64

13 Besturingsysteem = Operating System (OS) OS regelt en organiseert de computer OS wordt van harde schijf gestart bij het booten BIOS zorgt hiervoor Een besturingssysteem (in het Engels operating system of afgekort OS) is een programma (meestal een geheel van samenwerkende programma's) dat na het opstarten van een computer in het geheugen geladen wordt en alle mogelijkheden van de computer aan de gebruiker. Het OS biedt ook de functionaliteiten aan om andere programma's - applicaties genoemd - uit te voeren. Jan Lemeire Pag. 13 / 64

14 Application Programming Interface (API) OS verstopt de details van de hardware voor de gebruiker en voor applicaties dmv een API Deze worden op een uniforme wijze aan de applicaties aangeboden. De API abstraheert de toegang tot de verschillende randapparatuur, zonder OS moet elk programma zelf instaan voor het aansturen van randapparatuur (zoals printer, beeldschermen, harde schijf). Gebruikersprogramma is enkel afhankelijk van het OS, niet van de randapparatuur. Het communiceren van het OS met het randapparaat gebeurt via een driver. Jan Lemeire Pag. 14 / 64

15 Hoofdtaken OS (vervolg) Verdelen van toegang tot systeembronnen (RAM-geheugen, opslag, printer etc.) tussen actieve programma's Elk programma krijgt een deel van het werkgeheugen toegewezen (java: standaard 64MB, je kan dit anders instellen) OS voorkomt dat programma buiten zijn deel gegevens kan lezen of schrijven (beveiliging!) Aanbieden gegevens (files) en applicaties aan gebruiker OS beheert het filesysteem (georganiseerd in een boomstructuur dmv folders) Verdelen van processortijd over de aktieve programma s Zie verder Jan Lemeire Pag. 15 / 64

16 Interactiviteit Geen interactiviteit = batch programma Programma en gegevens worden op voorhand klaargemaakt Tijdens de uitvoering kan je niet interageren met het programma Resultaten worden op het einde als geheel gepresenteerd Commando-gebaseerd Cf DOS, linux shell De commando s worden geïnterpreteerd en het programma gestart Je kan een lijst van commando s doorgeven ( batch ) Grafische User-Interface (GUI) Windows, muis, toetsenbord, touch screen Jan Lemeire Pag. 16 / 64

17 Task Manager Windows: start via Control-Alt-Delete Toont aktieve applicaties en processen, alsook processorgebruik Applicaties: van gebruiker Processen: naast processen van applicatie, ook processen en services van operating system, achtergrondprocessen van applicaties, Operating System verdeelt cycles van processor (CPU) over de verschillende processen (process scheduling) Op een modern OS kan je meerdere programma s tegelijk draaien. Het uitvoeren van een programma resulteert in een proces. Een achtergrondproces is in feite ook een gewoon programma, maar ze is niet zichtbaar voor de gebruiker. De achtergrondprocessen zorgen voor het beheer van het systeem of bieden Informatica services II: les 9 aan (zoals het sharen van je (muziek-)files en het checken Jan Lemeire Pag. 17 / 64 van je mailbox).

18 Threads van processen main(){ thread.start(); Hoofdthread Process Zijthread run(){ Eén programma kan bestaan uit meerdere threads. Elke thread voert een sequentie van instructies uit. Een sequentie kan je zien als een draad, vandaar de benaming. Vele moderne toepassingen zijn zelf opgebouwd uit een groot aantal onafhankelijke threads die simultaan uitgevoerd worden. Het tekstverwerkingsprogramma Word bv. gebruikt verschillende threads om teksten en figuren op het scherm te tonen, zodanig dat wanneer men snel door een tekst wenst te lopen men niet hoeft te wachten op het tekenen van alle figuren. Een andere thread zal tegelijkertijd je taalfouten opsporen (de spelling checker). Jan Lemeire Pag. 18 / 64

19 Processor kan maar 1 instructiesequentie tegelijk uitvoeren Jan Lemeire Pag. 19 / 64

20 Threads van je project Niet in cursus Hoofdthread Proces Thread voor afhandelen events Thread voor timer main(){ Jframe frame = new Jframe(); frame.show();... Hoofdthread doet niets meer Windows do{ Wacht op event Bepaal broncomponent Roep Listeners op actionperformed(){... timer.start();... Uw code while (frame is shown); Maar 1 GUI-thread: kan maar 1 actie/event tegelijk afhandelen!!! Windows For(elke x ms){ Jan Lemeire Pag. 20 / 64 Aparte thread voor spellus actionperformed(){ Uw code

21 Process scheduler De process-scheduler is een deel van het besturingssysteem dat op elk ogenblik bepaalt aan welk van alle programma's die zich in werkgeheugen bevinden de centrale verwerkingseenheid zal werken. Het hart van de computer, de processor of CPU, kan immers maar 1 programma tegelijk uitvoeren. De processor is immers opgebouwd volgens de Von Neumann-architectuur. Karakteristiek voor deze architectuur is dat hij één programma stap-voor-stap uitvoert. Moderne computers hebben echter meerdere processorcores (dual core, quadcore, ). Dat zijn dan in feite 2, respectievelijk 4 onafhankelijke processoren die elk één proces tegelijkertijd kunnen uitvoeren. De process-scheduler zal per core de processortijd verdelen over de lopende processen en threads: elk proces/thread krijgt een periode ( time slice ) toegekend. Jan Lemeire Pag. 21 / 64

22 Toestanden van proces De lopende processen, kunnen zich, op elk ogenblik in drie toestanden bevinden: 1) actief: de centrale verwerkingseenheid (processor) is aan het proces aan het werken; dwz. dat instructies van dat programma opgehaald worden door de stuureenheid. 2) geblokkeerd: een in- of uitvoeroperatie (Input/Output of I/O) is aan de gang en het proces moet wachten tot het einde ervan; 3) wachtend: het proces zou kunnen uitgevoerd worden, maar de centrale verwerkingseenheid is niet beschikbaar, ze is instructies van een ander proces aan het uitvoeren. Het proces moet wachten tot de proces-scheduler Informatica II: 9 processorcycles ter beschikking stelt. Jan Lemeire Pag. 22 / 64

23 Overgang van 1 proces naar een ander Als het aktieve proces op I/O (input/output) moet wachten Dikwijls wordt bij I/O het OS geaktiveerd, omdat die de I/O beheert (bvb toegang tot files) Of als de toegekende time slice die een proces toegekend krijgt op is Timer wordt gestart en geeft een interrupt Interrupt geeft aan processor aan dat de scheduler van het OS weer geaktiveerd moet worden Overgang van 1 proces naar een ander: context switch de staat vh proces wordt opgeslagen en dat van het ander wordt geladen Jan Lemeire Pag. 23 / 64

24 Interrupts Met een Interrupt ( onderbreking ) wordt een lopend programma onderbroken. Deze is voorzien in de hardware van de processor! Je kan immers niet verwachten dat een lopend programma zelf zal checken of hij verder kan gaan. Ook kan het OS er niet van uitgaan dat elk programma in een redelijke tijd stopt. Het OS moet op elk moment een programma kunnen onderbreken. Anders zou een oneindige lus volledig beslag leggen op je processor zonder dat je er iets aan kan doen, behalve dan de computer herstarten. Let op: het OS is ook niets meer dan een programma. Er is geen big brother in je computer die toekijkt wat de processor doet. Controle over het aktieve proces wordt verkregen door interrupts. Om toe te laten op gelijk welk ogenblik sprongen tussen toepassingsprogramma en besturingssysteem te maken bevatten processoren een hardwareschakeling waardoor een programma kan onderbroken worden door middel van een interrupt. Vervolgens bepaalt de interrupt handler welk programma uitgevoerd moet worden. Aan de hand van de oorsprong van de interrupt veroorzaakt deze een sprong naar het gewenste programma. De interrupt handler speelt dus een centrale rol en vormt dan ook het hoofdbestanddeel van de kern van moderne besturingssystemen. Jan Lemeire Pag. 24 / 64

25 Unix & Linux UNIX operating system: zoals mainframe initieel bestemd voor bedrijfscomputers User moet inloggen Heeft eigen files op server (in zijn home) Enkel administrator kan dingen aan systeem veranderen Linux: Open Source-versie van UNIX Open Source volgt de GNU-regels: de code mag vrij (gratis) gebruikt worden zolang er geen geld voor gevraagd wordt Apple gebruikt nu ook Unix-versie Android van Google is java op Linux Conclusie: in de consumentenmarkt is het Windows of Linux. Jan Lemeire Pag. 25 / 64

26 Vandaag 1. Besturingssystemen 2. Operaties op binaire bomen (vervolg) 3. Java applets 4. AVL-bomen

27 Operaties op bomen (vervolg)

28 Elke node is een object class Node<T>{ T data; Node<T> left, right; Node(T data){ this.data = data; this.left = null; this.right = null; Jan Lemeire Pag. 28 / 64

29 Boom object public class BinaryTree<T> { Node<T> root; Comparator<T> comparator; public BinaryTree(Comparator<T> comparator){ this.comparator = comparator; root = null; Jan Lemeire Pag. 29 / 64

30 Belangrijke operaties 1. Toevoegen element 2. Zoeken element 3. Verwijderen element 4. Doorlopen van boom (bvb printen) 5. Balanceren van de boom Jan Lemeire Pag. 30 / 64

31 3. Verwijderen van element p mogelijkheden: Element is root Element is niet in boom Element heeft 0 of 1 subboom Element heeft 2 subbomen 5 Jan Lemeire Pag. 31 / mogelijke situaties : a) 2 subbomen: 3, 6 b) 0 of 1 subboom: 1, 2, 4, 5, 7 c) niet aanwezig: 0, 8,

32 4 e geval: promoten van node Meest linkse van rechtersubboom Meest rechtse van linkersubboom Jan Lemeire Pag. 32 / 64

33 public boolean remove(t object){ if (comparator.compare(root.data, object)== 0){ root = createsubtree(root); return true; else return findnodeandremove(root, object); p. 72 private boolean findnodeandremove(node<t> current, T object){ if (current == null) return false; if (current.left!= null && comparator.compare(current.left.data, object)== 0){ current.left = createsubtree(current.left); return true; else if (current.right!= null && comparator.compare(current.right.data, object)== 0){ current.left = createsubtree(current.right); return true; else if (comparator.compare(current.data, object) < 0) return findnodeandremove(current.left, object); else return findnodeandremove(current.right, object); Jan Lemeire Pag. 33 / 64

34 private Node<T> createsubtree(node<t> current){ if (current.left == null){ // current.right is the only subtree that we should consider return current.right; else if (current.right == null){ // current.left is the only subtree that we should consider return current.left; else { // promote rightmost node of left subtree if (current.left.right == null){ current.left.right = current.right; return current.left; else { Node<T> rightmostnode=pickrightmostnode(current.left); // he is new root of subtree rightmostnode.right = current.right; rightmostnode.left = current.left; return rightmostnode;

35 private Node<T> pickrightmostnode(node<t> current){ // we expect current.right not to be null if (current.right.right!= null){ return pickrightmostnode(current.right); else { Node<T> rightmostnode = current.right; current.right = rightmostnode.left; rightmostnode.left = null; return rightmostnode;

36 p Doorlopen van boom public void preorder(node<t> node){ if (node!= null){ System.out.print(node.data+", "); preorder(node.left); preorder(node.right); public void inorder(node<t> node){ if (node!= null){ inorder(node.left); System.out.print(node.data+", "); inorder(node.right); public void postorder(node<t> node){ if (node!= null){ postorder(node.left); postorder(node.right); System.out.print(node.data+", "); Zie boom van vorige les {k, g, a, e, c, f, i, l, x, q, r, z {a, c, e, f, g, i, k, l, q, r, x, z {c, f, e, a, i, g, r, q, z, x, l, k Jan Lemeire Pag. 36 / 64

37 = Boomrecursie Kan je niet op een eenvoudige manier met een while-lus Jan Lemeire Pag. 37 / 64

38 p. 75 Toepassing postorder public int aantalkinderen(node<t> node){ if (node == null) return 0; int n = aantalkinderen(node.left); n += aantalkinderen(node.right); System.out.println("Node "+node.data+" heeft "+n+" kinderen"); return n + 1; Jan Lemeire Pag. 38 / 64

39 Applets

40 Java applets Kan je toevoegen aan html-webpagina s <applet code="be.ac.vub.ir.util.jappletwithpanel archive="../causallearningwithkde.jar" height="360" width="900"> <param name="panel" value="be.ac.vub.ir.statistics.estimators.kde2dpanel" > </applet> Steek al je files in een jar-file In Eclipse: File menu -> export -> Java -> Jar file Je browser heeft een java-console waarin de System output komt (System.out & System.err) Jan Lemeire Pag. 42 / 64

41 Voorbeeld import javax.swing.japplet; public class CannonDemoApplet extends JApplet { public void init(){ String opt = getparameter("option"); if (opt!= null && opt.equals("ammo")) getcontentpane().add(new CannonPanel(true)); else getcontentpane().add(new CannonPanel(false)); Jan Lemeire Pag. 43 / 64

42 Opgelet Zorg dat beeldjes en audiofiles ook in de jar komen Zet ze bij je packages Laden van beeldjes: zie website Jan Lemeire Pag. 44 / 64

43 JApplet De browser communiceert met de applet via public void init( ) initializes variables and objects Voeg GUI componenten toe aan contentpane: getcontentpane().add() public void paint( Graphics g ) to draw screen public void start() called when the applet is visible. It is called after the init method and each time the applet is revisited in a Web page. public void stop() called when applet is no longer visible public void destroy() when hosting window is closed (exit). Overschrijf methodes als nodig Jan Lemeire Pag. 45 / 64

44 AVL-bomen

45 Waarom bomen? Linked lists: gemiddelde zoektijd = n/2 Perfect-gebalanceerde boom log 2 n 3/4 Niet (log 2 n)/2, de helft van de nodes ligt immers in diepste laag! Echter: tijdrovend gebalanceerd te houden bij het toevoegen/verwijderen van nodes Wat als niet-perfect gebalanceerd? Er tussen in AVL-bomen Logaritmisch of lineair? Jan Lemeire Pag. 47 / 64

46 p. 76 AVL-bomen Gedefinieerd door twee Russische mathematici, Adelson-Velskii & Landis Beschouwen enkel de hoogte van deze subbomen De hoogte van de linkersubboom mag niet meer dan een niveau verschillen van de hoogte van de rechtersubboom Jan Lemeire Pag. 48 / 64

47 Voorbeeld 3/4 2/2 3/3 1/1 1/0 2/2 2/0 0/0 0/0 0/0 1/0 1/0 1/1 Jan Lemeire Pag. 49 / 64

48 Herbalanceren 3/4 2/2 3/3 1/1 1/0 2/2 1/1 0/0 0/0 0/0 1/0 1/0 0/0 0/0 Jan Lemeire Pag. 50 / 64

49 p. 77 Hoogte van subboom class Node<T>{ T data; Node<T> left, right; int hoogte=0; Node(T data){ this.data = data; left = null; right = null; public String tostring(){ return data.tostring()+"("+hoogte+")"; Jan Lemeire Pag. 51 / 64

50 Hoogte berekenen protected void berekenhoogte(node<t> node){ int nrechts = node.right == null? 1 : 1 + node.right.hoogte; int nlinks = node.left == null? 1 : 1 + node.left.hoogte; node.hoogte = Math.max(nRechts, nlinks); Jan Lemeire Pag. 52 / 64

51 public void add(t object){ Node<T> newnode = new Node<T>(object); if (root == null) root = newnode; else add(root, newnode); berekenhoogte(root); private void add(node<t> current, Node<T> newnode){ if (comparator.compare(newnode.data, current.data) < 0){ // moet links komen if (current.left == null) current.left = newnode; else add(current.left, newnode); else { // rechts if (current.right == null) current.right = newnode; else add(current.right, newnode); // herbereken hoogte berekenhoogte(current);

52 p. 78 Consistent houden Hoogte moet steeds correct blijven Herberekenen wanneer nodig Encapsulatie kan dit waarborgen: Alle aanpassingen van boom gebeuren via methodes Cf getters en setters De methodes garanderen de consistentie van de gegevens Jan Lemeire Pag. 54 / 64

53 p. 79 Het opbouwen van een AVL-boom Nodes worden toegevoegd Indien niet aan de AVL-voorwaarde voldaan: herschikken van de boom 2 situaties + symmetrisch geval tov A: A A B B Buitenwaarts onevenwicht Binnenwaarts onevenwicht Jan Lemeire Pag. 55 / 64

54 Herschikking buitenaards onevenwicht A B B A Herschikking van een buitenwaarts onevenwicht Jan Lemeire Pag. 56 / 64

55 Herschikking binnenwaarts onevenwicht A C B C B A Herschikking van een binnenwaarts onevenwicht Jan Lemeire Pag. 57 / 64

56 p. 80 AVLTree klasse Subklasse van BinaryTree! Overschrijven van add om AVL-voorwaarde te bestendigen public class AVLTree<T> extends BinaryTree<T> { public AVLTree(Comparator<T> comparator) { super(comparator); Jan Lemeire Pag. 58 / 64

57 Imbalans berekenen // negatief is imbalans naar links private int imbalance(node<t> links, Node<T> rechts){ int nrechts = rechts == null? 0 : 1 + rechts.hoogte; int nlinks = links == null? 0 : 1 + links.hoogte; return nrechts - nlinks; Jan Lemeire Pag. 59 / 64

58 p Programmatie van de public void add(t object){ Node<T> newnode = new Node<T>(object); root = addavl(root, newnode); // Node wordt toegevoegd en nieuwe topnode wordt teruggegeven (deze kan veranderen) private Node<T> addavl(node<t> current, Node<T> newnode){ if (current == null) return newnode; if (comparator.compare(newnode.data, current.data) < 0){ // moet links komen Wat als current.left = addavl(current.left, newnode); we dit weglaten? // check for imbalance Node teruggeven is van belang else { // rechts current.right = addavl(current.right, newnode); // check for imbalance Jan Lemeire Pag. 60 / 64

59 Outer imbalance left // check for imbalance int imbalans = imbalance(current.left, current.right); if (imbalans < -1){ if (comparator.compare(newnode.data, current.left.data) < 0){ System.out.println("When adding "+newnode.data+" outer imbalance at left of "+current.data); // if added left: outer imbalance Node<T> A = current; // zie tekening van cursus Node<T> B = current.left; A.left = B.right; // in de goede volgorde!! B.right = A; current = B; // dit is de nieuwe topnode van subboom berekenhoogte(a); berekenhoogte(b); else { Jan Lemeire Pag. 61 / 64

60 Inner imbalance left else { System.out.println("When adding "+newnode.data+" inner imbalance at left of "+current.data); // if added right: inner imbalance Node<T> A = current; // zie tekening van cursus Node<T> B = current.left; Node<T> C = B.right; A.left = C.right; // in de goede volgorde!! B.right = C.left; C.right = A; C.left = B; current = C; // dit is de nieuwe topnode van subboom berekenhoogte(a); berekenhoogte(b); berekenhoogte(c); Jan Lemeire Pag. 62 / 64

61 else { // rechts toevoegen right: identiek current.right = addavl(current.right, newnode); // check for imbalance int imbalans = imbalance(current.left, current.right); if (imbalans > 1){ if (comparator.compare(newnode.data, current.right.data) > 0){ System.out.println("When adding "+newnode.data+" outer imbalance at right of "+current.data); // if added right: outer imbalance else { System.out.println("When adding "+newnode.data+" inner imbalance at right of "+current.data); // if added left: inner imbalance // spiegelbeeld van vorige berekenhoogte(current); return Informatica current; II: les 9 Jan Lemeire Pag. 63 / 64

62 p. 84 Zoektijd in AVL-bomen Meest-ongebalanceerde AVL-boom (worst case) Diepe boom met weinig nodes, maar toch AVL N(h) het minimum aantal nodes voor een hoogte h N(1)=1 en N(2) = 2 ( fibonacci) Er geldt: Dus: OK!! logaritmisch in n! Jan Lemeire Pag. 64 / 64