Samenvattingen · InformaticaNL · HAVO

Domein E: Architectuur

Domein E gaat over de bouw van een computer: hoe processor, geheugen en invoer/uitvoer via de bus samenwerken tot één rekenmachine die programma's uitvoert. Je leert de von-neumann-architectuur en het opgeslagen-programma-principe, volgt de fetch-decode-execute-cyclus in de processor, doorziet waarom geheugen in lagen is geordend, en krijgt een globaal beeld van wat een besturingssysteem doet en hoe computers in lagen met elkaar communiceren. Architectuur is een kerndomein van het schoolexamenvak informatica.

4 Onderdelen~25 min leestijd4 VaardighedenNiveau Basis 1 · Standaard 2 · Verdieping 1

T·0555 / 12

Examenprofiel

De von-neumann-architectuur beschrijven: de functie van de processor (met ALU en besturingseenheid), het werkgeheugen, de invoer/uitvoer en de bus, en het opgeslagen-programma-principe en het von-neumann-knelpunt uitleggen.De fetch-decode-execute-cyclus stap voor stap beschrijven en met de kloksnelheid (Hz/GHz) de duur van een kloktik en de orde van grootte van het aantal instructies per seconde berekenen.De geheugenhiërarchie uitleggen vanuit de afruil tussen snelheid, grootte en kosten, vluchtig van niet-vluchtig geheugen onderscheiden en beredeneren waarom een cache werkt.De kerntaken van een besturingssysteem benoemen, de basis van multitasking met procestoestanden uitleggen en globaal beschrijven hoe gelaagde netwerkcommunicatie met protocollen werkt.

Operatoren:leg uitbeschrijfberekenberedeneervergelijkpas toe

basisniveau

Zorg dat je de vaste onderdelen (processor met ALU en besturingseenheid, geheugen, invoer/uitvoer, bus), de drie stappen van de instructiecyclus, de lagen van de geheugenhiërarchie en de kerntaken van een besturingssysteem uit het hoofd kunt benoemen en in een eenvoudig schema kunt plaatsen.

verhoogd niveau

Redeneer in onbekende contexten met de architectuur: verklaar het von-neumann-knelpunt, reken met kloksnelheid en geheugengroottes, beredeneer keuzes in de geheugenhiërarchie en leg uit hoe het besturingssysteem en gelaagde netwerkcommunicatie samenwerken.

Diepte

Tekst

Inhoud · 4 onderdelen

Domein E: Architectuur

Von-neumann-architectuur#

Basisexamenblad-nl

Von-neumann-architectuur

Afb. 1De von-neumann-architectuur: processor, geheugen en invoer/uitvoer zijn via de gedeelde bus met elkaar verbonden; de ALU en de besturingseenheid zitten in de processor.

Computerarchitectuur beschrijft uit welke bouwstenen een computer bestaat en hoe die samenwerken tot één apparaat dat berekeningen uitvoert. Vrijwel elke digitale computer — van een smartphone tot een server — volgt hetzelfde basisplan, dat naar de wiskundige John von Neumann de von-neumann-architectuur heet. Dit plan kent vier vaste onderdelen: de processor of CPU, die rekent en de machine aanstuurt; het werkgeheugen, dat instructies en gegevens tijdelijk bewaart; de invoer- en uitvoerapparaten, waarmee de computer met de buitenwereld communiceert; en de bus, het stelsel van verbindingen waarlangs alle informatie tussen die onderdelen reist. Wie deze vier onderdelen begrijpt, kan van elke computer navertellen hoe een taak van toetsenbord tot scherm door de machine stroomt.

De processor is het rekenend en sturend hart van de computer en bestaat zelf uit twee samenwerkende delen. Het eerste is de rekenkundig-logische eenheid, in het Engels de ALU (Arithmetic Logic Unit): die voert de eigenlijke bewerkingen uit — optellen, aftrekken, vergelijken, en logische bewerkingen zoals EN, OF en NIET. Het tweede is de besturingseenheid (control unit): die rekent zelf niet, maar leest de instructies van een programma en stuurt op grond daarvan alle andere onderdelen aan. De besturingseenheid bepaalt dus welke bewerking de ALU moet doen, welke gegevens uit het geheugen gehaald worden en waar het resultaat naartoe gaat. Je kunt de ALU zien als de rekenaar en de besturingseenheid als de dirigent die de partituur — het programma — leest en iedereen op het juiste moment laat spelen.

