Hoe computers werken

Een computer ontvangt invoer, volgt instructies om die te verwerken, slaat gegevens op en produceert uitvoer. Deze functies gelden voor een laptop en voor een besturing die verborgen zit in een wasmachine. Het verschil zit in de taak en de aangesloten apparatuur.

Fysieke onderdelen en programma’s

Hardware is de fysieke apparatuur. Software bestaat uit programma’s en de gegevens waarmee ze werken. De CPU is de processorchip, niet de hele computerbehuizing. Een moederbord verbindt de CPU met RAM, opslag, een GPU, de voeding en apparaatpoorten. De GPU verzorgt het tekenen en ander werk waarbij vergelijkbare bewerkingen op veel waarden worden toegepast. Een telefoon combineert veel van deze functies in een systeem op een chip (SoC).

RAM bevat instructies en gegevens die op dat moment worden gebruikt. Een opslagstation bewaart programma’s en opgeslagen bestanden zonder stroom. Bij een computer met 16 GB geheugen en een SSD van 512 GB beschrijft de eerste capaciteit het RAM en de tweede de opslag. Een groter opslagstation levert niet meer werkgeheugen op.

Een programma opgeslagen als gegevens

De Von Neumann-architectuur heeft een CPU, hoofdgeheugen dat zowel instructies als gegevens bevat, invoer- en uitvoerapparaten en bussen die ze verbinden. John von Neumann beschreef dit ontwerp in het “First Draft of a Report on the EDVAC” uit 1945. Het centrale idee is het opgeslagen programma: instructies zijn binaire waarden in het geheugen, klaar om door de CPU te worden opgehaald.

Eerdere machines zoals ENIAC werden met schakelaars en kabels voor taken ingesteld. Door een nieuw programma te laden kan een computer met opgeslagen programma van taak veranderen zonder de bedrading aan te passen. De Manchester Baby voerde op 21 juni 1948 een programma uit in herschrijfbaar elektronisch geheugen.

Het geheugen kent niet aan elk patroon een betekenis toe. De byte 01000001 kan het getal 65, de ASCII-letter “A” of een deel van een instructie voorstellen. Wat de CPU of het programma met het patroon doet, bepaalt de betekenis. Bij het ophalen van een instructie behandelt de CPU het opgehaalde patroon als instructie.

Waarom de processor moet wachten

Instructies en gegevens delen de route tussen de CPU en het hoofdgeheugen. Het geheugen levert ze bovendien langzamer dan de CPU ze kan gebruiken. Deze beperking is het Von Neumann-knelpunt. Een snelle processor kan daardoor tijd kwijt zijn met wachten op de volgende waarde. Kleine, snelle caches bewaren bruikbare kopieën dicht bij de CPU en beperken veel van deze wachttijden.

Kleine microcontrollers en signaalprocessoren gebruiken vaak een Harvard-ontwerp. Moderne CPU’s voor algemeen gebruik combineren de ideeën: gedeeld hoofdgeheugen, maar afzonderlijke niveau 1-caches voor instructies en gegevens.

Computers in andere apparaten

Een ingebed systeem voert een specifieke taak uit binnen een groter apparaat. Een thermostaat leest een temperatuursensor, verwerkt de meetwaarde en regelt de verwarming. Het opgeslagen programma blijft meestal in niet-vluchtig geheugen staan. De functies van processor, geheugen en invoer en uitvoer zijn nog steeds aanwezig, ook zonder toetsenbord, scherm of volledig desktopbesturingssysteem.

Een processor heeft drie dingen nodig om het geheugen te gebruiken: een locatie, de over te dragen waarde en een commando dat het geheugen vertelt wat het moet doen. Als je deze functies uit elkaar houdt, kun je een busoverdracht veel gemakkelijker volgen.

Drie functies op een klassieke systeembus

Een bus is een gedeeld communicatiepad. In een klassieke parallelle systeembus dragen verschillende draden of printsporen tegelijk bits.

Een adres duidt een locatie aan; het is niet de waarde die daar is opgeslagen. Adres 200 kan vandaag 7 bevatten en later 9, zonder dat het adres verandert. Een bruikbare vergelijking is een genummerde brievenbus: het nummer duidt de bus aan, terwijl de inhoud kan veranderen.

Volg een lees- en een schrijfbewerking

Om adres 200 te lezen, zet de CPU 200, binair 11001000, op de adresbus en stuurt een leescommando over de besturingsbus. Het geheugen geeft de waarde op die locatie, hier 7, terug via de databus. De CPU kopieert die naar een register.

Om 9 naar adres 201 te schrijven, zet de CPU 201 op de adresbus, 9 op de databus en een schrijfcommando op de besturingsbus. Het geheugen vervangt de inhoud van locatie 201. Als 201 over de databus zou worden gestuurd, zou de verkeerde waarde worden verstuurd; het adres en de inhoud hebben verschillende functies.

De adresbreedte begrenst het aantal locaties

Met $n$ adresbits zijn er $2^n$ verschillende adressen. Als elk adres één byte aanduidt, is dat ook het aantal adresseerbare bytes.

• 16 bits geven $2^{16}=65.536$ adressen, oftewel 64 KiB.
• 32 bits geven $2^{32}=\mathrm{4.294.967.296}$ adressen, oftewel 4 GiB.
• Een toename van 20 naar 21 bits verdubbelt de capaciteit van 1 MiB naar 2 MiB.

Elk extra bit verdubbelt het aantal combinaties. Als je het aantal bits verdubbelt van 16 naar 32, wordt het aantal locaties vermenigvuldigd met $2^{16}$; het verdubbelt niet alleen. Deze berekening geeft een adresseringslimiet, niet de hoeveelheid RAM die werkelijk is geïnstalleerd.

De databreedte begrenst elke overdracht

Een 64-bitsdatapad draagt 8 bytes in één overdracht. Een 8-bitspad heeft vier overdrachten nodig om een waarde van 4 bytes over te brengen. Bandbreedte meet hoeveel gegevens per seconde kunnen worden verplaatst:

Bij 1 miljard overdrachten per seconde draagt een pad van 8 bytes 8 miljard bytes per seconde, oftewel 8 GB/s. De adresbreedte bepaalt hoeveel locaties kunnen worden aangeduid; de databreedte bepaalt hoeveel tegelijk wordt verplaatst.

Het woord van een CPU is de natuurlijke werkgrootte, meestal 32 of 64 bits. Een 64-bitsprocessor vereist niet dat elke verbinding 64 draden heeft. Het geïmplementeerde adresbereik kan ook minder dan 64 bits gebruiken.

