Verschil tussen risc en cisc embedded architectuur

Embedded systeem is het hart en de kern van de meeste elektronische producten die op de markt verkrijgbaar zijn. Het is de implementatie van engineering waarbij hardware de software ontmoet. We zijn omringd door een wereld van embedded systemen, met mini-computers in biometrische deursloten, vliegtuigen, auto's, pacemakers, enz. Deze beperkte, kleine, slimme en krachtige systemen helpen ons bij onze dagelijkse taken.

Heb ooit nagedacht over hoe ons lichaam functioneert, het zenuwstelsel, de hersenen en het vermogen om te multitasken. Als je al deze functies combineert, krijg je een globaal beeld van een biologisch ingebed systeem. Ons brein verbergt de complexe details van zijn werking die erin plaatsvinden, maar stelt ons toch in staat om het maximaal te beheersen. Dezelfde complexiteit geldt voor de processor of controller die wordt gebruikt in embedded systemen. Ze verbergen complexe details en bieden ons een interface op hoog niveau om aan te werken. Voor het abstractieniveau kan men relateren hoe de code voor het optellen van twee getallen in een programmeertaal op hoog niveau ervoor zorgt dat de registers in de chips bits verwerken en een uitvoer teruggeven aan de gebruiker.

Processor-architecturen

De centrale verwerkingseenheid, verwijzend naar zowel microprocessor als microcontroller, voert specifieke taken uit met behulp van een besturingseenheid (CU) en rekenkundige logische eenheid (ALU). Aangezien de instructies worden geleverd vanuit het RAM, handelt de CPU met behulp van zijn twee hulpeenheden door variabelen te creëren en deze waarden en geheugen toe te wijzen. Het is erg belangrijk om te weten hoe de CPU al deze acties uitvoert met behulp van zijn architectuur. Als u meer wilt weten over hoe een microcontroller werkt, kunt u dit basisartikel over een microcontroller lezen.

Elke CPU heeft een bijbehorend geheugen om het programma en de gegevens op te slaan. Programma en gegevens werken met de CPU om de uitvoer te krijgen. Het programma geeft de instructie terwijl de gegevens de informatie leveren waaraan moet worden gewerkt. Om toegang te krijgen tot het programma en de gegevens gebruikt de CPU bussen, deze bussen zijn draden, meer bepaald zijn dit de draadsporen zoals je misschien hebt gezien op de printplaten. In de afgelopen jaren zijn microcontrollers en microprocessors geëvolueerd door verschillende architecturen aan te passen, op basis van de applicatie- of ontwerpvereisten. De keuze van de microcontroller wordt beïnvloed door het type architectuur dat erin wordt gebruikt. Laten we eens kijken naar de populaire architecturen.

Von-Neumann / Princeton-architectuur

De manier waarop de CPU toegang krijgt tot het programma en de gegevens, vertelt over de architectuur van de CPU. Eerder werd een enkele bus gebruikt om toegang te krijgen tot het programma en de gegevens. Dit type architectuur staat bekend als de Von Neumann-architectuur of eenvoudiger Princeton-architectuur. Een enkele bus voor het ophalen van de code en gegevens betekent dat ze elkaar in de weg zitten en de verwerkingssnelheid van de CPU vertragen omdat ze moesten wachten tot de ander klaar was met ophalen. Deze beperking wordt ook wel de bottleneckconditie van Von-Neumann genoemd.

Harvard-architectuur

Om het proces te versnellen, werd Harvard Architecture voorgesteld. In deze architectuur zijn aparte databussen voor data en programma aanwezig. Het betekent dus dat deze architectuur het gebruik van vier bussen voorstelde

1. Een set databussen die de gegevens naar en uit de CPU vervoert.
2. Een set adresbus voor toegang tot de gegevens.
3. Een set databussen om code naar de CPU te dragen.
4. Een adresbus voor toegang tot de code.

Het gebruik van een aparte adresbus en databus betekende een korte uitvoeringstijd voor de CPU, maar dit gaat ten koste van de complexiteit bij het ontwerpen van de architectuur. De architectuur van Von Neumann klinkt misschien een beetje lui, maar heeft het voordeel van zijn eenvoudige ontwerp.