Het werkgeheugen bewaart tijdens het werken zowel de instructies van het programma als de gegevens waarmee dat programma rekent. Juist dat is de kern van von Neumanns idee: het opgeslagen-programma-principe. Vroege rekenmachines moesten voor elke nieuwe taak fysiek worden omgebouwd of opnieuw bedraad. Von Neumann bedacht dat je het programma net als gewone gegevens als getallen in hetzelfde geheugen kunt opslaan. Daardoor kan één machine elk programma uitvoeren dat je erin laadt, zonder haar bouw te veranderen — precies wat een computer zo veelzijdig maakt. Het werkgeheugen is een lange rij genummerde plekken; elk nummer heet een adres, en de processor gebruikt dat adres om gericht een instructie of een getal op te halen of weg te schrijven.

De invoer- en uitvoerapparaten (I/O) verbinden de computer met de buitenwereld. Invoerapparaten zoals toetsenbord, muis en sensoren brengen gegevens naar binnen; uitvoerapparaten zoals scherm, luidspreker en printer geven resultaten naar buiten, en sommige apparaten (een netwerkkaart, een aanraakscherm) doen allebei. Al die onderdelen zijn verbonden door de bus: een bundel elektrische lijnen die als een gedeelde snelweg werkt. Men onderscheidt drie soorten lijnen: de databus, waarover de eigenlijke gegevens gaan; de adresbus, waarmee de processor aangeeft welke geheugenplek hij bedoelt; en de besturingsbus, die regelt óf er gelezen of geschreven wordt. Hoeveel geheugen een processor rechtstreeks kan aanspreken, hangt af van de breedte van de adresbus: met

n

adreslijnen zijn er

2^n

verschillende adressen.

De keuze om instructies én data door hetzelfde geheugen en over dezelfde bus te laten lopen, heeft één belangrijk nadeel: het von-neumann-knelpunt (de bottleneck). Omdat de processor voor elke stap zowel de instructie als de bijbehorende gegevens over diezelfde bus moet ophalen, kan er per keer maar één ding tegelijk door. De processor is bovendien meestal veel sneller dan het geheugen, en daardoor staat hij vaak te wachten tot de volgende instructie of het volgende getal binnen is — de bus is dan de flessenhals. Dit knelpunt verklaart waarom computers zoveel moeite doen om het geheugen bij te laten benen: snelle tussengeheugens (cache), bredere bussen en slimme processortrucs zijn allemaal manieren om de processor minder te laten wachten. Het is geen ontwerpfout maar een gevolg van het eenvoudige, veelzijdige von-neumann-ontwerp.

2^{n}\text{ adressen}

Adresruimte van de adresbus

Met een adresbus van $n$ lijnen kan de processor $2^{n}$ verschillende geheugenplaatsen aanspreken. Bij $n = 32$ zijn dat $2^{32} \approx 4{,}3 \times 10^{9}$ adressen, oftewel ongeveer 4 gigabyte direct adresseerbaar geheugen.

Uitgewerkt voorbeeld

Twee getallen optellen — welke onderdelen doen wat?

Een programma telt twee getallen op die al in het werkgeheugen staan en toont de uitkomst op het scherm. Benoem stap voor stap welke onderdelen van de von-neumann-architectuur betrokken zijn en hoe de gegevens over de bus stromen.

Instructie ophalen
De besturingseenheid vraagt via de adresbus de volgende instructie ('tel op') op. Die instructie reist van het werkgeheugen over de databus naar de processor; de besturingsbus geeft aan dat het om lezen gaat.
Instructie decoderen
De besturingseenheid ontcijfert de opgehaalde instructie en bepaalt dat de ALU een optelling moet doen en op welke twee geheugenadressen de getallen staan.
Gegevens ophalen
De processor zet de adressen van de twee getallen op de adresbus; de getallen komen via de databus uit het werkgeheugen naar de registers in de processor.
Uitvoeren
De ALU telt de twee getallen bij elkaar op. Het resultaat blijft eerst in een register in de processor staan.
Resultaat wegschrijven en tonen
Het resultaat gaat via de databus terug naar het werkgeheugen of rechtstreeks naar de invoer/uitvoer: het scherm zet het via de bus aangeleverde getal om in beeld.