Moderne verbindingen behouden dezelfde functies

Geheugenkanalen, PCI Express en USB vervangen één gedeelde bus door meerdere verbindingen. PCI Express en USB zijn serieel: bits reizen na elkaar over snelle draadparen. Adressen, waarden en commando’s worden in berichten verpakt. Ze duiden nog steeds een bestemming aan, dragen inhoud en coördineren de overdracht.

Een invoerapparaat levert gegevens; een uitvoerapparaat presenteert een resultaat of zet het om in een handeling. De indeling beschrijft de rol van het apparaat in het systeem. Ze beschrijft niet hoe ingewikkeld het apparaat vanbinnen is.

Deel in naar de handeling

Toetsenborden, camera’s, microfoons, barcodescanners en sensoren leveren invoer. Schermen, printers, luidsprekers en actuatoren leveren uitvoer. Een actuator verandert iets fysieks, bijvoorbeeld door een klep te openen of een motor te laten draaien.

Sommige apparaten doen beide. Een touchscreen registreert aanrakingen en toont beelden. Een headset combineert een microfoon met luidsprekers. Een netwerkadapter verstuurt en ontvangt gegevens. Opslagstations voeren ook lees- en schrijfbewerkingen uit via invoer-uitvoercontrollers, maar hun belangrijkste doel is gegevens bewaren. Daarom vormen ze de afzonderlijke categorie secundaire opslag.

Een printer kan een processor bevatten die een pagina omzet in afdrukbare punten. De printer blijft een uitvoerapparaat vanwege wat die voor de computer doet. Een draadloze muis levert net als een muis met kabel invoer.

Zet continue signalen om in getallen

Geluid en temperatuur veranderen continu: het zijn analoge signalen. Een analoog-digitaalomzetter (ADC) meet een signaal met regelmatige tussenpozen en codeert de samples als getallen. Een digitaal-analoogomzetter (DAC) zet digitale waarden om in analoge uitvoer, zoals het signaal dat een luidspreker aanstuurt.

Voor één audiokanaal dat 44.100 keer per seconde wordt bemonsterd met 16 bits per sample:

Dit is de ruwe gegevenssnelheid van de samples. Elke seconde bevat 44.100 metingen en elke meting heeft 16 bits nodig. Door bemonsteren en coderen kan een computer de opname opslaan en verwerken.

Hardwarecontroller, softwarestuurprogramma

Apparaten verbinden via poorten of draadloze verbindingen zoals USB, HDMI, Bluetooth of wifi. Een apparaatcontroller is een schakeling die communicatie op laag niveau afhandelt en registers beschikbaar stelt die de CPU kan lezen of beschrijven. Een apparaatstuurprogramma is software die verzoeken van het besturingssysteem vertaalt naar commando’s voor het apparaat. De controller is hardware; het stuurprogramma is software.

Laat apparaten aandacht vragen

Bij polling controleert de processor herhaaldelijk een statusregister. Dit is eenvoudig, maar een apparaat dat meestal niets doet, kan veel controles zonder nuttig resultaat veroorzaken.

Bij een interrupt geeft de controller een signaal wanneer aandacht nodig is. In het eenvoudige model van de instructiecyclus voltooit de CPU de huidige instructie, bewaart de onderbroken toestand en voert een interruptafhandelaar uit. Daarna herstelt de CPU de bewaarde toestand en gaat verder. Een toetsaanslag of een voltooide leesbewerking van een schijf kan deze reeks in gang zetten.

Mensen en veel apparaten handelen veel langzamer dan een CPU. Een persoon typt slechts enkele tekens per seconde, terwijl een processor miljarden instructies per seconde kan uitvoeren. Interrupts laten de CPU tussen gebeurtenissen door werken.

Bij een grote overdracht laat directe geheugentoegang (DMA) een apparaat of DMA-controller een blok rechtstreeks naar of vanuit RAM verplaatsen. De CPU bereidt de bewerking voor en werkt aan iets anders. Een interrupt bij voltooiing laat de CPU weten wanneer het blok klaar is. Door DMA hoeft de CPU niet elke byte te kopiëren; de CPU blijft wel betrokken bij het regelen en afronden van de overdracht.

De kleinste bewerkingen van een computer komen voort uit circuits die schakelen tussen twee signaalniveaus. Een hoge spanning stelt 1 voor en een lage spanning 0. Deze niveaus staan voor bits; een chip herkent de betekenis van een foto of een zin niet.

Poorten zetten invoerbits om in uitvoer

Een transistor werkt als een elektronisch bestuurde schakelaar. Kleine groepen vormen logische poorten, elk met een vaste regel voor invoer en uitvoer. Een waarheidstabel vermeldt elke invoercombinatie en de bijbehorende uitvoer. Bij twee ingangen zijn er vier combinaties; in het algemeen zijn voor $n$ ingangen $2^n$ rijen nodig.

NIET keert de enkele invoerwaarde om. De poorten met twee ingangen werken als volgt:

EN vereist dat beide invoerwaarden 1 zijn. OF vereist minstens één, waarbij beide ook mogelijk zijn. XOR vereist verschillende invoerwaarden. NAND keert EN om; NOR keert OF om. Als je OF leest als “één maar niet allebei”, verwar je die met XOR.

Om (A AND B) OR (NOT C) uit te rekenen voor A = 1, B = 0, C = 0, werk je vanaf de ingangen naar buiten. A AND B geeft 0. NOT C geeft 1. Ten slotte geeft 0 OR 1 de waarde 1. Schrijf de tussenliggende uitvoerwaarden op, zodat de laatste poort de juiste invoer krijgt.

Poorten tellen binaire cijfers op

Een halve opteller ontvangt twee bits. De somuitvoer is XOR en de overdrachtsuitvoer is EN. Bij twee invoerwaarden 1 is het sombit 0 en het overdrachtsbit 1: het resultaat van twee bits is 10, oftewel 2.

Een volledige opteller ontvangt ook een overdracht uit de vorige kolom. Door deze circuits te koppelen kan een ALU langere getallen optellen. Volg 0110 plus 0011 vanaf rechts:

1. De meest rechtse kolom geeft 1, zonder overdracht.
2. De volgende kolom heeft twee 1’en: schrijf 0 en draag 1 over.
3. De volgende heeft 1, 0 en overdracht 1: schrijf 0 en draag 1 over.
4. De meest linkse heeft 0, 0 en overdracht 1: schrijf 1.

Het resultaat is 1001, oftewel 9. Een overdracht hoort bij de volgende kolom; als je die weglaat, verandert de waarde.

