Het digitale domein: architectuur

Op deze pagina, gaan we in plaats van naar software, kijken naar hardware. Het eerste onderwerp is architectuur, wat praktisch is hoe de software de hardware ziet.

De software in een computer is nutteloos zonder de hardware: de daadwerkelijke circuits in de computer. Net zoals er lagen van abstractie zijn voor software denken hardware-designers ook in lagen van abstractie.

Geen Afbeelding

Iedereen heeft het over computers die alle gegevens vertegenwoordigen met slechts twee waarden, 0 en 1. Maar dat is niet echt hoe elektronische circuits werken. Computerontwerpers kunnen doen alsof circuits uit (0) of aan (1) staan vanwege digitale abstractie , de belangrijkste abstractie in hardware. Boven dat abstractieniveau zijn er vier gedetailleerdere niveaus, het digitale domein genoemd. Onder de digitale abstractie werken ontwerpers in het analoge domein , waarin een draad in een circuit elke spanningswaarde kan hebben, niet slechts twee waarden.

Op de volgende vier pagina's, zullen we vier lagen van het digitale domein verkennen.

De Stored program-computer (Computer met opgeslagen programma)

Zoals je zal zien in Les 3 zijn er al duizenden jaren machines die berekeningen uitvoeren. Maar de moderne, programmeerbare computer komt voort uit het werk van Charles Babbage in de vroege jaren van 1800.

Babbage was vooral een wiskundige maar hij heeft veel bijgedragen aan onder andere astronomie en economie. Babbage leefde ongeveer 150 jaar geleden van 1791-1871. Dat elektriciteit als een bron van energie kon worden gebruikt was nog onbekend. De stoommachine werd populair rond de tijd dat hij was geboren. De meeste precieze machines uit zijn tijd waren uurwerken.

De Difference Engine

Babbage's eerste computer was de Difference Engine (Verschilmotor).Hij gebruikten tandwielen om een ingewikkelde machine te ontwerpen die tabellen met getallen kon berekenen en printen (bijvoorbeld tabellen van logaritme-functies). Maar deze tandwielen moesten heel precies zijn en ieder tandwiel moest met de hand gemaakt worden. Het project werd zo duur dat de overheid de financiering stop moest zetten en Babbage maakte het project nooit af.

Geen Afbeelding
De Difference Engine in het London Science Museum
Afbeelding van Wikimedia-gebruiker geni. Copyright 2008. Licentie: GFDL, CC BY-SA.
Geen Afbeelding
Een close-up die de tandwielen duidelijker laat zien
Afbeelding van Carsten Ullrich. Copyright 2005. Licentie: CC-BY-SA-2.5.

Leer meer over de geschiedenis van de Difference Engine.

In de tijd van Babbage werden dergelijke numerieke tabellen met de hand berekend door menselijke wiskundigen, en ze werden met de hand gezet om te worden afgedrukt. Zowel de berekening als het kopiëren naar print waren foutgevoelig, en nauwkeurige tabellen waren nodig voor doeleinden variërend van engineering tot navigatie.

Babbage bouwde eerst een kleine Difference Engine in 1822. Deze eerste poging bewees dat een Difference Engine mogelijk was, maar het had niet de precisie (aantal cijfers in elk getal) om praktisch te zijn. In 1823 financierde de Britse overheid Babbage om een ​​grotere versie te bouwen. Helaas konden metaalsmeden in zijn tijd niet erg precieze tandwielen in grote hoeveelheden produceren; elk moest handgemaakt zijn. Dus had hij hij tien keer zijn goedgekeurde budget besteed tegen de tijd dat de overheid het project in 1842 stopzette.

In 1991 voltooide het London Science Museum een Difference Engine volgens het oorspronkelijke ontwerp van Babbage met behulp van tandwielen gemaakt door moderne processen, maar op het niveau van precisie dat beschikbaar was voor Babbage. Dit bewees dat Babbage in principe een werkende machine had kunnen voltooien met voldoende tijd en geld.

De Analytical Engine

De Difference Engine kan worden gebruikt om veel verschillende functies te berekenen door de startpositie van verschillende versnellingen handmatig in te stellen. Maar het had slechts één algoritme : het algoritme ingebouwd in het hardware-ontwerp. In 1833 begon Babbage te werken aan de Analytical Engine, die gebaseerd was op het algemene idee van de Difference Engine maar die wel instructies uit kon voeren in een primitieve programmeertaal die met ponskaarten werkte.

Ponskaarten gebruikt om de Analytical Engine te programmeren
Karoly Lorentey. Copyright 2004. Licentie: CC-BY.
Geen Afbeelding

Tegenwoordig zijn we omringd door programmeerbare computers en het is nu vanzelfsprekend om software te hebben. Maar dit was niet altijd zo, vóór Babbage werden alle algoritmen rechtstreeks in hardware geïmplementeerd.

