Hoe microprocessors werken

Microprocessors vormen het hart van alle computers. Jorg Greuel / Getty Images

-De computer die u gebruikt om deze pagina te lezen, gebruikt een microprocessor om zijn werk te doen. De microprocessor is het hart van elke normale computer, of het nu een desktopcomputer, een server of een laptop is. De microprocessor die u gebruikt, kan een Pentium, een K6, een PowerPC, een Sparc of een van de vele andere merken en typen microprocessors zijn, maar ze doen allemaal ongeveer hetzelfde op ongeveer dezelfde manier.

Een microprocessor - ook wel bekend als een CPU of centrale verwerkingseenheid - is een complete rekenmachine die is vervaardigd op een enkele chip. De eerste microprocessor was de Intel 4004, geïntroduceerd in 1971. De 4004 was niet erg krachtig - het enige wat hij kon doen was optellen en aftrekken, en hij kon dat maar met 4 bits tegelijk. Maar het was verbazingwekkend dat alles op één chip stond. Voorafgaand aan de 4004 bouwden ingenieurs computers ofwel van verzamelingen chips of van afzonderlijke componenten (transistors die één voor één bedraad waren). De 4004 dreef een van de eerste draagbare elektronische rekenmachines aan.

- Als je je ooit hebt afgevraagd wat de microprocessor in je computer doet, of als je je ooit hebt afgevraagd wat de verschillen zijn tussen typen microprocessors, lees dan verder. In dit artikel leert u hoe vrij eenvoudige digitale logische technieken een computer in staat stellen zijn werk te doen, of het nu gaat om het spelen van een game of het controleren van een document op spelling.!

Inhoud

1. Progressie van microprocessor: Intel
2. Microprocessorlogica
3. Microprocessor geheugen
4. Microprocessor instructies
5. Microprocessorprestaties en trends
6. 64-bits microprocessors

De Intel 8080 was de eerste microprocessor in een thuiscomputer.

De eerste microprocessor die er een thuiscomputer van maakte, was de Intel 8080, een complete 8-bits computer op één chip, geïntroduceerd in 1974. De eerste microprocessor die echt indruk maakte op de markt was de Intel 8088, geïntroduceerd in 1979 en ingebouwd in de IBM-pc (die voor het eerst verscheen rond 1982). Als u bekend bent met de pc-markt en zijn geschiedenis, weet u dat de pc-markt is overgegaan van de 8088 naar de 80286 naar de 80386 naar de 80486 naar de Pentium naar de Pentium II naar de Pentium III naar de Pentium 4. Al deze microprocessors zijn gemaakt door Intel en het zijn allemaal verbeteringen op het basisontwerp van de 8088. De Pentium 4 kan elk stukje code uitvoeren dat op de originele 8088 draaide, maar het doet het ongeveer 5.000 keer sneller!

Sinds 2004 heeft Intel microprocessors geïntroduceerd met meerdere kernen en miljoenen meer transistors. Maar zelfs deze microprocessors volgen dezelfde algemene regels als eerdere chips.

Hier zijn de verschillen tussen de verschillende processors die Intel in de loop der jaren heeft geïntroduceerd. Samengesteld uit de Intel Microprocessor Quick Reference Guide en TSCP Benchmark Scores

Aanvullende informatie over de tafel op deze pagina:

• De datum is het jaar waarin de processor voor het eerst werd geïntroduceerd. Veel processors worden vele jaren na de oorspronkelijke releasedatum opnieuw geïntroduceerd met hogere kloksnelheden.
• Transistors is het aantal transistors op de chip. Je kunt zien dat het aantal transistors op een enkele chip in de loop der jaren gestaag is gestegen.
• Micron is de breedte, in micron, van de kleinste draad op de chip. Ter vergelijking: een mensenhaar is 100 micron dik. Naarmate de feature-afmeting op de chip afneemt, neemt het aantal transistors toe.
• Kloksnelheid is de maximale snelheid waarmee de chip kan worden geklokt. De kloksnelheid zal logischer worden in de volgende sectie.
• Gegevensbreedte is de breedte van de ALU. Een 8-bits ALU kan optellen / aftrekken / vermenigvuldigen / enz. twee 8-bits getallen, terwijl een 32-bits ALU 32-bits getallen kan manipuleren. Een 8-bits ALU zou vier instructies moeten uitvoeren om twee 32-bits getallen toe te voegen, terwijl een 32-bits ALU dit in één instructie kan doen. In veel gevallen heeft de externe databus dezelfde breedte als de ALU, maar niet altijd. De 8088 had een 16-bits ALU en een 8-bits bus, terwijl de moderne Pentiums gegevens 64 bits tegelijk ophalen voor hun 32-bits ALU's.
• MIPS staat voor "miljoenen instructies per seconde" en is een ruwe maatstaf voor de prestaties van een CPU. Moderne CPU's kunnen zoveel verschillende dingen doen dat MIPS-beoordelingen veel van hun betekenis verliezen, maar je kunt een algemeen idee krijgen van de relatieve kracht van de CPU's uit deze kolom.