Poorten kunnen een bit bewaren

Terugkoppeling betekent dat de uitvoer van een circuit wordt teruggeleid naar de invoer. Kruislings gekoppelde NAND- of NOR-poorten vormen een latch die één bit bewaart zolang de stroom aanstaat. Een flipflop neemt een nieuw bit op bij een klokflank, zodat de veranderingen synchroon lopen met de klok van de processor. Registers gebruiken opslagcircuits die door de klok worden gestuurd. SRAM-cachecellen gebruiken latchachtige circuits; DRAM slaat lading op in condensatoren.

NAND en NOR zijn elk universeel: met elk poorttype afzonderlijk kun je elke logische functie bouwen. Als je beide NAND-ingangen met A verbindt, krijg je A NAND A, wat werkt als NIET A.

Dit zijn abstractielagen. Transistors vormen poorten; poorten vormen optellers, registers en besturingscircuits; die vormen een processor die instructies uitvoert. Een programmeur kan de instructielaag gebruiken zonder de schakelaars daaronder te ontwerpen.

De CPU, of processor, voert de instructies van een programma uit. De besturingseenheid stuurt het werk aan, de rekenkundige en logische eenheid voert bewerkingen uit en de registers bevatten de waarden die direct nodig zijn. Een klok coördineert veranderingen in deze circuits.

Het werk aansturen en uitvoeren

De besturingseenheid haalt een instructie op, decodeert die en geeft besturingssignalen af. Ze kan het geheugen bijvoorbeeld opdracht geven een waarde terug te sturen, twee invoerwaarden voor de ALU selecteren en een register inschakelen om het resultaat op te slaan. De besturingseenheid coördineert de bewerking; de ALU voert de rekenkundige of logische bewerking uit.

Tot de ALU-bewerkingen behoren optellen, aftrekken, vergelijken, bitverschuivingen en bewerkingen met poorten zoals EN en XOR. Resultaten werken ook statusvlaggen bij. Een nulvlag geeft een resultaat van nul aan; een negatiefvlag legt een negatief resultaat vast. Een vertakking kan een vlag controleren om de volgende instructie te kiezen.

Registers bewaren de directe werktoestand

Registers zijn zeer kleine, snelle opslaglocaties in de processor. Een algemeen register bevat meestal één woord. Zo biedt x86-64 16 algemene registers voor gehele getallen en 64-bits ARM 31. Programma’s gebruiken die om waarden dicht bij de ALU te houden.

De processor uit het leerboek maakt de volgende functies zichtbaar:

Het MDR wordt ook het geheugenbufferregister (MBR) genoemd. Het CIR wordt ook het instructieregister (IR) genoemd. Echte chips organiseren deze taken op complexere manieren, maar met het model kun je volgen hoe een instructie en de bijbehorende gegevens zich verplaatsen.

De PC bevat een adres, geen totaal van voltooide instructies. Een sprong kan de PC terugsturen om een lus te herhalen. MAR en MDR verschillen ook: een adres zoals 10 gaat in het MAR; de waarde op adres 10 gaat in het MDR.

Een klokcyclus is één tijdstap

De klokfrequentie telt pulsen per seconde en wordt gemeten in hertz (Hz). Een klok van 3 GHz produceert 3 miljard cycli per seconde. De duur van één cyclus is:

Een puls laat delen van een circuit een stap verder gaan. Sommige instructies hebben meerdere tijdstappen nodig en moderne processoren laten het werk aan meerdere instructies overlappen.

Meer dan één processorkern

Een processorkern beschikt over de besturing, rekeneenheid, registers en cache die nodig zijn om een instructiestroom uit te voeren. Vier kernen kunnen vier stromen tegelijk uitvoeren. Een programma heeft daar voordeel van als het werk over de kernen kan worden verdeeld; alleen al het hebben van vier kernen splitst niet elke taak op.

Een GPU heeft veel kleinere verwerkingseenheden die geschikt zijn om vergelijkbare bewerkingen op veel gegevens tegelijk uit te voeren. Pixels tekenen, video verwerken en sommige berekeningen voor machinaal leren hebben deze vorm. Een CPU is geschikt voor een bredere combinatie van instructies en beslissingen.

Denk aan een keuken: de besturingseenheid verdeelt de taken, de ALU voert ze uit, registers bevatten ingrediënten die direct voorhanden zijn en het geheugen levert meer. De CPU volgt bitpatronen mechanisch; de bruikbare betekenis komt van het programma.

De instructiecyclus laat de onderdelen van de processor samenwerken om een programma uit te voeren. Elke cyclus haalt een instructie op, bepaalt de bewerking en voert die uit. Een doorloop legt de veranderingen in registers en geheugen vast, zodat de oorzaak van elk resultaat zichtbaar wordt.

Haal de instructie op

In de eenvoudige processor verloopt het ophalen als volgt:

1. Kopieer de PC naar het MAR.
2. Zet het adres op de adresbus en stuur een signaal om het geheugen te lezen.
3. Ontvang de instructie via de databus in het MDR.
4. Kopieer de instructie naar het CIR.
5. Verhoog de PC naar de volgende instructie.

In de leermachine neemt elke instructie één locatie in, dus gaat de PC met 1 omhoog. Een processor met adressering per byte verhoogt de PC met de lengte van de instructie in bytes. Tijdens de uitvoering wijst de PC al voorbij de opgehaalde instructie.

Decodeer en voer uit

De besturingseenheid scheidt de operatiecode, die de bewerking aangeeft, van de operand, die een waarde, register of adres levert. Daarna stuurt de besturingseenheid de signalen die nodig zijn om de instructie uit te voeren. Een laadinstructie leest gegevens, een optelinstructie gebruikt de ALU, een opslaginstructie schrijft gegevens en een sprong verandert de PC. Sommige beschrijvingen noemen het wegschrijven van het resultaat een afzonderlijke fase: terugschrijven.

Doorloop een volledig programma

De leermachine heeft één accumulator. Hier gebruiken LOAD, ADD en STORE geheugenadressen als operanden.

Address  Instruction      Data address  Value
0        LOAD 10          10            7
1        ADD 11           11            5
2        STORE 12         12            0
3        HALT

Begin met PC 0. Door LOAD 10 op te halen gaat de PC naar 1. De uitvoering zet adres 10 in het MAR, leest 7 via het MDR en zet de ACC op 7. De operand 10 duidt een locatie aan; die is niet de geladen waarde.