Resultaat: De besturingseenheid regisseert, de ALU rekent, het werkgeheugen levert en bewaart de getallen, en alle gegevens reizen over de bus (adres-, data- en besturingslijnen) tussen processor, geheugen en invoer/uitvoer.

Veelgemaakte fouten

De ALU en de besturingseenheid door elkaar halen. De ALU rekent (optellen, vergelijken, logische bewerkingen); de besturingseenheid rekent niet maar leest instructies en stuurt de andere onderdelen aan.
Denken dat een programma 'in de processor' zit. Het programma staat als instructies in het werkgeheugen; de processor haalt ze daar één voor één op via de bus.
Het werkgeheugen (RAM) verwarren met de harde schijf of SSD. Het werkgeheugen bewaart wat de computer nú gebruikt en is vluchtig; de schijf bewaart bestanden ook als de stroom eraf is.

Actieve herhaling

Teken de von-neumann-architectuur met de processor (met ALU en besturingseenheid), het geheugen en de invoer/uitvoer, verbonden door de bus. Leg met dit schema uit wat het opgeslagen-programma-principe inhoudt, en beschrijf in eigen woorden wat het von-neumann-knelpunt is en waarom het ontstaat.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Processor en instructiecyclus#

Standaardexamenblad-nl

De fetch-decode-execute-cyclus

Afb. 2De instructiecyclus als kringloop: na uitvoeren telt de programmateller op en begint de processor opnieuw bij ophalen.

De processor voert een programma niet in één keer uit, maar instructie voor instructie, en voor elke instructie doorloopt hij steeds dezelfde drie stappen. Die vaste rondgang heet de fetch-decode-execute-cyclus, oftewel de ophalen-decoderen-uitvoeren-cyclus. In de eerste stap, fetch (ophalen), haalt de besturingseenheid de volgende instructie uit het werkgeheugen. In de tweede stap, decode (decoderen), ontcijfert zij wat die instructie precies betekent: welke bewerking moet gebeuren en met welke gegevens. In de derde stap, execute (uitvoeren), laat zij de bewerking daadwerkelijk uitvoeren — meestal door de ALU — en wordt het resultaat opgeslagen. Daarna begint de cyclus opnieuw met de volgende instructie. Deze eenvoudige lus, miljarden keren per seconde herhaald, is alles wat een computer 'doet'.

Om deze cyclus snel te laten verlopen, heeft de processor een handvol piepkleine, razendsnelle geheugenplaatsen vlak bij de rekeneenheid: de registers. Registers bewaren de getallen waarmee de processor op dít moment werkt — de twee getallen die opgeteld worden, een tussenresultaat, een adres. Eén register is bijzonder: de programmateller (de program counter). Die onthoudt het adres van de volgende instructie die opgehaald moet worden, en telt na elke fetch automatisch één op, zodat de processor vanzelf naar de volgende instructie doorschuift. Bij een sprong-instructie — door een keuze of een herhaling in het programma — wordt de programmateller op een ander adres gezet; zo bepaalt hij de volgorde waarin het programma wordt afgewerkt. Zonder de programmateller zou de processor niet weten waar hij gebleven was.

De stappen van de cyclus mogen niet door elkaar lopen; ze worden strak op de maat gehouden door de systeemklok. De klok is een elektronisch onderdeel dat een gestaag ritme van pulsen afgeeft — tik, tik, tik — en bij elke tik zet de processor een volgende deelstap. Het aantal tikken per seconde heet de kloksnelheid en wordt gemeten in hertz (Hz): 1 Hz is één tik per seconde. Moderne processoren tikken miljarden keren per seconde, en daarom rekenen we in gigahertz (GHz): 1 GHz is

10^9

tikken per seconde. Een processor van 3 GHz geeft dus drie miljard klokpulsen per seconde. Hoe hoger de kloksnelheid, hoe meer stappen de processor per seconde kan zetten, en dus — bij verder gelijke bouw — hoe sneller hij is. De duur van één tik is het omgekeerde van de frequentie: bij 3 GHz duurt één tik

1/(3 \times 10^9) \approx 0{,}33

nanoseconde.