De architectuur van Harvard is veel eenvoudig te implementeren wanneer de CPU en de geheugeneenheden dezelfde ruimte delen of de RAM en ROM zijn ingebouwd (op de chip) met de verwerkingseenheid, zoals in een microcontroller waar de afstanden in microns en millimeters zijn. Dezelfde architectuur is echter moeilijk te implementeren waar het geheugen dat de code bevat zich buiten de verwerkingseenheid bevindt, zoals die in x86 IBM-pc's. Een reeks afzonderlijke draadsporen voor zowel de gegevens als het adres op het moederbord zou het bord complex en duur maken. Laten we het begrijpen met een voorbeeld van een processor.

Een processor met 64-bits databus en 32-bits adresbus zou ongeveer 100 bussen nodig hebben (96 voor de data- en adresbus en enkele andere voor de besturingssignalen) voor implementatie van de Von-Neumann-architectuur. Dezelfde structuur indien geïmplementeerd met de Harvard-architectuur zou de dubbele draadsporen ongeveer 200 kosten met een groot aantal pinnen die uit de processor komen. Om dezelfde reden zien we geen pure Harvard-architectuur geïmplementeerd voor pc's en werkstations. In plaats daarvan wordt een gemodificeerde Harvard-architectuur gebruikt waarin geheugenhiërarchie met CPU-cachegeheugen wordt gebruikt voor het scheiden van het programma en de gegevens. Geheugenhiërarchie scheidt de opslag op basis van de hiërarchie van de responstijd van de processen.

Instructieset Architectuur

Aangezien het programma (code) in het geheugen van het systeem (RAM) wordt geladen, wordt het opgehaald door de CPU (verwijzend naar zowel de microprocessor als de microcontroller) om op de gegevens te reageren, het lijkt veel op het feit dat we instructies geven wanneer we de hond trainen voor bepaalde acties en commando's. Omdat die instructies op bepaalde transistors worden uitgevoerd, gaan ze van het ene logische niveau naar het andere om dat te laten gebeuren. Dus eigenlijk communiceert de menselijke programmeur met behulp van instructies met de processor. Elke CPU heeft zijn eigen instructieset, een verzameling instructies op basis van zijn architectuur en mogelijkheden.

CPU begrijpt deze instructies in de combinatie van nullen en 1, die ook bekend staan ​​als een opcode. Voor een menselijke programmeur is het erg moeilijk om de combinatie van nullen en enen te onthouden voor elke instructie die aan de CPU is gekoppeld. Om het werk van een menselijke programmeur gemakkelijk te houden, zijn we voorzien van interfaces op hoog niveau van deze instructies en de compiler converteert ze in de vorm van nullen en enen voor de verwerking ervan. Ook in de instructieset van elke CPU heeft het een beperkt aantal instructies die het kan begrijpen.

Prestaties van CPU

Je hebt misschien de term kloksnelheid van CPU gehoord die verband houdt met de prestaties van de CPU. CPU's hebben over het algemeen een kloksnelheid in MHz (Mega-Hertz) of GHz (Giga-Hertz), zoals een kloksnelheid van 25 GHz. Het getal dat aan de kloksnelheid is gekoppeld, geeft aan hoe vaak de klok in de CPU tikt in cycli per seconde. De bruikbaarheid van de kloksnelheid kan worden begrepen door het feit dat instructies worden uitgevoerd op basis van klokcycli van de CPU die evenredig is met het aantal programma's dat de CPU tegelijkertijd kan uitvoeren.

De prestaties van de CPU zijn afhankelijk van het aantal instructies dat in het programma is geschreven, meer instructies, meer tijd die de CPU nodig heeft om ze uit te voeren. Het hangt ook af van het aantal klokcycli waarin elke instructie wordt uitgevoerd, bepaalde instructies hebben meer klokcycli nodig om te worden uitgevoerd dan andere, zodat ze achterlopen op de prestaties van de CPU. Instructies in een programma en cycli die nodig zijn om elke instructie uit te voeren, zijn omgekeerd evenredig met elkaar. Het veranderen van de een heeft invloed op de ander. Dit is het punt waarop de CPU-industrie is verdeeld.