Vervolgens wordt ADD 11 opgehaald en wordt de PC 2. Geheugenlocatie 11 levert 5. De ALU telt 7 en 5 op, zodat de ACC 12 bevat. Door STORE 12 op te halen gaat de PC naar 3. De uitvoering zet adres 12 in het MAR en waarde 12 in het MDR en schrijft daarna 12 naar die locatie. De ACC blijft 12. Ten slotte gaat de PC door het ophalen van HALT naar 4 en stopt de leermachine bij de uitvoering. Er zijn vier instructies uitgevoerd.

Vertakkingen vervangen het volgende adres

JUMP 0 zet tijdens de uitvoering 0 in de PC, ongeacht de vorige waarde. JUMPZ 6 springt alleen als de ACC nul is. Als die instructie van adres 4 is opgehaald, maakt het ophalen de PC eerst 5. De uitvoering zet de PC daarna op 6 als de ACC nul is; anders blijft de PC 5. Zo kan een reeks een route kiezen of een lus herhalen.

Interrupts en echte processoren

Op de grens tussen instructies controleert de CPU in dit model op interrupts. Om een interrupt af te handelen, bewaart de CPU de PC en andere werkregisters, voert de afhandelaar uit en herstelt daarna de bewaarde toestand. Het onderbroken programma gaat verder met de eigen waarden en het volgende adres.

Een CPU haalt niet een heel bronprogramma in één keer op. De CPU voert machine-instructies uit, vaak meerdere voor één instructie in de broncode. Moderne CPU’s laten intern werk overlappen en veranderen de volgorde, terwijl ze de vereiste resultaten van het programma behouden.

De prestaties van een processor hangen af van het werk dat een programma nodig heeft en hoe snel de computer dat werk voltooit. Klokfrequentie, nuttig werk per cyclus, wachttijd en mogelijkheden voor parallel werk spelen allemaal een rol.

Klokfrequentie en een vast aantal cycli

Voor een taak waarvoor een bekend aantal klokcycli nodig is:

Een taak die 6 miljard cycli nodig heeft, duurt 2 seconden bij 3 GHz en 1,5 seconde bij 4 GHz. In deze vergelijking blijft het aantal cycli gelijk. Bij verschillende processorontwerpen kan een programma een verschillend aantal cycli nodig hebben. Een chip van 3,5 GHz kan daarom beter presteren dan een chip van 4 GHz door meer nuttige instructies per cyclus te voltooien.

Hogere klokfrequenties gebruiken ook meer energie en produceren warmte. Thermische snelheidsbegrenzing verlaagt de klokfrequentie wanneer een processor te heet wordt. Dit helpt verklaren waarom prestatiewinst door meer komt dan het verhogen van het aantal gigahertz.

Processorkernen verdelen alleen het parallelle deel

Stel dat een taak op één processorkern 10 seconden duurt. Twee seconden moeten na elkaar worden uitgevoerd; acht seconden kunnen gelijkmatig over vier kernen worden verdeeld. Als we de overhead voor coördinatie buiten beschouwing laten:

Als je de hele 10 seconden door vier deelt, krijg je 2,5 seconde, maar dan verdeel je ten onrechte ook het sequentiële werk. Zelfs een onbeperkt aantal kernen kan die twee seconden niet wegnemen. Meerdere kernen helpen ook om afzonderlijke programma’s tegelijk te laten draaien, zelfs als elk programma maar één kern gebruikt.

Een pipeline laat fasen overlappen

In een pipeline met drie fasen wordt één instructie uitgevoerd terwijl de volgende wordt gedecodeerd en een andere wordt opgehaald. Elke instructie doorloopt nog steeds alle drie de fasen. De winst is dat er in een bepaalde tijd meer instructies worden voltooid.

Als elke fase één cyclus duurt, kosten tien onafhankelijke instructies zonder overlap 30 cycli. Een ideale pipeline heeft drie cycli nodig om de eerste instructie te voltooien en één extra voor elke resterende instructie:

Een vertakking kan al opgehaalde instructies onbruikbaar maken. Het weggooien van dat werk kost cycli, dus voorspellen processoren vertakkingen. Ook werkelijke afhankelijkheden en wachttijden voor het geheugen voorkomen dat een pipeline altijd de ideale snelheid haalt.

Blijf de processor voorzien

Een cache bewaart kopieën van instructies en gegevens dichtbij. Meer bruikbare cachecapaciteit kan het aantal keren dat RAM moet worden geraadpleegd verminderen, vooral wanneer een programma herhaaldelijk een werkverzameling gebruikt die eerder niet in de cache paste. Als die werkverzameling er al in past, helpt extra capaciteit mogelijk weinig.

De geheugenbandbreedte begrenst hoe snel veel waarden kunnen aankomen. De opslagsnelheid is van belang bij het openen van bestanden of starten van toepassingen: de overstap van een harde schijf naar een SSD kan de vertraging verminderen, ook al blijft de CPU gelijk. De woordgrootte en de instructies die een processor ondersteunt, beïnvloeden ook voor welke taken die geschikt is.

Meer transistors, andere toepassingen

De wet van Moore beschrijft de waarneming van Gordon Moore, voor het eerst gedaan in 1965 en herzien in 1975, dat het aantal transistors ongeveer elke twee jaar verdubbelde. Deze historische trend is geen regel dat programma’s volgens een vast schema twee keer zo snel worden. Nu het verkleinen van onderdelen is vertraagd, gebruiken chipontwerpers extra transistors voor processorkernen, caches, GPU’s en gespecialiseerde versnellers. Een bruikbare vergelijking kijkt naar de tijd die dezelfde taak onder dezelfde omstandigheden kost.

Machinecode bestaat uit binaire instructies voor een bepaald type processor. Assembleertaal schrijft die instructies met leesbare namen. Beide beschrijven bewerkingen die veel dichter bij de hardware liggen dan een hogere programmeertaal zoals Python of C.

Bewerkingen en operanden

Een instructie bevat een operatiecode die aangeeft wat er moet gebeuren en meestal één of meer operanden die aangeven wat moet worden gebruikt. Een operand kan een register of geheugenadres aanduiden of rechtstreeks een waarde leveren. De betekenis volgt uit de vastgelegde indeling van de instructie.

Bekijk een 8-bitscodering voor een leermachine. De eerste vier bits bevatten een operatiecode; de laatste vier een adres. Als LOAD gelijk is aan 0001, wordt LOAD 10 dan 0001 1010, omdat decimaal 10 binair 1010 is. Vier bits voor de operatiecode maken $2^4=16$ operatiecodes mogelijk. Vier adresbits duiden de locaties 0 tot en met 15 aan. Deze codering laat een beperkt formaat zien; de andere doorlopen van de leermachine gebruiken uitgeschreven instructies met grotere adressen.