Een processor begrijpt geen Python of andere programmeertaal; hij begrijpt alleen zijn eigen machinetaal: een beperkte lijst heel eenvoudige instructies die elk als een patroon van bits in het geheugen staan. Zulke machine-instructies zijn bewust simpel: haal een getal uit het geheugen, sla een getal op, tel twee registers op, vergelijk twee waarden, spring naar een ander adres. Elke instructie bestaat meestal uit een opdrachtdeel (welke bewerking) en een of meer operanden (met welke gegevens of adressen). Een programma in een hogere taal wordt vóór of tijdens het uitvoeren vertaald naar duizenden van deze kleine stappen. Dat de computer ze zó snel achter elkaar zet, is precies waarom hij ingewikkelde taken aankan: de kracht zit niet in één complexe stap, maar in het tempo en de herhaling.

Met de kloksnelheid kun je de orde van grootte schatten van het aantal instructies dat een processor per seconde verwerkt. In het eenvoudigste model kost één eenvoudige instructie ongeveer één kloktik, dus verwerkt een processor van 2,5 GHz in de buurt van

2{,}5 \times 10^9

— 2,5 miljard — eenvoudige instructies per seconde. In werkelijkheid is dat een ruwe schatting: sommige instructies kosten meer tikken, terwijl moderne processoren juist meerdere instructies tegelijk in bewerking hebben (pijplijnen) en meerdere kernen bezitten die parallel werken. Toch is de kloksnelheid daarom nog steeds een bruikbare eerste maat: ze vertelt in welke grootteorde de machine rekent, en ze maakt duidelijk waarom het von-neumann-knelpunt zo knelt — een processor die miljarden keren per seconde een getal nodig heeft, mag niet te lang op het tragere geheugen wachten.

T = \dfrac{1}{f}

Duur van één kloktik

De periodetijd $T$ (de duur van één kloktik) is het omgekeerde van de kloksnelheid $f$ . Bij $f = 2{,}5$ GHz $= 2{,}5 \times 10^9$ Hz is $T = 1/(2{,}5 \times 10^9) \approx 0{,}4$ nanoseconde.

1\ \text{GHz} = 10^{9}\ \text{Hz}

Kloksnelheid in gigahertz

Eén gigahertz staat voor één miljard klokpulsen per seconde. Zo is 2,5 GHz gelijk aan $2{,}5 \times 10^9$ tikken per seconde.

Uitgewerkt voorbeeld

Instructies per seconde bij 2,5 GHz

Een processor draait op 2,5 GHz. Bereken hoeveel kloktikken hij per seconde geeft, hoe lang één tik duurt, en schat hoeveel eenvoudige instructies hij per seconde ongeveer aankan als één instructie ongeveer één tik kost. Beschrijf daarna één instructiecyclus stap voor stap.

Kloksnelheid omzetten
$2{,}5$ GHz $= 2{,}5 \times 10^9$ Hz. De processor geeft dus $2{,}5 \times 10^9 = 2\,500\,000\,000$ kloktikken per seconde, oftewel 2,5 miljard tikken per seconde.
Duur van één tik
$T = 1/f = 1/(2{,}5 \times 10^9) = 0{,}4 \times 10^{-9}$ s $= 0{,}4$ nanoseconde per tik.
Instructies per seconde schatten
Kost één eenvoudige instructie ongeveer één tik, dan verwerkt de processor in de orde van $2{,}5 \times 10^9$ instructies per seconde: ongeveer 2,5 miljard. Dit is een schatting van de grootteorde, geen exact getal.
Eén cyclus: ophalen
Fetch — de besturingseenheid haalt via het adres in de programmateller de volgende instructie uit het geheugen; de programmateller telt daarna één op.
Decoderen en uitvoeren
Decode — de besturingseenheid ontcijfert de instructie. Execute — de ALU voert de bewerking uit (bijvoorbeeld de optelling) en het resultaat komt in een register; daarna begint de cyclus opnieuw.

Resultaat: Bij 2,5 GHz: $2{,}5 \times 10^9$ tikken per seconde, $0{,}4$ ns per tik, en in de orde van 2,5 miljard eenvoudige instructies per seconde — elk via de vaste rondgang ophalen → decoderen → uitvoeren.

Veelgemaakte fouten