RISC- en CISC-instructiesetarchitectuur

Zoals hierboven vermeld, hangt de uitvoering van een programma en de prestaties van de CPU af van het aantal instructies in een programma waarin de instructies aan die specifieke CPU worden voorgesteld als onderdeel van de instructieset en de tweede factor is het aantal klokcycli in die elke instructie wordt uitgevoerd. Op basis van deze twee factoren zijn er momenteel twee instructiesets beschikbaar. De eerste daarvan is Complex Instruction Set Computing (CISC), terwijl de andere Reduced Instruction Set Computing (RISC) is. Laten we elk van deze architectuur in detail bespreken om het verschil tussen RIC- en CISC-architectuur te begrijpen.

Complex Instruction Set Computing (CISC)

CISC staat voor Complex Instruction Set Computing. Het belangrijkste motief van CISC is om het aantal instructies dat een programma uitvoert te verminderen, dit wordt gedaan door vele eenvoudige instructies zoals adresmodus, laden, etc. te combineren en om een ​​enkele complexe instructie te vormen. De CISC-instructie bevat een reeks eenvoudige instructies en enkele speciale instructies die meer dan één klokcyclus nodig hebben om uit te voeren. De CISC-instructies kunnen direct in het geheugen werken zonder tussenkomst van registers, wat betekent dat het de behoefte aan enkele basisinstructies zoals het laden van waarden en de vereiste geheugen (RAM) elimineert. CISC-instructies leggen meer de nadruk op hardware dan op de software, wat betekent dat in plaats van de compilers te belasten,CISC gebruikt transistors als hardware voor het decoderen en implementeren van instructies. Omdat instructies echter complex zijn en uit meerdere stappen bestaan, worden ze in een groter aantal klokcycli uitgevoerd.

Een eenvoudige analogie te relateren is wanneer je verteld wordt om het boek te openen en lees de 3 ^rd hoofdstuk's 2 ^nd pagina. In deze reeks activiteiten voer je meerdere stappen uit, zoals het vinden van het boek uit je tas, dan de pagina door elkaar schuiven naar hoofdstuk 3 en dan naar de 2 ^e pagina van het hoofdstuk gaan en dan beginnen met lezen. Als de reeks van een stap wordt gecombineerd in een enkele instructie voor het lezen van pagina 44 (dat is het 2 ^e paginanummer van het 3 ^e hoofdstuk), krijgen we een CISC-instructie.

Reduced Instruction Set Computing (RISC)

De eerste geïntegreerde chip werd in 1958 ontworpen door Jack Kilby en was een oscillator en in 1970 kwam de eerste commerciële microprocessor van Intel. Hoewel er aan het begin van de processors geen CISC was. Maar met de zware computervereisten werd de CISC-architectuur complexer en moeilijker te hanteren. Een totaal nieuw ontwerp van de CISC-architectuur, bekend als RISC, kwam van IBM door John Coke. Om onderscheid te maken tussen de twee architecturen werden de termen RISC en CISC geïntroduceerd.

RISC staat voor computergebruik met gereduceerde instructieset. Het belangrijkste motief van RISC was het introduceren van uniformiteit in de omvang en uitvoering van instructies. Dit werd gedaan door een eenvoudige instructieset te introduceren die als één instructie per cyclus zou kunnen worden uitgevoerd, dit wordt gedaan door complexe instructies, zoals laden en opslaan, te breken in verschillende instructies, waarbij elke instructie ongeveer één klokcyclus nodig heeft om uit te voeren. De RISC-architectuur bevat eenvoudige instructies van dezelfde grootte die in een enkele klokcyclus kunnen worden uitgevoerd. Op RISC gebaseerde machines hebben meer RAM nodig dan CISC om de waarden vast te houden terwijl elke instructie in registers wordt geladen. Het uitvoeren van een enkele instructie per cyclus geeft op RISC gebaseerde machines het voordeel van pipelining(pipelining is het proces waarin de volgende instructie wordt geladen voordat de eerste instructie wordt uitgevoerd, dit verhoogt de efficiëntie van de uitvoering). RISC-architectuur benadrukt