Een instructiesetarchitectuur (ISA) definieert de instructies, coderingen en registers die een processor biedt. x86-64, ARM en RISC-V zijn voorbeelden. De A64-instructies van ARM zijn 32 bits lang; x86-64-instructies variëren van 1 tot 15 bytes. De woordgrootte van een 64-bitsprocessor bepaalt niet de lengte van elke instructie.

Een leesbare lus

Een assembler zet geheugensteuntjes en labels in assembleertaal om in machinecode voor een ISA. Nuttige instructiegroepen zijn gegevensoverdracht, rekenkundige en logische bewerkingen, besturing van de uitvoeringsvolgorde en systeem- of invoer-uitvoerbewerkingen.

Dit accumulatorprogramma telt af vanaf 3. SUB 21 trekt de inhoud van adres 21 af. JUMPZ vertakt als de ACC nul is.

0  LOAD 20
1  SUB 21
2  STORE 20
3  JUMPZ 5
4  JUMP 0
5  HALT

20 holds 3; 21 holds 1.

Bij de eerste doorgang leest LOAD 3, laat SUB 2 over en slaat STORE 2 op. De nulcontrole slaagt niet, dus start JUMP 0 een nieuwe doorgang. De tweede doorgang slaat 1 op en springt terug. De derde slaat 0 op, dus gaat JUMPZ 5 naar HALT.

De eerste twee doorgangen gebruiken elk vijf instructies. De laatste gebruikt er vier vóór HALT, dat ook als instructie meetelt: $5+5+4+1=15$. Als je alleen de zes geschreven regels telt, mis je de herhaalde uitvoeringen.

Eén broncode-instructie, meerdere instructies

Een instructie in een hogere programmeertaal zoals total = price + tax kan worden omgezet in bewerkingen om een waarde te laden, er een andere bij op te tellen en het resultaat op te slaan. Hogere programmeertalen drukken variabelen, keuzes, lussen en functies uit zonder elk register te noemen. In assembleertaal komt elke geschreven instructie meestal overeen met één machine-instructie en de taal is sterk afhankelijk van de ISA.

Machinecode voor x86-64 kan niet rechtstreeks als ARM-code worden uitgevoerd. De broncode kan opnieuw worden gecompileerd voor ARM of een vertaal- of emulatielaag kan het verschil opvangen.

RISC en CISC

RISC-ontwerpen zoals ARM en RISC-V geven de voorkeur aan eenvoudige, regelmatige instructies. Veel daarvan gebruiken instructies met een vaste lengte, maar RISC-V kan gecomprimeerde 16-bitsvormen combineren met standaard 32-bitsinstructies. CISC-ontwerpen zoals x86 bieden complexere instructies van variabele lengte. Moderne x86-processoren breken instructies op in eenvoudigere interne bewerkingen. Deze labels beschrijven ontwerpbenaderingen en garanderen niet dat de ene machine sneller is.

Broncode is leesbare programmatekst. Een processor voert machine-instructies uit, dus moet een hulpmiddel de kloof overbruggen. Compilatie en interpretatie beschrijven manieren om dat te doen; veel echte implementaties combineren ze.

De vertaalprogramma’s

De meeste compilers werken voordat een programma start. Een just-in-timecompiler (JIT) werkt tijdens de uitvoering. Een interpreter is zelf een machinecodeprogramma: de CPU voert de interpreter uit, die de bewerkingen van het bronprogramma uitvoert.

Volg de bouw van een C-programma

Het commando clang hello.c -o hello bouwt een uitvoerbaar bestand met de naam hello uit hello.c. Een bouwprogramma zoals make kan compilercommando’s voor de programmeur regelen. De belangrijkste fasen zijn:

1. Voorverwerking: verwerk richtlijnen zoals #include <stdio.h> en voeg daarmee declaraties uit headerbestanden toe aan de broncode.
2. Compileren: vertaal de C-code naar bewerkingen op het niveau van assembleertaal.
3. Assembleren: codeer die bewerkingen als machinecode in objectbestanden.
4. Linken: verbind objectcode en verwijzingen naar bibliotheken om een uitvoerbaar bestand te maken.

Headerbestanden beschrijven bibliotheekinterfaces; door een headerbestand op te nemen, wordt de gecompileerde implementatie van de bibliotheek niet vanzelf naar het programma gekopieerd. Linken verzorgt de verbinding met die code. Statisch linken kopieert de vereiste bibliotheekcode naar het uitvoerbare bestand. Dynamisch linken legt afhankelijkheden van gedeelde bibliotheken vast die worden geladen en gekoppeld wanneer dat nodig is.

Het uitvoerbare bestand is gericht op een ISA en een bestandsformaat van een besturingssysteem. Voor een ARM-Mac en een x86-64-Windows-computer zijn daarom afzonderlijke systeemeigen builds nodig. Ook na het wijzigen van de broncode moet je een gecompileerd uitvoerbaar bestand opnieuw bouwen voordat de wijziging effect heeft.

Fouten ontstaan in verschillende fasen

Een compiler kan syntaxisfouten melden, zoals een ontbrekende puntkomma in C, en typefouten waar de taal typen controleert. Een geslaagde compilatie bewijst niet dat het programma het juiste probleem oplost. Een logische fout levert een verkeerd resultaat op. Een uitvoeringsfout ontstaat terwijl het programma draait, bijvoorbeeld bij deling door een invoerwaarde die nul blijkt te zijn.

Een eenvoudige interpreter kan pas bij een fout aankomen nadat eerdere instructies zijn uitgevoerd. Python controleert eerst de syntaxis van een heel bestand, maar een niet-gedefinieerde naam kan nog steeds pas een fout opleveren wanneer de uitvoering die bereikt. De vertaalmethode alleen vertelt je niet wanneer elke soort fout wordt gevonden.

Bytecode en virtuele machines

Java compileert broncode naar bytecode, instructies voor de Java Virtual Machine (JVM). Elk ondersteund platform biedt een eigen JVM. Die kan bytecode interpreteren en veelgebruikte delen tijdens de uitvoering compileren naar de machinecode van de lokale CPU. De bytecode blijft overdraagbaar omdat de platformspecifieke JVM de hardwareverschillen afhandelt.