De volgorde van de cyclus omdraaien. Het is altijd eerst ophalen (fetch), dan decoderen (decode), dan uitvoeren (execute) — niet eerst uitvoeren.
Denken dat een hogere kloksnelheid altijd een snellere computer betekent, ook tussen verschillende processortypen. Snelheid hangt óók af van het aantal kernen, pijplijnen, de cache en hoeveel tikken een instructie kost.
Hertz verwarren met een hoeveelheid gegevens. Hertz telt gebeurtenissen per seconde (tikken/s); 2,5 GHz betekent 2,5 miljard tikken per seconde, niet 2,5 miljard bytes.

Actieve herhaling

Een processor heeft een kloksnelheid van 2,0 GHz. (a) Hoeveel kloktikken geeft hij per seconde? (b) Hoe lang duurt één tik? (c) Als een eenvoudige instructie gemiddeld één tik kost, ongeveer hoeveel van zulke instructies verwerkt hij dan per seconde? Beschrijf ten slotte in eigen woorden wat er in de drie stappen van de instructiecyclus gebeurt bij de instructie 'tel twee getallen op'.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Geheugenhiërarchie#

Standaardexamenblad-nl

Geheugenhiërarchie

Afb. 3Van boven naar beneden: hoe hoger in de hiërarchie, hoe sneller, kleiner en duurder het geheugen. Registers, cache en RAM zijn vluchtig; SSD en harde schijf niet.

Een computer zou het snelst werken als al zijn geheugen even snel was als de registers in de processor. Dat kan niet, en de reden is een afruil (een trade-off) tussen drie eigenschappen die je niet tegelijk maximaal kunt hebben: snelheid, grootte en kosten. Geheugen dat razendsnel is, is per byte duur en daardoor in de praktijk klein; geheugen dat goedkoop en dus groot kan zijn, is traag. Omdat je én snelheid én een grote capaciteit wilt, lossen computers dit op met een geheugenhiërarchie: een aantal lagen geheugen, van heel klein en heel snel bovenaan tot heel groot en traag onderaan. De processor werkt zoveel mogelijk met de snelle bovenlagen en gebruikt de trage onderlagen alleen voor wat daar niet in past. Zo benadert het geheel de snelheid van de snelle lagen én de omvang van de grote lagen.

Van boven naar beneden bestaat de hiërarchie uit vier hoofdlagen. Bovenaan staan de registers: een handjevol geheugenplaatsen ín de processor, zo snel dat de ALU er direct mee rekent, maar samen niet meer dan enkele tientallen tot honderden bytes. Daaronder ligt het cachegeheugen: klein (enkele kilobytes tot megabytes) en zeer snel, dat vlak bij of in de processor zit en kopieën bewaart van veelgebruikte gegevens uit het werkgeheugen. Nog lager ligt het werkgeheugen of RAM (Random Access Memory): een stuk groter (gigabytes) en van gemiddelde snelheid; hier staan de draaiende programma's en hun gegevens. Onderaan ligt de secundaire opslag — de harde schijf (HDD) of solid-state drive (SSD) — die zeer groot is (honderden gigabytes tot terabytes) en goedkoop per byte, maar veel trager dan het werkgeheugen. Zie de tabel hiernaast.

Een tweede belangrijk onderscheid loopt dwars door de hiërarchie heen: dat tussen vluchtig en niet-vluchtig geheugen. Vluchtig geheugen (volatile) bewaart zijn inhoud alleen zolang er stroom op staat; zodra de computer uitgaat, is alles weg. De registers, de cache en het werkgeheugen zijn allemaal vluchtig — daarom is een niet-opgeslagen document verdwenen na een stroomstoring. Niet-vluchtig geheugen (non-volatile) houdt zijn inhoud ook zonder stroom vast; de harde schijf en de SSD zijn niet-vluchtig, en daarom blijven je bestanden, foto's en programma's bewaard als je de computer uitzet. Dit verklaart de vaste werkwijze van een computer: bij het opstarten worden het besturingssysteem en de programma's vanuit de trage, niet-vluchtige opslag in het snelle, vluchtige werkgeheugen geladen; bij het opslaan gaat het resultaat weer terug naar de niet-vluchtige opslag.