Uit deze tabel kun je zien dat er over het algemeen een verband bestaat tussen kloksnelheid en MIPS. De maximale kloksnelheid is een functie van het fabricageproces en vertragingen in de chip. Er is ook een verband tussen het aantal transistors en MIPS. De 8088 bijvoorbeeld geklokt op 5 MHz maar alleen uitgevoerd op 0,33 MIPS (ongeveer één instructie per 15 klokcycli). Moderne processors kunnen vaak worden uitgevoerd met een snelheid van twee instructies per klokcyclus. Die verbetering houdt rechtstreeks verband met het aantal transistors op de chip en zal in de volgende sectie logischer worden.

Wat is een chip?

EEN chip wordt ook wel een geïntegreerde schakeling. Over het algemeen is het een klein, dun stukje silicium waarop de transistors van de microprocessor zijn geëtst. Een chip kan aan één kant wel een centimeter groot zijn en kan tientallen miljoenen transistors bevatten. Eenvoudigere processors kunnen bestaan ​​uit een paar duizend transistors die zijn geëtst op een chip van slechts enkele millimeters in het vierkant.

Intel Pentium 4-processor Foto ter beschikking gesteld door Intel Corporation

Om te begrijpen hoe een microprocessor werkt, is het handig om naar binnen te kijken en meer te weten te komen over de logica die wordt gebruikt om er een te maken. In het proces kunt u ook leren over assembleertaal -- de moedertaal van een microprocessor - en veel van de dingen die ingenieurs kunnen doen om de snelheid van een processor te verhogen.

Een microprocessor voert een verzameling machine-instructies uit die de processor vertellen wat hij moet doen. Op basis van de instructies doet een microprocessor drie basisdingen:

• Met behulp van zijn ALU (Arithmetic / Logic Unit) kan een microprocessor wiskundige bewerkingen uitvoeren zoals optellen, aftrekken, vermenigvuldigen en delen. Moderne microprocessors bevatten complete drijvende-kommagetallen die uiterst geavanceerde bewerkingen kunnen uitvoeren op grote drijvende-kommagetallen.
• Een microprocessor kan gegevens van de ene geheugenlocatie naar de andere verplaatsen.
• Een microprocessor kan beslissingen nemen en op basis van die beslissingen naar een nieuwe reeks instructies springen.

Er zijn misschien zeer geavanceerde dingen die een microprocessor doet, maar dat zijn de drie basisactiviteiten. Het volgende diagram toont een uiterst eenvoudige microprocessor die deze drie dingen kan doen:

Dit is ongeveer net zo eenvoudig als een microprocessor krijgt. Deze microprocessor heeft:

• Een adresbus (dat kan 8, 16 of 32 bits breed zijn) dat een adres naar het geheugen stuurt
• EEN databus (dat kan 8, 16 of 32 bits breed zijn) die gegevens naar het geheugen kunnen verzenden of gegevens uit het geheugen kunnen ontvangen
• Een RD (Lees en WR (schrijf) regel om het geheugen te vertellen of het de geadresseerde locatie wil instellen of ophalen
• EEN klok lijn dat laat een klokpuls de processor volgen
• EEN reset lijn die de programmateller terugzet op nul (of wat dan ook) en de uitvoering herstart

Laten we aannemen dat zowel de adres- als de databussen in dit voorbeeld 8 bits breed zijn.

Hier zijn de componenten van deze eenvoudige microprocessor:

• Registers A, B en C zijn gewoon sloten gemaakt van flip-flops. (Zie het gedeelte over "edge-triggered latches" in How Boolean Logic Works voor details.)
• De adresvergrendeling is net als de registers A, B en C.
• De programmateller is een vergrendeling met de extra mogelijkheid om met 1 te verhogen wanneer dit wordt gevraagd, en ook om op nul te resetten wanneer dit wordt gevraagd.
• De ALU kan zo simpel zijn als een 8-bits opteller (zie de sectie over optellers in Hoe Booleaanse logica werkt voor details), of hij kan 8-bits waarden optellen, aftrekken, vermenigvuldigen en delen. Laten we hier het laatste aannemen.
• Het testregister is een speciale vergrendeling die waarden kan bevatten van vergelijkingen die in de ALU zijn uitgevoerd. Een ALU kan normaal gesproken twee getallen vergelijken en bepalen of ze gelijk zijn, of de ene groter is dan de andere, enz. Het testregister kan normaal ook een carry-bit bevatten van de laatste fase van de opteller. Het slaat deze waarden op in flip-flops en vervolgens kan de instructiedecoder de waarden gebruiken om beslissingen te nemen.
• Er zijn zes vakken gemarkeerd met "3-State" in het diagram. Dit zijn tri-state buffers. Een tri-state buffer kan een 1, een 0 doorgeven of het kan in wezen zijn output loskoppelen (stel je een schakelaar voor die de outputlijn volledig loskoppelt van de draad waar de output naartoe leidt). Met een tri-state buffer kunnen meerdere uitgangen op een draad worden aangesloten, maar slechts één ervan kan een 1 of een 0 naar de lijn sturen.
• Het instructieregister en de instructiedecoder zijn verantwoordelijk voor het besturen van alle andere componenten.

Hoewel ze niet in dit diagram worden weergegeven, zouden er controlelijnen zijn van de instructiedecoder die:

• Vertel het A-register om de huidige waarde op de databus te vergrendelen
• Vertel het B-register om de huidige waarde op de databus te vergrendelen
• Vertel het C-register om de waarde te vergrendelen die momenteel door de ALU wordt uitgevoerd
• Vertel het programma-tellerregister om de huidige waarde op de databus te vergrendelen
• Vertel het adresregister om de huidige waarde op de databus te vergrendelen
• Vertel het instructieregister om de huidige waarde op de databus te vergrendelen
• Vertel de programmateller om te verhogen
• Laat de programmateller op nul resetten
• Activeer een van de zes tri-state buffers (zes afzonderlijke regels)
• Vertel de ALU welke operatie moet worden uitgevoerd
• Vertel het testregister om de testbits van de ALU te vergrendelen
• Activeer de RD-lijn
• Activeer de WR-lijn

In de instructiedecoder komen de bits uit het testregister en de kloklijn, evenals de bits uit het instructieregister.

ROM-chip

In het vorige gedeelte werd gesproken over de adres- en databussen, evenals de RD- en WR-lijnen. Deze bussen en lijnen zijn verbonden met RAM of ROM - meestal beide. In onze voorbeeldmicroprocessor hebben we een adresbus van 8 bits breed en een databus van 8 bits breed. Dat betekent dat de microprocessor (2⁸) 256 bytes geheugen, en het kan 8 bits van het geheugen tegelijk lezen of schrijven. Laten we aannemen dat deze eenvoudige microprocessor 128 bytes ROM heeft beginnend bij adres 0 en 128 bytes RAM beginnend bij adres 128.

ROM staat voor read-only memory. Een ROM-chip is geprogrammeerd met een permanente verzameling vooraf ingestelde bytes. De adresbus vertelt de ROM-chip welke byte moet worden opgehaald en op de databus moet worden geplaatst. Wanneer de RD-lijn van status verandert, presenteert de ROM-chip de geselecteerde byte op de databus.

RAM staat voor Random Access Memory. RAM bevat bytes aan informatie, en de microprocessor kan die bytes lezen of ernaar schrijven, afhankelijk van of de RD- of WR-lijn wordt gesignaleerd. Een probleem met de huidige RAM-chips is dat ze alles vergeten zodra de stroom uitvalt. Daarom heeft de computer ROM nodig.

RAM-chip

Overigens bevatten bijna alle computers een bepaalde hoeveelheid ROM (het is mogelijk om een ​​eenvoudige computer te maken die geen RAM bevat - veel microcontrollers doen dit door een handvol RAM-bytes op de processorchip zelf te plaatsen - maar over het algemeen onmogelijk om dit te maken een die geen ROM bevat). Op een pc wordt de ROM het BIOS (Basic Input / Output System) genoemd. Wanneer de microprocessor start, begint deze met het uitvoeren van instructies die hij vindt in het BIOS. De BIOS-instructies doen dingen zoals het testen van de hardware in de machine, en dan gaat het naar de harde schijf om het opstartsector (zie Hoe harde schijven werken voor details). Deze opstartsector is een ander klein programma en het BIOS slaat het op in het RAM nadat het van de schijf is gelezen. De microprocessor begint dan met het uitvoeren van de instructies van de opstartsector vanuit het RAM. Het opstartsectorprogramma zal de microprocessor vertellen iets anders van de harde schijf in het RAM-geheugen op te halen, dat de microprocessor vervolgens uitvoert, enzovoort. Dit is hoe de microprocessor het volledige besturingssysteem laadt en uitvoert.

Zelfs de ongelooflijk eenvoudige microprocessor die in het vorige voorbeeld wordt getoond, zal een vrij grote reeks instructies hebben die hij kan uitvoeren. De verzameling instructies is geïmplementeerd als bitpatronen, die elk een andere betekenis hebben wanneer ze in het instructieregister worden geladen. Mensen zijn niet bijzonder goed in het onthouden van bitpatronen, dus een reeks korte woorden wordt gedefinieerd om de verschillende bitpatronen weer te geven. Deze verzameling woorden wordt de assembleertaal van de processor. Een assembler kan de woorden heel gemakkelijk in hun bitpatronen vertalen, en vervolgens wordt de uitvoer van de assembler in het geheugen geplaatst zodat de microprocessor deze kan uitvoeren.

Hier is de set met assembleertaalinstructies die de ontwerper zou kunnen maken voor de eenvoudige microprocessor in ons voorbeeld:

• LOADA mem - Laad register A uit geheugenadres
• LOADB mem - Laad register B uit geheugenadres
• CONB con - Laad een constante waarde in register B.
• SAVEB mem - Sla register B op in het geheugenadres
• SAVEC-mem - Sla register C op in het geheugenadres
• TOEVOEGEN - Voeg A en B toe en sla het resultaat op in C
• SUB - Trek A en B af en sla het resultaat op in C
• MUL - Vermenigvuldig A en B en sla het resultaat op in C
• DIV - Verdeel A en B en sla het resultaat op in C
• COM - Vergelijk A en B en sla het resultaat op in de test
• JUMP-adres - Spring naar een adres
• JEQ adres - Spring, indien gelijk, naar het adres
• JNEQ addr - Spring, zo niet gelijk, naar adres
• JG addr - Spring, indien groter dan, naar adres
• JGE adres - Spring, indien groter dan of gelijk, naar adres
• JL-adres - Spring, indien minder dan, naar adres
• JLE-adres - Spring, indien kleiner dan of gelijk, naar adres
• HOU OP - Stop met de uitvoering

Als je hebt gelezen hoe C-programmeren werkt, dan weet je dat dit eenvoudige stukje C-code de faculteit van 5 berekent (waarbij de faculteit van 5 = 5! = 5 * 4 * 3 * 2 * 1 = 120):

a = 1; f = 1; terwijl (a <= 5) f = f * a; a = a + 1;

Aan het einde van de uitvoering van het programma wordt de variabele f bevat de faculteit van 5.

Assemblagetaal

EEN C-compiler vertaalt deze C-code in assembleertaal. Aangenomen dat RAM begint bij adres 128 in deze processor, en ROM (dat het assembleertaalprogramma bevat) begint bij adres 0, dan zou voor onze eenvoudige microprocessor de assembleertaal er als volgt uit kunnen zien:

// Neem aan dat a is op adres 128 // Neem aan dat F op adres 1290 CONB 1 // a = 1; 1 SAVEB 1282 CONB 1 // f = 1; 3 SAVEB 1294 LOADA 128 // als a> 5 de sprong naar 175 is CONB 56 COM7 JG 178 LOADA 129 // f = f * a; 9 LOADB 12810 MUL11 SAVEC 12912 LOADA 128 // a = a + 1; 13 CONB 114 ADD15 SAVEC 12816 JUMP 4 // loop terug naar if17 STOP

rom

Dus nu is de vraag: "Hoe zien al deze instructies eruit in ROM?" Elk van deze assembleertaalinstructies moet worden weergegeven door een binair getal. Laten we voor de eenvoud aannemen dat elke assembleertaalinstructie een uniek nummer krijgt, zoals dit:

• LOADA - 1
• LOADB - 2
• CONB - 3
• SAVEB - 4
• SAVEC-geheugen - 5
• TOEVOEGEN - 6
• ONDER - 7
• MUL - 8
• DIV - 9
• COM - 10
• JUMP-adres - 11
• JEQ adres - 12
• JNEQ adres - 13
• JG adres - 14
• JGE-adres - 15
• JL adres - 16
• JLE-adres - 17
• STOP - 18

De nummers staan ​​bekend als opcodes. In ROM zou ons kleine programma er als volgt uitzien:

// Veronderstel dat a is op adres 128 // Veronderstel dat F op adres 129 is Addr opcode / waarde0 3 // CONB 11 12 4 // SAVEB 1283 1284 3 // CONB 15 16 4 // SAVEB 1297 1298 1 // LOADA 1289 12810 3 // CONB 511512 10 // COM13 14 // JG 1714 3115 1 // LOADA 12916 12917 2 // LOADB 12818 12819 8 // MUL20 5 // SAVEC 12921 12922 1 // LOADA 12823 12824 3 // CONB 125126 6 // ADD27 5 // SAVEC 12828 12829 11 // JUMP 430831 18 // STOP

Je kunt zien dat zeven regels C-code 18 regels assembleertaal werden, en dat werd 32 bytes in ROM.

Decodering

De instructiedecoder moet elk van de opcodes omzetten in een reeks signalen die de verschillende componenten in de microprocessor aansturen. Laten we de ADD-instructie als voorbeeld nemen en kijken wat deze moet doen:

1. Tijdens de eerste klokcyclus moeten we de instructie daadwerkelijk laden. Daarom moet de instructiedecoder: de tri-state buffer activeren voor de programmateller de RD-lijn activeren de data-in tri-state buffer activeren de instructie in het instructieregister vastleggen
2. Tijdens de tweede klokcyclus wordt de ADD-instructie gedecodeerd. Het hoeft heel weinig te doen: stel de werking van de ALU in om bovendien de uitgang van de ALU in het C-register te vergrendelen
3. Tijdens de derde klokcyclus wordt de programmateller verhoogd (in theorie zou dit kunnen overlappen in de tweede klokcyclus).

Elke instructie kan worden opgesplitst als een reeks opeenvolgende bewerkingen zoals deze die de componenten van de microprocessor in de juiste volgorde manipuleren. Sommige instructies, zoals deze ADD-instructie, kunnen twee of drie klokcycli in beslag nemen. Anderen hebben misschien vijf of zes klokcycli nodig.

Het aantal transistors beschikbaar heeft een enorm effect op de prestaties van een processor. Zoals eerder gezien, kostte het uitvoeren van een typische instructie in een processor zoals een 8088 15 klokcycli. Vanwege het ontwerp van de vermenigvuldiger, kostte het ongeveer 80 cycli om slechts één 16-bits vermenigvuldiging op de 8088 uit te voeren. Met meer transistors worden veel krachtigere vermenigvuldigers die in staat zijn tot snelheden van één cyclus mogelijk.

Meer transistors maken ook een technologie mogelijk genaamd pijpleidingen. In een pijplijnarchitectuur overlapt het uitvoeren van instructies. Dus hoewel het vijf klokcycli kan kosten om elke instructie uit te voeren, kunnen er vijf instructies tegelijkertijd in verschillende stadia van uitvoering zijn. Op die manier lijkt het alsof één instructie elke klokcyclus voltooit.

Veel moderne processors hebben meerdere instructiedecoders, elk met een eigen pijplijn. Dit maakt meerdere instructiestromen mogelijk, wat betekent dat meer dan één instructie tijdens elke klokcyclus kan worden voltooid. Deze techniek kan behoorlijk complex zijn om te implementeren, dus er zijn veel transistors voor nodig.

Trends

De trend in het processorontwerp was voornamelijk in de richting van volledige 32-bits ALU's met ingebouwde snelle floating point processors en pijplijnuitvoering met meerdere instructiestromen. Het nieuwste op het gebied van processorontwerp zijn 64-bits ALU's, en de verwachting is dat mensen deze processors het komende decennium op hun pc thuis zullen hebben. Er is ook een tendens geweest naar speciale instructies (zoals de MMX-instructies) die bepaalde bewerkingen bijzonder efficiënt maken, en de toevoeging van hardware virtueel geheugenondersteuning en L1-caching op de processorchip. Al deze trends verhogen het aantal transistoren, wat leidt tot de miljoenen transistor-krachtpatsers die vandaag beschikbaar zijn. Deze processors kunnen ongeveer een miljard instructies per seconde uitvoeren!

Foto met dank aan AMD

Vierenzestig-bits processors zijn bij ons sinds 1992, en in de 21e eeuw zijn ze mainstream geworden. Zowel Intel als AMD hebben 64-bits chips geïntroduceerd en de Mac G5 heeft een 64-bits processor. 64-bits processors hebben 64-bits ALU's, 64-bits registers, 64-bits bussen enzovoort.

Een van de redenen waarom de wereld 64-bits processors nodig heeft, is vanwege hun vergrote adresruimten. Tweeëndertig-bits chips zijn vaak beperkt tot maximaal 2 GB of 4 GB RAM-toegang. Dat klinkt als veel, aangezien de meeste thuiscomputers momenteel slechts 256 MB tot 512 MB RAM gebruiken. Een limiet van 4 GB kan echter een ernstig probleem zijn voor servermachines en machines met grote databases. En zelfs thuismachines zullen al snel tegen de limiet van 2 GB of 4 GB botsen als de huidige trends doorzetten. Een 64-bits chip heeft geen van deze beperkingen omdat een 64-bits RAM-adresruimte in de nabije toekomst in wezen oneindig is - 2 ^ 64 bytes RAM is iets in de orde van een miljard gigabyte RAM.

Met een 64-bits adresbus en brede, supersnelle databussen op het moederbord, bieden 64-bits machines ook snellere I / O-snelheden (invoer / uitvoer) voor zaken als harde schijven en videokaarten. Deze functies kunnen de systeemprestaties aanzienlijk verbeteren.

Servers kunnen zeker profiteren van 64 bits, maar hoe zit het met normale gebruikers? Afgezien van de RAM-oplossing, is het niet duidelijk dat een 64-bits chip op dit moment "normale gebruikers" echte, tastbare voordelen biedt. Ze kunnen gegevens (zeer complexe gegevens bevatten veel reële getallen) sneller verwerken. Mensen die videobewerking uitvoeren en mensen die fotobewerkingen uitvoeren op zeer grote afbeeldingen, profiteren van dit soort rekenkracht. Geavanceerde games zullen ook profiteren, zodra ze opnieuw zijn gecodeerd om te profiteren van 64-bits functies. Maar de gemiddelde gebruiker die e-mail leest, op internet surft en Word-documenten bewerkt, gebruikt de processor niet echt op die manier.

Raadpleeg de links op de volgende pagina voor meer informatie over microprocessors en aanverwante onderwerpen.

gerelateerde artikelen

• CPU-quiz
• Waarom zijn er limieten aan de CPU-snelheid??
• Hoe halfgeleiders werken
• Hoe pc's werken
• Hoe C-programmering werkt
• Hoe Java werkt
• Hoe besturingssystemen werken
• Hoe computergeheugen werkt
• Hoe Quantum Computers zullen werken
• Hoe DNA-computers zullen werken

Meer geweldige links

• Webopedia: microprocessor
• Klik op CPU
• Processor-upgrades
• 6e generatie CPU-vergelijkingen
• 7e generatie CPU-vergelijkingen
• TSCP-benchmarkscores