CPython compileert Python ook naar bytecode en voert die uit met een virtuele machine. PyPy gebruikt een JIT-compiler en JavaScript-engines in browsers gebruiken ook JIT-compilatie. “Gecompileerd” en “geïnterpreteerd” beschrijven implementaties, geen blijvende eigenschappen van een taal.

Vooraf gecompileerde systeemeigen code vermijdt meestal herhaald interpretatiewerk. Interpretatie maakt het handig om na een wijziging direct uit te voeren, terwijl bytecode en JIT overdraagbaarheid combineren met optimalisatie tijdens de uitvoering. Bij elke route volgt de CPU uiteindelijk machine-instructies en laadt het besturingssysteem de benodigde uitvoerbare code in het geheugen.

Het hoofdgeheugen bevat de instructies en gegevens die op dat moment voor de CPU beschikbaar zijn. Voor een gewone toepassing die op een SSD staat, brengt het besturingssysteem eerst de benodigde code en gegevens naar RAM. De CPU haalt vervolgens instructies op via het geheugen- en cachesysteem.

RAM, DRAM en SRAM

RAM is geheugen met directe toegang: een locatie kan worden bereikt zonder alle eerdere locaties te doorlopen. Gewoon RAM als werkgeheugen is vluchtig, dus de inhoud gaat zonder stroom verloren. Als je een document opslaat, worden de gegevens naar niet-vluchtige opslag gekopieerd.

Het hoofdgeheugen gebruikt DRAM, dat bits als lading in kleine condensatoren opslaat. De lading lekt weg, dus de cellen moeten worden ververst, meestal binnen een verversingsinterval van 64 ms. SRAM gebruikt latchachtige transistorcircuits die hun toestand behouden zolang er stroom is. Het hoeft niet te worden ververst, maar gebruikt meer ruimte en kost meer per bit. De snelheid maakt het geschikt voor processorcaches.

ROM, of alleen-lezengeheugen, is niet-vluchtig geheugen dat wordt gebruikt voor vaste instructies zoals firmware. Moderne UEFI- of BIOS-firmware staat normaal in bijwerkbaar flashgeheugen. De geadverteerde bestandscapaciteit van een telefoon is flashopslag, ook als een beschrijving die informeel “ROM” noemt; de telefoon schrijft er regelmatig bestanden naartoe.

Een byte heeft een adres

In per byte adresseerbaar geheugen duidt elk adres één byte aan. Een geheel getal van 4 bytes dat begint op decimaal adres 1000, bezet de locaties 1000, 1001, 1002 en 1003. De volgende ongebruikte locatie is 1004. Adressen worden vaak hexadecimaal geschreven, zoals 0x7FFE0010, omdat hexadecimale notatie bitpatronen compact weergeeft.

Het adres geeft aan waar bytes te vinden zijn. Het getal lezen dat als adres is geschreven, is iets anders dan de waarde lezen die op dat adres is opgeslagen.

Capaciteitseenheden gebruiken twee systemen

Een byte bevat 8 bits. Een kleine letter b betekent bits; een hoofdletter B betekent bytes.

Een station dat als 1 TB wordt verkocht, bevat ${10}^{12}$ bytes. In GiB is het aantal:

Sommige besturingssystemen geven dit binaire aantal weer met het label “GB”. Het andere getal volgt uit de grootte van de eenheid; het is geen bewijs dat er ruimte ontbreekt.

Capaciteit verschilt van processorsnelheid

Met meer RAM kunnen meer draaiende programma’s en gegevens tegelijk gereed blijven. Wanneer werkgegevens de capaciteit van RAM overschrijden, kan het besturingssysteem pagina’s naar de opslag verplaatsen, waardoor de toegang langzamer wordt. Extra RAM helpt bij dat tekort, maar verhoogt de klokfrequentie van de CPU niet. Opgeslagen bestanden verwijderen maakt opslagruimte vrij. Programma’s of tabbladen die je niet nodig hebt sluiten, kan werkgeheugen vrijmaken.

Secundaire opslag bewaart programma’s en bestanden zonder stroom. Vergeleken met RAM biedt die meer capaciteit tegen lagere kosten per byte, maar met langzamere toegang. Verschillende opslagtechnieken bieden verschillende afwegingen tussen snelheid, kosten, draagbaarheid en duurzaamheid.

Harde schijven en SSD’s

Een harde schijf (HDD) bewaart magnetische patronen op ronddraaiende schijven. Een bewegende kop zoekt het juiste spoor en wacht daarna tot het gewenste deel van de schijf eronderdoor draait. Beide bewegingen vergroten de toegangsvertraging.

Bij 7.200 omwentelingen per minuut duurt één omwenteling:

De gemiddelde wachttijd door het draaien is een halve omwenteling, ongeveer 4,2 ms. Dit is alleen het deel door het draaien, niet de volledige leestijd; zoeken en overdragen kosten ook tijd. Bewegende onderdelen maken een werkende harde schijf ook kwetsbaar voor schokken.

Een SSD bewaart lading in flashcellen en heeft geen bewegende onderdelen. Kleine leesbewerkingen op willekeurige plaatsen duren tientallen microseconden in plaats van de milliseconden die gebruikelijk zijn bij toegang tot een harde schijf. SSD’s zijn stil, bestand tegen schokken en geschikt voor draagbare computers. Harde schijven bieden bij grote verzamelingen doorgaans lagere kosten per terabyte.

Flashcellen verdragen een beperkt aantal wis- en schrijfcycli. De controller gebruikt slijtagespreiding om schrijfbewerkingen over de cellen te verdelen. USB-sticks, geheugenkaarten en telefoonopslag gebruiken ook flashgeheugen, al beïnvloeden de controller en interface hun prestaties.

Optische schijven en magneetband

Gebruikelijke capaciteiten zijn ongeveer 700 MB voor een cd, 4,7 GB voor een enkellaags-dvd en 25 GB voor een enkellaagse Blu-ray-schijf. Optische media zijn draagbaar, maar traag vergeleken met moderne opslagstations.

Magneetband biedt lage kosten voor grote archieven. Door de sequentiële toegang moet het station spoelen om een ver verwijderd bestand te bereiken. Harde schijven en SSD’s bieden directe toegang: ze bereiken een gekozen locatie zonder alle eerdere gegevens te doorlopen. Magneetband is daardoor geschikter voor geplande grote reservekopieën dan voor een toepassing die herhaaldelijk verspreide kleine bestanden opent.

Cloudopslag is een dienst