Dus, 150 jaar geleden, maakte Babbage plannen voor wat in wezen een moderne computer is, hoewel hij geen elektronica beschikbaar had. Zijn onderliggende idee voor hardware was volledig mechanisch, maar het bleek niet mogelijk te zijn om het met de toenmalige technologie te bouwen. We hebben geen bruikbare computers gekregen totdat er een onderliggende technologie was die klein, goedkoop en snel genoeg was om de software-abstractie te ondersteunen. Je leert snel over deze technologie, transistors.

De abstractie van software (een programma dat opgeslagen is in het geheugen van de computer) is wat een computer bruikbaar maakt voor meerdere doeleinden.

Leer meer over de Analytical Engine.

De Analytical Engine, had net als moderne computers, een rekenkundige processor (genaamd de "molen") en een apart geheugen (de "winkel") die 1000 getallen kon bijhouden, ieder tot en met 40 cijfers. De molen voerde rekenkundige handelingen uit in decimalen (met cijfers 0-9 verdeeld over ieder tandwiel); het gebruik van "enen en nullen" kwam pas later.

De programmeertaal die gebruikt werd in de Analytical Engine had ook condities en lussen, wat alles is dat je nodig hebt om een algoritme te maken. (Het kon lussen maken omdat het voorwaarts en achterwaarts door de ponskaarten kon gaan.)

Helaas kon Babbage maar een klein deel van de Analytical Engine bouwen, die nog meer metaalwerk nodig had dan de Difference Engine. Zijn aantekeningen over het ontwerp waren niet volledig en dus heeft niemand ooit een werkend model gebouwd, alhoewel er simulaties zijn op het internet (zie het Ga Een Stapje Verder-probleem hieronder). Jammer genoeg was Babbage werk niet bekend in de vroege dagen van elektronische computers en veel mensen hebben zijn ideeën heruitgevonden.

Leer over Ada, Gravin Lovelace's uitvinding van symbolisch programmeren.

Alhoewel zijn ontwerp zeer veelzijdig was, was Babbage vooral geïnteresseerd in het afdrukken van getallentabellen. Het was zijn medewerker Augusta Ada King-Noel, gravin van Lovelace, die voor het eerst inzag dat de nummers in de computer van Babbage niet alleen als hoeveelheden konden worden gebruikt, maar ook als weergave van muzieknoten, letters, enzovoort.

Geen Afbeelding
Afbeelding van Alfred Edward Chalon, Science & Society Picture Library, Publiek Domein, via Wikimedia.

Veel van wat we vandaag weten over het ontwerp van Babbage komt uit de uitgebreide aantekeningen van Ada Lovelace over zijn ontwerp. Haar aantekeningen omvatten het eerste gepubliceerde programma voor de Analytical Engine, en daarom wordt ze algemeen beschouwd als "de eerste programmeur", hoewel het bijna zeker is dat Babbage zelf verschillende voorbeeldprogramma's heeft geschreven tijdens het ontwerpen van de machine.

Of ze nu echt de eerste programmeur was of niet, historici zijn het erover eens dat ze iets belangrijkers heeft gedaan: ze heeft het idee van symbolische berekening (inclusief tekst, afbeeldingen, muziek, etc.) naar numerieke berekening uitgevonden. Dit inzicht maakte de weg vrij voor alle manieren waarop computers tegenwoordig worden gebruikt, van Netflix tot stem-interactieve programma's zoals Siri en Alexa.

Wat is een Architectuur?

De Analytical Engine (boven beschreven) was de eerste programmeerbare computerarchitectuur. De processor in de computer die je nu gebruikt begrijpt maar één taal: zijn eigen machinetaal, geen Java, C of Snap!, of iets anders. Programma's die geschreven zijn in die andere talen moeten eerst vertaald worden naar machinetaal.

Het belangrijkste van de architectuur is de machinetaal. De set instructies van zeer laag niveau die de hardware begrijpt. Deze taal is een soort contract tussen de hardware en de software: De hardware belooft de instructies te begrijpen en de software compileert programma's van mens-vriendelijke taal naar deze instructies.

Machinetaal is de programmeertaal op het laagste niveau; het wordt direct begrepen door de hardware.

Architectuur is een abstractie, een specificate van de machinetaal. Het zegt ook hoe de processor verbonden is met het geheugen. Het specificeert niets van de circuits; dezelfde architectuur kan op meerdere manieren worden gebouwd qua circuits.

Een belangrijk onderdeel van een architectuur is het aantal draden dat de processor met het geheugen verbindt. Dit wordt de breedte van de architectuur genoemd, gemeten in bits (aantal draden). Een computer met een hogere breedte kan meer gegevens in één instructie verwerken.

Hoe ziet machinetaal eruit?

Bekijk de Snap!-instructie Geen Afbeelding. In een taal op laag niveau zoals C of Java zou het zelfde idee geschreven als:

c = a+b;
Dat simpele commando zou vertaald kunnen worden in zes machinetaalinstructies (een beetje versimpeld):
movq    _c, %rcx
movq    _b, %rdx
movq    _a, %rsi
movl    (%rsi), %edi
addl    (%rdx), %edi
movl    %edi, (%rcx)
Deze notatie, assembly-taal genaamd, is een regel voor regel-equivalent aan de daadwerkelijke numerieke instructiecode, maar het is iets meer leesbaar.

Wat betekent de code?

De eerste drie instructies laden de adressen van de drie variabelen in de registers in de processor. De namen met een percentage-teken zoals %rcx verwijzen naar specifieke registers. Movq is de naam van een machinetaalinstructie. (Het is een afkorting voor "move quote", wat betekent dat we een constante waarde in een register plaatsen. Merk op dat a een variabele is, maar het adres van a is een constante waarde, omdat de variabele niet wordt verplaatst in het geheugen.)

De volgende instructie, movl ("move long"), zegt dat een woord van de ene plek naar de andere moet worden verplaatst. Als een registernaam tussen haakjes staat zoals (%rsi dan betekent dat dat we locatie in het geheugen gebruiken van wie het adres in dat register staat. Omdat de derde movq het adres van a in register %rsi heeft geplaatst zegt de eerste movl dat de variabele a van het geheugen in de processorregister moet worden geplaatst. De instructie addl zegt dat b moet worden toegevoegd aan hetzelfde register. Aan het einde wordt de waarde in register %edi in de geheugen locatie geplaatst van variabele c.

Je wil niet moeten programmeren in deze taal! En dat hoeft ook niet ; moderne architecturen zijn ontworpen voor compilers, niet voor machinetaalprogrammeurs.

Leer over:
Leer meer over computerarchitectuur in het algemeen.

De Geheugenhiërarchie

Een gegeven van circuithardware is, hoe groter het geheugen, hoe langzamer het werkt. om deze reden hebben computers niet alleen een grote hoop geheugen. Er zal een klein aantal registers in de processor zelf zijn, meestal tussen de 8 en 16. De "grootte" (aantal bits) van een gegevensregister is gelijk aan de breedte van de architectuur.

Het hoofdgeheugen van de computer wordt tegenwoordig gemeten in GB (gigabytes of miljarden bytes). Een geheugen van die omvang kan niet snel genoeg zijn om een ​​moderne processor bij te houden. Gelukkig hebben computerprogramma's over het algemeen plaats van referentie , wat betekent dat als het programma net gebruik heeft gemaakt van een bepaalde geheugenlocatie, het waarschijnlijk een nabijgelegen locatie hierna zal gebruiken. Dus een compleet programma kan heel groot zijn, maar in de loop van een seconde zal er maar een klein deel van nodig zijn. Daarom zijn moderne computers ontworpen met een of meer cache -geheugens - veel kleiner en daarom sneller - tussen de processor en het hoofdgeheugen. De processor zorgt ervoor dat het meest recent gebruikte geheugen naar de cache wordt gekopieerd.

Een recente 64-bit x86-processor heeft een eerste niveau (L1) cache van 64 KB (duizenden bytes) in de processorchip, een grotere maar langzamere L2-cache van 256 KB, ook in de processor, en een L3-cache van maximaal 2 MB (megabytes, miljoenen bytes) buiten de processor. Elk niveau van cache heeft een kopie van de meest recent gebruikte delen van het volgende niveau naar buiten: de L1-cache kopieert een deel van de L2-cache, die een deel van de L3-cache kopieert, die een deel van het hoofdgeheugen kopieert. Gegevens in de L1-cache zijn ongeveer even snel toegankelijk voor de processor als de interne registers en elk niveau naar buiten is iets langzamer. Hardware in de processor verwerkt al deze complexiteit, zodat programmeurs programma's kunnen schrijven alsof de processor rechtstreeks op het hoofdgeheugen is aangesloten.

Second sourcing

Intel geeft licenties aan andere chipfabrikanten om processors te bouwen die dezelfde architectuur gebruiken als de processors van Intel. Waarom doen ze dat? Zouden ze niet meer geld verdienen als mensen alles bij Intel moesten kopen? De reden is dat computerfabrikanten, zoals Dell, Apple en Lenovo, hun systemen niet zullen bouwen rond een architectuur die slechts bij één bedrijf beschikbaar is. Ze zijn niet bang dat Intel failliet gaat; de zorg is dat er mogelijk een groter dan verwachte vraag is naar een bepaalde processor en dat Intel mogelijk niet in staat is bestellingen op tijd af te handelen. Maar als die processor ook verkrijgbaar is bij andere bedrijven zoals AMD en Cyrix, dan zal een vertraging bij Intel geen vertraging worden bij Dell. Die andere chipfabrikanten gebruiken mogelijk niet dezelfde circuits als de Intel-versie, zolang ze zich maar hetzelfde gedragen op architectuurniveau.

  1. Voldoende leren over de Analytical Engine om zelfs een eenvoudig programma te kunnen schrijven, is een behoorlijk grote onderneming. Maar als je geïnteresseerd bent, zijn hier uitgebreide online bronnen beschikbaar:
Terug Volgende