Dat een kleine, snelle cache toch grote winst oplevert, komt door een verschijnsel dat lokaliteit heet: programma's gebruiken hun gegevens niet willekeurig, maar geconcentreerd. Bij tijdslokaliteit gebruikt een programma een gegeven dat het net gebruikt heeft waarschijnlijk snel weer — denk aan een teller in een lus. Bij plaatslokaliteit gebruikt het na een gegeven vaak de buurgegevens — denk aan het rij voor rij doorlopen van een lijst. Hier speelt de computer op in: vraagt de processor iets uit het werkgeheugen op, dan bewaart hij een kopie ervan én van de buren in de cache. De volgende keer staat het gevraagde er waarschijnlijk al (een 'cache hit') en hoeft de trage rit naar het werkgeheugen niet gemaakt te worden. Doordat lokaliteit in bijna alle programma's voorkomt, werkt een kleine cache verrassend vaak — en verzacht ze het von-neumann-knelpunt uit het eerste onderwerp.

De geheugenhiërarchie is dus geen toevallige stapel maar een bewust ontwerp dat de sterke kanten van elke laag combineert. Elke laag dient als een snelle buffer voor de laag eronder: de cache vangt het werkgeheugen op, het werkgeheugen vangt de schijf op. Gegevens schuiven omhoog wanneer ze nodig zijn en zakken weer omlaag wanneer er lang niet naar gevraagd is. Voor jou als gebruiker is het geheel onzichtbaar: je merkt alleen dat de computer meestal snel reageert (de gegevens zaten in een bovenlaag) en soms even hapert (er moest iets uit een tragere laag komen). Het ontwerpprincipe is algemeen en kom je overal in de informatica tegen: houd wat je vaak en snel nodig hebt dicht bij de hand in een klein, snel geheugen, en bewaar de grote massa verder weg in een groot, goedkoop geheugen.

Uitgewerkt voorbeeld

Van snel naar langzaam ordenen — en waarom niet alleen registers

Rangschik de geheugensoorten harde schijf, register, RAM, cache en SSD van snel naar langzaam. Beredeneer daarna waarom een computer niet volledig uit (het snelste) registergeheugen is opgebouwd.

Ordenen op snelheid
Van snel naar langzaam: register → cache → RAM (werkgeheugen) → SSD → harde schijf. Dit is precies de volgorde van boven naar beneden in de geheugenhiërarchie.
De afruil benoemen
Snelheid gaat gepaard met hoge kosten per byte en kleine capaciteit. Registers zijn het snelst, maar samen slechts enkele tientallen tot honderden bytes groot en per byte extreem duur.
Waarom niet alleen registers
Een programma en zijn gegevens beslaan al gauw vele megabytes tot gigabytes. Dat past onmogelijk in de paar honderd bytes registergeheugen, en geheugen ter grootte van gigabytes volledig zo snel én zo duur maken zou onbetaalbaar zijn.
De oplossing
Daarom combineert de computer een klein beetje supersnel geheugen (registers, cache) met veel goedkoop, trager geheugen (RAM, schijf), zodat het geheel bijna zo snel voelt als de bovenlaag maar zo groot is als de onderlaag.

Resultaat: Volgorde snel → langzaam: register, cache, RAM, SSD, harde schijf. Alleen registers gebruiken kan niet, want ze zijn te klein en te duur voor de gigabytes aan programma en data; de hiërarchie verenigt snelheid en capaciteit tegen aanvaardbare kosten.

Veelgemaakte fouten

Cache en RAM verwisselen. Cache is kleiner, sneller en zit dichter bij de processor; RAM (werkgeheugen) is groter en trager, maar nog altijd veel sneller dan de schijf.
Denken dat RAM niet-vluchtig is. Registers, cache én RAM zijn vluchtig: hun inhoud verdwijnt zonder stroom. Alleen de schijf of SSD houdt gegevens vast als de computer uit is.
'Meer opslag' gelijkstellen aan 'snellere computer'. Een grotere harde schijf maakt een computer niet sneller; meer of sneller werkgeheugen en cache doen dat wel.

Actieve herhaling

Zet de geheugensoorten register, harde schijf (HDD), werkgeheugen (RAM), SSD en cache in volgorde van snel naar langzaam. Geef bij elke soort aan of hij vluchtig of niet-vluchtig is, en beredeneer in enkele zinnen waarom een computer niet gewoon volledig uit registers is opgebouwd.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Besturingssysteem en netwerklagen (globaal)#

Verdiepingexamenblad-nl

Bestandssysteem