Cloudopslag bewaart bestanden op apparatuur in de datacenters van een aanbieder. De onderliggende media zijn nog steeds SSD’s, harde schijven of magneetband. Een netwerkverbinding voegt toegangs- en overdrachtsvertraging toe. De dienst biedt delen, toegang op afstand en kopieën op een andere locatie, met terugkerende kosten en afhankelijkheid van de toegangscontrole en betrouwbaarheid van de aanbieder.

Houd rekening met de beperkende factor

Toegangstijd is de vertraging voordat gegevens beginnen aan te komen. Overdrachtssnelheid meet hoe snel ze daarna worden overgebracht. Bij het lezen van veel kleine bestanden treedt de toegangsvertraging telkens opnieuw op; bij één groot aaneengesloten bestand speelt de overdrachtssnelheid een grotere rol.

Een SSD is geschikt voor de actieve programma’s van een laptop. Harde schijven zijn geschikt voor een server die 20 TB aan video voordelig opslaat. Magneetband of een cloudarchief is geschikt voor bedrijfsgegevens die langdurig worden bewaard, terwijl een USB-stick handig is om bestanden mee te nemen. Kies op basis van capaciteit, toegangstijd, overdrachtssnelheid, kosten per byte, stroomverbruik, betrouwbaarheid en draagbaarheid. Doordat een SSD uit chips is gemaakt, wordt die nog geen RAM als werkgeheugen: het blijft niet-vluchtige opslag achter een opslagcontroller.

Een computer combineert verschillende soorten opslag omdat snelle toegang, grote capaciteit en lage kosten niet samen in één techniek voorkomen. De geheugenhiërarchie plaatst een kleine hoeveelheid zeer snelle opslag dicht bij de CPU en grotere, langzamere opslag verder weg.

De niveaus van de hiërarchie

Van snelst en kleinst naar langzamer en groter zijn de belangrijkste niveaus registers, L1/L2/L3-cache, RAM, SSD, harde schijf en archiefopslag. De kosten per byte dalen doorgaans naarmate de capaciteit groeit.

Deze tijden tonen de orde van grootte, niet één vaste specificatie voor elk apparaat. Als je uitgaat van 1 ns voor L1, 100 ns voor RAM en 10 ms voor een harde schijf, duurt toegang tot RAM ongeveer 100 keer zo lang als toegang tot L1 en toegang tot de harde schijf ongeveer 100.000 keer zo lang als toegang tot RAM.

Treffers, missers en bruikbare kopieën

Een cache van de CPU gebruikt SRAM om blokken te bewaren die uit het hoofdgeheugen zijn gekopieerd. Hardware doorzoekt de cacheniveaus voordat gegevens uit RAM worden opgehaald. Bij een treffer wordt de gevraagde inhoud in de cache gevonden. Bij een misser moeten gegevens van een langzamer niveau worden opgehaald en kan een kopie in de cache worden geplaatst.

Het trefferpercentage is het aantal treffers gedeeld door alle toegangen. Bij 950 treffers op 1.000 toegangen is dat 95%. Een misser betekent niet dat gegevens ontbreken of beschadigd zijn; het betekent dat de snelle kopie niet beschikbaar was.

Waarom eerdere toegang toekomstige toegang voorspelt

Temporele lokaliteit betekent dat onlangs gebruikte inhoud waarschijnlijk binnenkort opnieuw wordt gebruikt. Een lus leest herhaaldelijk een teller en de eigen instructies. Ruimtelijke lokaliteit betekent dat adressen in de buurt waarschijnlijk binnenkort worden gebruikt. Het lezen van opeenvolgende lijstelementen volgt dit patroon.

Een cache haalt een hele cachelijn binnen, meestal 64 aangrenzende bytes, en maakt zo gebruik van ruimtelijke lokaliteit. Meerdere niveaus brengen capaciteit en zoektijd in evenwicht: één enorme cache zou meer tijd kosten om te doorzoeken.

Bereken de gemiddelde vertraging

Stel dat een cachecontrole 1 ns duurt en een RAM-toegang 100 ns. Een misser kost beide, dus duurt 101 ns. Bij een trefferpercentage van 95%:

Bij een trefferpercentage van 80%:

Het tweede gemiddelde is $21÷6=\mathrm{3,5}$ keer zo groot. Weeg de volledige kosten van een treffer en een misser naar hoe vaak elk voorkomt. Als je de cachecontrole bij een misser vergeet, verandert het antwoord van dit model.

Caching buiten de processor

Het besturingssysteem bewaart bestandsinhoud in RAM als cache. Een browser bewaart gedownloade webbestanden op de opslag als cache en contentdistributienetwerken bewaren kopieën dicht bij gebruikers. Ze hergebruiken allemaal kopieën dichtbij om herhaald langzaam ophalen te voorkomen. Als je een browsercache wist, verwijder je browserbestanden; je wist daarmee geen CPU-cachecircuits. CPU-caches bevatten kleine geheugenblokken, geen georganiseerde bibliotheek van volledige documenten.

Een besturingssysteem beheert hardware en levert diensten aan toepassingen. Windows, macOS en Linux worden gebruikt op pc’s en servers; Android en iOS op mobiele apparaten. Het zichtbare bureaublad is slechts één onderdeel van dit werk.

Beheer systeembronnen en verberg hardwaredetails

Als beheerder van systeembronnen wijst het besturingssysteem processortijd, werkgeheugen, bestanden en apparaten toe aan programma’s en gebruikers. Als abstractie biedt het eenvoudigere bewerkingen die hardwaredetails verbergen. Een teksteditor kan vragen om “open het bestand report.txt” zonder schijfsporen of apparaatcommando’s te kiezen.

Via de gebruikersinterface kunnen mensen om dit werk vragen. Een grafische gebruikersinterface (GUI) gebruikt vensters, pictogrammen, menu’s en aanraking of een aanwijzer. Een opdrachtregelinterface (CLI) accepteert getypte commando’s. Commando’s zoals ls op Linux en macOS of dir op Windows tonen bestanden; scripts kunnen commando’s combineren voor herhaalde taken.

De kernel beheert bewerkingen met speciale bevoegdheden

De kernel is de kern van het besturingssysteem die verantwoordelijk is voor de aansturing van hardware en beschermde systeembronnen. Toepassingen draaien in de gebruikersmodus met beperkte bevoegdheden. Kernelcode draait in de kernelmodus met meer bevoegdheden. Een toepassing vraagt een beschermde dienst aan via een systeemaanroep, bijvoorbeeld om het besturingssysteem een bestand te laten lezen.

De kernel controleert de toegangsrechten en voert de toegestane handeling uit. Een defecte toepassing kan niet zomaar met een gewone instructie in de gebruikersmodus de controle over elk apparaat overnemen of het beschermde geheugen van een ander proces lezen.

Verdeel processortijd

De procesplanner bepaalt welk gereedstaand programma processortijd krijgt. Door korte beurten op één verwerkingsstroom lijken muziek afspelen en een document bewerken tegelijk te gebeuren. Meerdere processorkernen maken het ook mogelijk om werk werkelijk op hetzelfde moment uit te voeren. Sommige CPU’s ondersteunen hardwarematige multithreading binnen een kern, maar tijd delen blijft nodig wanneer er meer werk klaarstaat dan de hardware tegelijk kan uitvoeren.

Geef bestanden namen en apparaten stuurprogramma’s

Een bestandssysteem houdt bestandsinhoud en metadata bij, zoals grootte, datums en toegangsrechten. Mappen vormen een hiërarchie; een pad duidt een bestand aan, bijvoorbeeld /home/sam/notes.txt op Linux. NTFS, APFS en ext4 zijn voorbeelden van bestandssystemen.

Als je een bestand verwijdert, wordt meestal de vermelding in de map verwijderd en komt de ruimte vrij voor hergebruik. Dat verschilt van het bewust overschrijven van elke byte. Oude gegevens zijn soms nog te herstellen, vooral op harde schijven; gewoon verwijderen garandeert niet dat gegevens veilig zijn gewist.

Een stuurprogramma vertaalt algemene apparaatverzoeken naar commando’s die een controller begrijpt. Standaardstuurprogramma’s handelen veel toetsenborden en USB-sticks af, terwijl sommige apparaten een specifiek stuurprogramma vereisen.

Deel software in naar functie

Het besturingssysteem, stuurprogramma’s en hulpprogramma’s zoals programma’s voor reservekopieën zijn systeemsoftware. Browsers, teksteditors, games en spreadsheetprogramma’s zijn toepassingssoftware. Mobiele systemen leggen de nadruk op batterijduur, aanraking en het scheiden van apps; servers ondersteunen netwerkdiensten. Een realtimebesturingssysteem voldoet aan vastgelegde reactietermijnen voor besturingstaken. Zeer eenvoudige ingebedde apparaten kunnen één programma uitvoeren zonder een volledig besturingssysteem.

Het starten van een computer en het starten van een toepassing omvatten verschillende fasen. Bij het opstarten krijgt het besturingssysteem de controle. Daarna ontstaat door het laden van een toepassing een draaiend proces dat de processor, het geheugen en diensten van het besturingssysteem gebruikt.

Begin met blijvende instructies

Bij het inschakelen bevat RAM als werkgeheugen geen bruikbaar draaiend programma. De CPU begint met firmware die in niet-vluchtig geheugen is opgeslagen. Op een moderne pc bereidt UEFI-firmware de hardware voor en voert opstartcontroles uit, vaak de zelftest bij het inschakelen (POST) genoemd. De firmware kiest een opstartapparaat en start een bootloader. De bootloader laadt de kernel van het besturingssysteem in RAM en draagt de besturing daaraan over. De kernel bereidt geheugenbeheer, stuurprogramma’s en diensten voor voordat het aanmeld- of startscherm verschijnt.

Maak van een programmabestand een proces

Een programma bestaat uit opgeslagen instructies. Een proces is een draaiend exemplaar, met geheugen, registertoestand en systeembronnen. Afzonderlijke exemplaren van één teksteditor kunnen afzonderlijke documenten bevatten, ook al zijn ze gestart vanuit hetzelfde programmabestand.

Om een toepassing te starten controleert het besturingssysteem het uitvoerbare bestand en het recht om het uit te voeren, maakt een adresruimte, laadt de code en gegevens die eerst nodig zijn, richt een stapelgeheugen in en stelt het adres van de startinstructie in. Meer pagina’s kunnen worden geladen zodra ze worden gebruikt. De procesplanner geeft het proces tijd op de CPU, die de machine-instructies van het proces uitvoert.

Verschillende gebieden bevatten verschillende inhoud

Een functie aanroepen voegt informatie toe aan het stapelgeheugen; bij terugkeer komt het deel van die aanroep vrij. Herhaalde aanroepen zonder eindpunt kunnen het stapelgeheugen uitputten en een stapeloverloop veroorzaken. Een geheugenlek ontstaat wanneer een programma geheugen vasthoudt dat het niet meer nodig heeft, waardoor de vastgehouden geheugentoewijzing groeit. Alleen het gebruik van veel geheugen is niet voldoende om een geheugenlek vast te stellen.

Maak onderscheid tussen adressen en fysieke locaties

Virtueel geheugen geeft elk proces een eigen adresruimte. Het besturingssysteem en de geheugenbeheereenheid (MMU) van de CPU koppelen virtuele adressen aan fysiek RAM in geheugenpagina’s, vaak van 4 KiB. Twee processen kunnen 0x1000 gebruiken voor verschillende fysieke locaties. Toegangsrechten verhinderen ongeoorloofde lees- of schrijfbewerkingen; het besturingssysteem kan ook expliciet gedeelde pagina’s toestaan.

Een verboden toegang veroorzaakt een fout die het proces kan beëindigen. Op Linux of macOS kan een C-programma een “segmentatiefout” melden. Een virtueel adres duidt een locatie aan in de adresruimte van dat proces, niet noodzakelijk een byte met hetzelfde nummer in RAM.

Bij een grote geheugenvraag kan het besturingssysteem inactieve pagina’s naar een wisselbestand op de opslag verplaatsen. Het ophalen van een pagina in bijvoorbeeld 100 µs duurt ongeveer 1.000 keer zo lang als een RAM-toegang van 100 ns. Herhaaldelijk pagina’s verplaatsen, overmatige pagina-uitwisseling genoemd, kan het grootste deel van de uitvoeringstijd in beslag nemen. De actieve geheugenvraag verminderen of RAM toevoegen kan helpen.

Volg een toetsaanslag door de lagen

Een toetsenbordcontroller geeft een interruptsignaal. De afhandelaar en het stuurprogramma van het besturingssysteem ontvangen de gebeurtenis en geven die door aan het proces van de teksteditor. De editor werkt het document in het eigen geheugen bij en vraagt de grafische diensten van het besturingssysteem om het scherm bij te werken. Bij opslaan wordt het bestandssysteem gevraagd het document naar de opslag te schrijven. Wanneer het proces eindigt, neemt het besturingssysteem het geheugen en de systeembronnen terug. Opgeslagen gegevens blijven behouden; wijzigingen die alleen in het procesgeheugen staan, verdwijnen.