Afb. 4Een bestandssysteem is een boom van mappen en bestanden; het gemarkeerde pad leidt van de hoofdmap naar het bestand verslag.docx.

Tussen de kale hardware en de programma's die jij gebruikt, zit een bijzonder stuk software: het besturingssysteem (in het Engels het operating system, kortweg OS). Voorbeelden zijn Windows, macOS, Linux, Android en iOS. Zonder besturingssysteem zou elk programma zelf de processor moeten verdelen, het geheugen moeten beheren en elk apparaat rechtstreeks moeten aansturen — ondoenlijk en onveilig. Het besturingssysteem neemt dat werk over: het beheert alle onderdelen van de von-neumann-architectuur namens de programma's, verdeelt de beschikbare middelen eerlijk en biedt de programma's een nette, uniforme manier om diensten aan te vragen (een systeemaanroep, in het Engels een system call). Zo hoeft een tekstverwerker niet te weten of jij een SSD of een harde schijf hebt: hij vraagt het besturingssysteem om een bestand, en dat regelt de rest.

Een besturingssysteem heeft een aantal duidelijk te onderscheiden kerntaken. Procesbeheer verdeelt de processortijd over de draaiende programma's en beslist met een planning (scheduling) welk programma wanneer aan de beurt is. Geheugenbeheer houdt bij welk programma welk deel van het werkgeheugen gebruikt en zorgt dat programma's elkaars geheugen niet beschadigen. Het bestandssysteem ordent de gegevens op de opslag in mappen en bestanden, zodat jij en de programma's ze op naam terugvinden in plaats van op ruwe schijfadressen. Apparaatbeheer stuurt via stuurprogramma's (drivers) de invoer- en uitvoerapparaten aan. En de gebruikersinterface laat jou de computer bedienen, met vensters en pictogrammen of via getypte opdrachten. Al deze taken samen maken van een verzameling chips een bruikbare computer.

De taak die op het schoolexamen het vaakst terugkomt, is procesbeheer. Een proces is een programma dat nu draait, samen met alles wat daarbij hoort: zijn instructies, zijn gegevens in het geheugen en de stand van zijn programmateller. Een moderne computer heeft er tegelijk tientallen tot honderden, terwijl één processorkern in werkelijkheid maar één ding tegelijk kan doen. De illusie dat alles tegelijk loopt — multitasking — ontstaat doordat het besturingssysteem razendsnel tussen de processen wisselt: het geeft elk proces een piepklein plakje processortijd en schakelt dan door. Daarbij doorloopt een proces verschillende toestanden: nieuw (net gestart), gereed (klaar om te rekenen, wachtend op een beurt), lopend (nu aan het rekenen), wachtend (opgehouden tot bijvoorbeeld een bestand van de schijf binnen is) of klaar (afgelopen). Dat voortdurend verschuiven tussen die toestanden is precies wat scheduling doet.

Computers staan tegenwoordig zelden alleen; ze wisselen gegevens uit over netwerken. Omdat communicatie tussen apparaten ingewikkeld is, is ze — net als de rest van de informatica — opgeknipt in lagen: het idee van gelaagde netwerkcommunicatie. Elke laag heeft één duidelijke taak en praat alleen met de laag direct erboven en eronder. Onderaan zorgt een laag voor het fysieke transport van bits over een kabel of via radiogolven; daarboven zorgt een laag dat de gegevens de juiste computer bereiken (adressering en routering); nog hoger zorgt een laag dat ze betrouwbaar en compleet aankomen; en bovenaan werken de toepassingen die jij gebruikt, zoals het web en e-mail. Binnen elke laag gelden vaste afspraken — protocollen — die precies vastleggen hoe apparaten elkaars berichten opbouwen en begrijpen; bekende voorbeelden zijn IP, TCP en HTTP. Door die gelaagdheid kun je één laag vervangen (wifi door een kabel) zonder de rest aan te passen.

Dat een netwerk in lagen is opgebouwd, is niet toevallig hetzelfde idee als de geheugenhiërarchie en de opdeling van de computer in samenwerkende onderdelen: gelaagdheid en het verdelen van werk over gespecialiseerde delen zijn dé manier waarop de informatica onbeheersbare complexiteit beheersbaar maakt. Elke laag mag erop vertrouwen dat de laag eronder haar werk doet, en hoeft alleen haar eigen taak te kennen. Deze globale kijk — het besturingssysteem dat de machine namens jou beheert, en de netwerklagen die communicatie in behapbare stukken knippen — is precies de opstap naar het keuzethema Netwerken, waar je deze lagen, adressen en protocollen in detail leert kennen. Voor domein E volstaat het dat je de kerntaken van een besturingssysteem kunt benoemen en het nut van gelaagde communicatie met protocollen globaal kunt uitleggen.

Uitgewerkt voorbeeld

Wat gebeurt er als je een bestand opent?

Je dubbelklikt in de verkenner op het bestand verslag.docx om het in een tekstverwerker te openen. Leg stap voor stap uit welke taken van het besturingssysteem daarbij in actie komen.

Gebruikersinterface
De grafische gebruikersinterface merkt je dubbelklik op en zet die om in een verzoek aan het besturingssysteem: 'open dit bestand' (een systeemaanroep).
Bestandssysteem
Het bestandssysteem zoekt via de mapstructuur (/gebruikers/anna/documenten/verslag.docx) op waar de gegevens van het bestand fysiek op de schijf staan, en controleert dat het bestand bestaat en dat je leesrechten hebt.
Apparaatbeheer en driver
Apparaatbeheer vraagt via het stuurprogramma (de driver) van de SSD of harde schijf de betreffende blokken op. Omdat schijftoegang traag is, zet het besturingssysteem het proces zolang in de toestand 'wachtend'.
Geheugenbeheer
Zodra de gegevens binnen zijn, plaatst geheugenbeheer ze in een stuk werkgeheugen (RAM) van de tekstverwerker, meestal via de cache; het proces wordt weer 'gereed' en daarna 'lopend'.
Weergeven
De tekstverwerker leest de gegevens uit het werkgeheugen en geeft, opnieuw via de gebruikersinterface en het scherm, de inhoud van verslag.docx weer.

Resultaat: Vrijwel elke kerntaak doet mee: de gebruikersinterface neemt het verzoek aan, het bestandssysteem lokaliseert het bestand en bewaakt de rechten, apparaatbeheer haalt de gegevens van de opslag, geheugenbeheer zet ze in het RAM, en procesbeheer schuift het proces van 'wachtend' naar 'lopend' — waarna het bestand op je scherm verschijnt.

Veelgemaakte fouten

Het besturingssysteem verwarren met een gewoon programma of met de hardware. Het OS is de laag software tússen de hardware en jouw programma's; het beheert de machine namens die programma's.
Denken dat één processorkern echt meerdere programma's tegelijk uitvoert. Bij multitasking wisselt het besturingssysteem alleen zó snel tussen processen dat het gelijktijdig lijkt.
Een map of bestand voor 'de opslag zelf' aanzien. Mappen en bestanden zijn de ordening die het bestandssysteem oplegt; de gegevens staan als blokken op de SSD of harde schijf.

Actieve herhaling

Noem vier kerntaken van een besturingssysteem en beschrijf elk in één zin. Leg vervolgens uit wat er stap voor stap gebeurt — en welke OS-taken daarbij in actie komen — vanaf het moment dat je een bestand opent tot het op je scherm verschijnt.

Actief ophalen

Haal de kernpunten op — onthul ze daarna.

Bronnen: Examenprogramma informatica (HAVO) (CvTE / Examenblad)

Referenties en bronnen

Bronnen

CvTE / Examenblad

Examenprogramma informatica (HAVO)

Domein E: Architectuur

4 Onderdelen~25 min leestijd4 VaardighedenNiveau Basis 1 · Standaard 2 · Verdieping 1

Domein E: Architectuur

Kernpunten

Twee getallen optellen — welke onderdelen doen wat?

Kernpunten

Instructies per seconde bij 2,5 GHz

Kernpunten

Van snel naar langzaam ordenen — en waarom niet alleen registers

Kernpunten

Wat gebeurt er als je een bestand opent?

Bronnen

Domein E: Architectuur

Kernpunten

Twee getallen optellen — welke onderdelen doen wat?

Kernpunten

Instructies per seconde bij 2,5 GHz

Kernpunten

Van snel naar langzaam ordenen — en waarom niet alleen registers

Kernpunten

Wat gebeurt er als je een bestand opent?

Bronnen