Worldlex Wiki Logé dans une mémoire spéciale à haute vitesse, le microcode traduit les instructions machine, les données de l'automate ou d'autres entrées en séquences d'opérations détaillées au niveau du circuit. Il dissocie les instructions machine de l' électronique sous-jacente , offrant ainsi une plus grande flexibilité dans la conception et la modification des instructions. De plus, il facilite la construction d'instructions complexes à plusieurs étapes, tout en réduisant la complexité des circuits informatiques. L'écriture du microcode est souvent appelée microprogrammation , et le microcode d'une implémentation de processeur spécifique est parfois appelé microprogramme .
Through extensive microprogramming, microarchitectures of smaller scale and simplicity can emulate more robust architectures with wider word lengths, additional execution units, and so forth. This approach provides a relatively straightforward method of ensuring software compatibility between different products within a processor family.
arithmetic logic unit (ALU) which performs instructions such as addition or comparing two numbers, circuits for reading and writing data to external memory, and small areas of onboard memory to store these values while they are being processed. In most designs, additional high-performance memory, the register file, is used to store temporary values, not just those needed by the current instruction.To properly perform an instruction, the various circuits have to be activated in order. For instance, it is not possible to add two numbers if they have not yet been loaded from memory. In RISC designs, the proper ordering of these instructions is largely up to the programmer, or at least to the compiler of the programming language they are using. So to add two numbers in memory and store the result in memory, for instance, the compiler may output instructions to load one of the values into one register, the second into another, perform the addition function in the ALU, putting the result into a register, and then store that register into memory.
As the sequence of instructions needed to complete this higher-level concept, "add these two numbers in memory", may require multiple instructions, this can represent a performance bottleneck if those instructions are stored in main memory. Reading those instructions one by one takes time that could be used to read and write the actual data. For this reason, it is common for non-RISC designs to have many different instructions that differ largely on where they store data. For instance, the MOS 6502 has eight variations of the addition instruction, code opération », qui correspond le mieux à l'opération finale permet de réduire le nombre d'instructions à une seule, ce qui économise la mémoire utilisée par le code du programme et améliore les performances en libérant le bus de données pour d'autres opérations. En interne, cependant, ces instructions ne sont pas des opérations distinctes, mais des séquences d'opérations que les unités exécutent réellement. La conversion d'une instruction unique lue en mémoire en une séquence d'actions internes est la tâche de l' unité de contrôle , une autre unité du processeur.
Microcode
L'idée fondamentale du microcode est de remplacer la logique matérielle personnalisée qui implémente le séquencement des instructions par une série d'instructions simples exécutées par un « moteur de microcode » au sein du processeur. Alors qu'un système logique personnalisé peut comporter des diodes et des portes logiques générant des tensions sur différentes lignes de contrôle, le moteur de microcode est connecté à ces lignes, qui sont activées et désactivées au fur et à mesure de la lecture des instructions de microcode. Ces instructions sont souvent codées par bits sur ces lignes ; par exemple, si le bit 8 est à 1, cela peut signifier que l'UAL doit être mise en pause en attente de données. À cet égard, le microcode est comparable aux rouleaux de papier d'un piano mécanique , où les perforations indiquent la touche à presser.
La distinction entre la logique personnalisée et le microcode peut sembler minime : la première utilise un réseau de diodes et de portes logiques pour décoder l’instruction et produire une séquence de signaux, tandis que la seconde encode les signaux sous forme de micro-instructions lues séquentiellement pour produire les mêmes résultats. La différence cruciale réside dans le fait que, dans une conception logique personnalisée, toute modification des étapes individuelles nécessite une refonte du matériel. Avec le microcode, seul le code stocké en mémoire ou le périphérique de stockage depuis lequel le microcode est chargé dans la mémoire de contrôle est modifié. Ceci facilite grandement la résolution des problèmes dans un système à microcode. Cela signifie également qu’il n’existe aucune limite à la complexité des instructions ; celle-ci est uniquement limitée par la quantité de mémoire allouée.
La couche la plus basse de la pile logicielle d'un ordinateur est traditionnellement constituée des instructions brutes en code machine destinées au processeur. Dans les processeurs microcodés, l'extraction, le décodage et l'exécution de ces instructions peuvent être effectués par le microcode. Afin d'éviter toute confusion, chaque élément lié au microprogramme est différencié par le préfixe « micro » : micro-instruction, micro-assembleur, microprogrammeur, etc.
Complex digital processors may also employ more than one (possibly microcode-based) control unit in order to delegate sub-tasks that must be performed essentially asynchronously in parallel. For example, the VAX 9000 has a hardwired IBox unit to fetch and decode instructions, which it hands to a microcoded EBox unit to be executed, and the VAX 8800 has both a microcoded IBox and a microcoded EBox.
A high-level programmer, or even an assembly language programmer, does not normally see or change microcode. Unlike machine code, which often retains some backward compatibility among different processors in a family, microcode only runs on the exact electronic circuitry for which it is designed, as it constitutes an inherent part of the particular processor design itself.
Design
Engineers normally write the microcode during the design phase of a processor, storing it in a read-only memory (ROM) or programmable logic array (PLA) structure, or in a combination of both. However, machines also exist that have some or all microcode stored in static random-access memory (SRAM) or flash memory. This is traditionally denoted as writable control store in the context of computers, which can be either read-only or read–write memory. In the latter case, the CPU initialization process loads microcode into the control store from another storage medium, with the possibility of altering the microcode to correct bugs in the instruction set, or to implement new machine instructions.
Microprograms
Microprograms consist of series of microinstructions, which control the CPU at a very fundamental level of hardware circuitry. For example, a single typical horizontal microinstruction might specify the following operations simultaneously:
- Connect register 1 to the A side of the ALU
- Connect register 7 to the B side of the ALU
- Set the ALU to perform two's-complement addition
- Set the ALU's carry input to zero
- Connect the ALU output to register 8
- Update the condition codes from the ALU status flags (negative, zero, overflow, and carry)
- Microjump to a given μPC address for the next microinstruction
Pour contrôler simultanément toutes les fonctionnalités du processeur en un seul cycle, la micro-instruction est souvent plus large que 50 bits ; par exemple, 128 bits sur un 360/85 avec émulateur. Les microprogrammes sont conçus et optimisés avec soin pour une exécution aussi rapide que possible, car un microprogramme lent entraînerait une instruction machine lente et une dégradation des performances des applications qui utilisent ces instructions.
Justification
Le microcode a été initialement développé comme une méthode plus simple pour concevoir la logique de contrôle d'un ordinateur. Au départ, les jeux d'instructions des processeurs étaient câblés . Chaque étape nécessaire à l'extraction, au décodage et à l'exécution des instructions machine (y compris les calculs d'adresses d'opérandes, les lectures et les écritures) était contrôlée directement par une logique combinatoire et un circuit de machine à états séquentielle relativement minimal . Bien que ces processeurs câblés fussent très efficaces, la nécessité de jeux d'instructions puissants, avec un adressage multi-étapes et des opérations complexes ( voir ci-dessous ), rendait leur conception et leur débogage difficiles ; des instructions fortement encodées et de longueur variable peuvent également contribuer à cette difficulté, en particulier lorsque des encodages très irréguliers sont utilisés.
Le microcode a simplifié la tâche en permettant de définir une grande partie du comportement et du modèle de programmation du processeur via des routines de microprogramme plutôt que par des circuits dédiés. Même en fin de conception, le microcode pouvait être facilement modifié, contrairement aux processeurs câblés, dont la modification était très complexe. Ainsi, la conception des processeurs s'en est trouvée grandement facilitée.
Des années 1940 à la fin des années 1970, une grande partie de la programmation était réalisée en langage assembleur . Les instructions de haut niveau permettant une productivité accrue des programmeurs, un avantage important du microcode résidait dans la relative facilité avec laquelle des instructions machine puissantes pouvaient être définies. L'aboutissement de cette approche est l'architecture « Directly Executable High Level Language » (DEL), dans laquelle chaque instruction d'un langage de haut niveau tel que PL/I est exécutée intégralement et directement par le microcode, sans compilation. Le projet IBM Future Systems et le processeur Fountainhead de Data General en sont des exemples. Au cours des années 1970, la vitesse des processeurs a progressé plus rapidement que celle de la mémoire, et de nombreuses techniques, telles que le transfert de blocs mémoire , la prélecture de la mémoire et les caches multiniveaux, ont été utilisées pour pallier ce problème. Les instructions machine de haut niveau, rendues possibles par le microcode, ont apporté une contribution supplémentaire, car des instructions machine moins nombreuses mais plus complexes nécessitent moins de bande passante mémoire. Par exemple, une opération sur une chaîne de caractères peut être effectuée par une seule instruction machine, évitant ainsi de multiples accès à la mémoire.
Les architectures dotées de jeux d'instructions implémentés par des microprogrammes complexes comprenaient l' IBM System/360 et le VAX de Digital Equipment Corporation . L'approche consistant à implémenter des jeux d'instructions de plus en plus complexes dans un microcode a été ultérieurement appelée ordinateur à jeu d'instructions complexe (CISC). Une approche alternative, utilisée dans de nombreux microprocesseurs , consiste à utiliser une ou plusieurs matrices logiques programmables (PLA) ou mémoires mortes (ROM) (au lieu de la logique combinatoire) principalement pour le décodage des instructions, et à laisser une machine à états finis simple (avec peu ou pas de microcode) effectuer la majeure partie du séquencement. Le MOS Technology 6502 est un exemple de microprocesseur utilisant une PLA pour le décodage et le séquencement des instructions. La PLA est visible sur les photomicrographies de la puce , et son fonctionnement peut être observé dans la simulation au niveau transistor .
La microprogrammation est encore utilisée dans la conception des processeurs modernes. Dans certains cas, après le débogage du microcode par simulation, des fonctions logiques remplacent la mémoire de contrôle. Ces fonctions logiques sont souvent plus rapides et moins coûteuses que la mémoire de microprogramme équivalente.System/360 Model 30 has 8-bit data paths to the arithmetic logic unit (ALU) and main memory and implemented the general-purpose registers in a special unit of higher-speed core memory, and the System/360 Model 40 has 8-bit data paths to the ALU and 16-bit data paths to main memory and also implemented the general-purpose registers in a special unit of higher-speed core memory. The Model 50 has full 32-bit data paths and implements the general-purpose registers in a special unit of higher-speed core memory. The Model 65 through the Model 195 have larger data paths and implement the general-purpose registers in faster transistor circuits.Digital Equipment CorporationPDP-11 is a 16-bit architecture with eight general-purpose registers. It was introduced in 1970 and the basic architecture remained unchanged through the 1990s. Only the original machine in the series was not microcoded. From the years 1972 to 1976, the width of the PDP-11's underlying microprogram varied from 22 to 64 bits. The length of the microprogram varied from 256 to 1,024 words with longer microprogram lengths generally corresponding to narrower widths. The variety of microprogram widths imply that there were at least seven different implementations of the PDP-11 in just four years.
A similar approach was used by Digital Equipment Corporation in their VAX family of computers. As a result, different VAX processors use different microarchitectures, yet the programmer-visible architecture does not change.
Microprogramming also reduces the cost of field changes to correct defects (bugs) in the processor; a bug can often be fixed by replacing a portion of the microprogram rather than by changes being made to hardware logic and wiring.
History
Early examples
The ACE computer, designed by Alan Turing in 1946, used microprogramming.
En 1947, la conception du MIT Whirlwind a introduit le concept de mémoire de contrôle afin de simplifier la conception des ordinateurs et de s'affranchir des méthodes empiriques . Cette mémoire de contrôle est une matrice de diodes : un réseau bidimensionnel dont une dimension reçoit les impulsions temporelles de contrôle provenant de l'horloge interne du processeur, et l'autre est connectée aux signaux de contrôle des portes logiques et autres circuits. Un distributeur d'impulsions reçoit les impulsions générées par l' horloge du processeur et les divise en huit impulsions temporelles distinctes, chacune activant une ligne différente du réseau. Lorsqu'une ligne est activée, elle active les signaux de contrôle qui y sont connectés.
En 1951, Maurice Wilkes a enrichi ce concept en y ajoutant l'exécution conditionnelle , un concept similaire à celui des instructions conditionnelles en informatique. Son implémentation initiale consistait en deux matrices : la première générait des signaux à la manière de la mémoire de contrôle Whirlwind, tandis que la seconde sélectionnait la ligne de signaux (l'instruction du microprogramme, en quelque sorte) à exécuter au cycle suivant. Les conditions étaient implémentées en permettant à une seule ligne de la mémoire de contrôle de choisir parmi les alternatives de la seconde matrice. Ainsi, les signaux de contrôle dépendaient du signal interne détecté. Wilkes a forgé le terme « microprogrammation » pour décrire cette fonctionnalité et la distinguer d'une simple mémoire de contrôle.
Le 360
But the real value in the 360 line was that one could build a series of machines that were completely different internally, yet run the same ISA. For a low-end machine, one might use an 8-bit ALU that requires multiple cycles to complete a single 32-bit addition, while a higher end machine might have a full 32-bit ALU that performs the same addition in a single cycle. These differences could be implemented in control logic, but the cost of implementing a completely different decoder for each machine would be prohibitive. Using microcode meant all that changed was the code in the ROM. For instance, one machine might include a floating point unit and thus its microcode for multiplying two numbers might be only a few lines long, whereas on the same machine without the FPU this would be a program that did the same using multiple additions, and all that changed was the ROM.
The outcome of this design was that customers could use a low-end model of the family to develop their software, knowing that if more performance was ever needed, they could move to a faster version and nothing else would change. This lowered the barrier to entry and the 360 was a runaway success. By the end of the decade, the use of microcode was de rigueur across the mainframe industry.
Moving up the line
Early minicomputers were far too simple to require microcode, and were more similar to earlier mainframes in terms of their instruction sets and the way they were decoded. But it was not long before their designers began using more powerful integrated circuits that allowed for more complex ISAs. By the mid-1970s, most new minicomputers and superminicomputers were using microcode as well, such as most models of the PDP-11 and, most notably, most models of the VAX, which included high-level instruction not unlike those found in the 360.
The same basic evolution occurred with microprocessors as well. Early designs were extremely simple, and even the more powerful 8-bit designs of the mid-1970s like the Zilog Z80 had instruction sets that were simple enough to be implemented in dedicated logic. By this time, the control logic could be patterned into the same die as the CPU, making the difference in cost between ROM and logic less of an issue. However, it was not long before these companies were also facing the problem of introducing higher-performance designs but still wanting to offer backward compatibility. Among early examples of microcode in micros was the Intel 8086.
Among the ultimate implementations of microcode in microprocessors is the Motorola 68000. This offered a highly orthogonal instruction set with a wide variety of addressing modes, all implemented in microcode. This did not come without cost, according to early articles, about 20% of the chip's surface area (and thus cost) is the microcode system and telephone switch, a team led by John Cocke began examining huge volumes of performance data from their customer's 360 (and System/370) programs. This led them to notice a curious pattern: when the ISA presented multiple versions of an instruction, the compiler almost always used the simplest one, instead of the one most directly representing the code. They learned that this was because those instructions were always implemented in hardware, and thus run the fastest. Using the other instruction might offer higher performance on some machines, but there was no way to know what machine they were running on. This defeated the purpose of using microcode in the first place, which was to hide these distinctions.
The team came to a radical conclusion: "Imposing microcode between a computer and its users imposes an expensive overhead in performing the most frequently executed instructions."
The result of this discovery was what is today known as the RISC concept. The complex microcode engine and its associated ROM is reduced or eliminated completely, and those circuits instead dedicated to things like additional registers or a wider ALU, which increases the performance of every program. When complex sequences of instructions are needed, this is left to the compiler, which is the entire purpose of using a compiler in the first place. The basic concept was soon picked up by university researchers in California, where simulations suggested such designs would trivially outperform even the fastest conventional designs. It was one such project, at the University of California, Berkeley, that introduced the term RISC.
The industry responded to the concept of RISC with both confusion and hostility, including a famous dismissive article by the VAX team at Digital. A major point of contention was that implementing the instructions outside of the processor meant it would spend much more time reading those instructions from memory, thereby slowing overall performance no matter how fast the CPU itself ran. Proponents pointed out that simulations clearly showed the number of instructions was not much greater, especially when considering compiled code.
The debate raged until the first commercial RISC designs emerged in the second half of the 1980s, which easily outperformed the most complex designs from other companies. By the late 1980s it was over; even DEC was abandoning microcode for their DEC Alpha designs, and CISC processors switched to using hardwired circuitry, rather than microcode, to perform many functions. For example, the Intel 80486 uses hardwired circuitry to fetch and decode instructions, using microcode only to execute instructions; register-register move and arithmetic instructions required only one microinstruction, allowing them to be completed in one clock cycle. The Pentium Pro's fetch and decode hardware fetches instructions and decodes them into series of micro-operations that are passed on to the execution unit, which schedules and executes the micro-operations, possibly doing so out-of-order. Complex instructions are implemented by microcode that consists of predefined sequences of micro-operations.
Certains processeurs utilisent du code machine s'exécutant dans un mode spécial, avec des instructions spécifiques, disponibles uniquement dans ce mode, qui accèdent à du matériel dépendant du processeur, afin d'implémenter certaines fonctionnalités de bas niveau du jeu d'instructions. Le DEC Alpha, une architecture RISC pure, utilisait du PALcode pour implémenter des fonctionnalités telles que la gestion des défauts de tampon de traduction (TLB) et la gestion des interruptions , et fournissait également, pour les systèmes basés sur Alpha exécutant OpenVMS , des instructions nécessitant un accès mémoire interverrouillé, similaires à celles fournies par l' architecture VAX . Les processeurs CMOS IBM System/390 , à partir du processeur G4, et les processeurs d'architecture z/ utilisent du millicode pour implémenter certaines instructions
Exemples
- La machine analytique imaginée par Charles Babbage utilise des chevilles insérées dans des tambours rotatifs pour stocker ses procédures internes.
- L' EMIDEC 1100 utilise, semble-t-il, un magasin de contrôle câblé constitué de fils passant à travers des noyaux de ferrite, connus sous le nom de « lacets ».
- La plupart des modèles de la série IBM System/360 sont microprogrammés :
- Le modèle 25 est unique parmi les modèles System/360 car il utilise les 16 Ko supérieurs de la mémoire centrale pour stocker le code de contrôle du microprogramme. Le 25 utilise une microarchitecture 16 bits avec sept mots de contrôle (ou micro-instructions). Après une opération de maintenance système ou un changement de mode de fonctionnement, le microcode est chargé à partir du lecteur de cartes, de la bande magnétique ou d'un autre périphérique. L' émulation IBM 1410 pour ce modèle est chargée de cette manière.
- Le modèle 30 utilise une microarchitecture 8 bits avec seulement quelques registres matériels ; tout ce que le programmeur voyait est émulé par le microprogramme. Le microcode de ce modèle est également stocké sur des cartes perforées spéciales, intégrées à la machine dans un lecteur dédié par carte, appelé « unité CROS » (Capacitor Read-Only Storage). Une unité CROS supplémentaire est ajoutée pour les machines commandées avec l’émulation 1401/1440/1460 et pour celles commandées avec l’émulation 1620.
- The Model 40 uses 56-bit control words. The 2040 box implements both the System/360 main processor and the multiplex channel (the I/O processor). This model uses TROS dedicated readers similar to CROS units, but with an inductive pickup (Transformer Read-only Store).
- The Model 50 has two internal datapaths which operated in parallel: a 32-bit datapath used for arithmetic operations, and an 8-bit data path used in some logical operations. The control store uses 90-bit microinstructions.
- The Model 85 has separate instruction fetch (I-unit) and execution (E-unit) to provide high performance. The I-unit is hardware controlled. The E-unit is microprogrammed; the control words are 108 bits wide on a basic 360/85 and wider if an emulator feature is installed.
- The NCR 315 is microprogrammed with hand wired ferrite cores (a ROM) pulsed by a sequencer with conditional execution. Wires routed through the cores are enabled for various data and logic elements in the processor.
- The Digital Equipment Corporation PDP-9 processor, KL10 and KS10 PDP-10 processors, and PDP-11 processors with the exception of the PDP-11/20, are microprogrammed.
- Most Data General Eclipse minicomputers are microprogrammed. The task of writing microcode for the Eclipse MV/8000 is detailed in the Pulitzer Prize-winning book titled The Soul of a New Machine.
- Many systems from Burroughs are microprogrammed:
- The B700 "microprocessor" execute application-level opcodes using sequences of 16-bit microinstructions stored in main memory; each of these is either a register-load operation or mapped to a single 56-bit "nanocode" instruction stored in read-only memory. This allows comparatively simple hardware to act either as a mainframe peripheral controller or to be packaged as a standalone computer.
- The B1700 is implemented with radically different hardware including bit-addressable main memory but has a similar multi-layer organisation. The operating system preloads the interpreter for whatever language is required. These interpreters present different virtual machines for COBOL, Fortran, etc.
- Microdata produced computers in which the microcode is accessible to the user; this allows the creation of custom assembler level instructions. Microdata's Reality operating system design makes extensive use of this capability.
- La station de travail Xerox Alto utilisait une architecture microcodée, mais contrairement à de nombreux ordinateurs, le moteur de microcode n'était pas dissimulé au programmeur par une architecture en couches. Les applications tirent parti de cette architecture pour optimiser les performances.
- Le système IBM System/38 est décrit comme possédant à la fois un microcode horizontal et vertical . En pratique, le processeur implémente une architecture de jeu d'instructions appelée Interface Microprogrammée Interne (IMPI) utilisant un format de microcode horizontal. La couche de microcode verticale implémente le jeu d'instructions d'Interface Machine (MI) indépendant du matériel du System/38 en traduisant le code MI en code IMPI et en l'exécutant. Avant l'introduction de la gamme de processeurs IBM RS64 , les premiers systèmes IBM AS/400 utilisaient la même architecture.
- Le coprocesseur de réalité (RCP) de la Nintendo 64 , qui fait office d' unité de traitement graphique et de processeur audio, utilise du microcode ; il est possible d'implémenter de nouveaux effets ou d'ajuster le processeur pour obtenir le résultat souhaité. Parmi les exemples notables de microcode RCP personnalisé, on peut citer les graphismes haute résolution, les moteurs de particules et les distances d'affichage illimitées présents dans Indiana Jones and the Infernal Machine , Star Wars: Rogue Squadron et Star Wars: Battle for Naboo de Factor 5 ; ainsi que la lecture vidéo en plein écran de Resident Evil 2 d' Angel Studios .
Il peut également y avoir un registre d'adresse mémoire et un registre de données mémoire , utilisés pour accéder à la mémoire principale de l'ordinateur . Ensemble, ces éléments forment une « unité d'exécution ». La plupart des processeurs modernes possèdent plusieurs unités d'exécution. Même les ordinateurs simples disposent généralement d'une unité pour lire et écrire en mémoire, et d'une autre pour exécuter le code utilisateur. Ces éléments peuvent souvent être intégrés sur une seule puce. Cette puce a une largeur fixe qui forme une « tranche » au sein de l'unité d'exécution. On les appelle des puces « à tranches de bits ». La famille AMD Am2900 est l'un des exemples les plus connus de puces à tranches de bits. Les différentes parties des unités d'exécution et l'unité d'exécution complète sont interconnectées par un faisceau de fils appelé bus .
Les programmeurs développent des microprogrammes à l'aide d'outils logiciels de base. Un microassembleur permet de définir symboliquement la table des bits. Du fait de sa forte dépendance à l'architecture sous-jacente, « le microcode présente plusieurs propriétés qui rendent sa génération par compilation complexe » Un simulateur exécute les bits de la même manière que l'électronique et offre une plus grande liberté pour le débogage du microprogramme. Une fois le microprogramme finalisé et testé de manière approfondie, il sert parfois d'entrée à un programme informatique qui construit la logique permettant de produire les mêmes données. Ce programme est similaire à ceux utilisés pour optimiser un réseau logique programmable . Même sans logique parfaitement optimale, une logique optimisée heuristiquement peut réduire considérablement le nombre de transistors nécessaires pour une mémoire morte (ROM). Cela diminue le coût de production et la consommation électrique d'un processeur.
Le microcode peut être qualifié d' horizontal ou de vertical , selon que chaque micro-instruction contrôle des éléments du processeur avec un décodage minimal, voire inexistant (microcode horizontal) , ou qu'elle nécessite un décodage important par logique combinatoire au préalable (microcode vertical). Par conséquent, chaque micro-instruction horizontale est plus large (contient plus de bits) et occupe plus d'espace de stockage qu'une micro-instruction verticale.
Microcode horizontal
Le microcode horizontal comprend plusieurs micro-opérations discrètes combinées en une seule micro-instruction pour un fonctionnement simultané. Ce microcode est généralement stocké dans une mémoire de contrôle relativement large ; il n’est pas rare que chaque mot fasse 108 bits ou plus. À chaque impulsion de l’horloge du séquenceur, un mot de microcode est lu, décodé et utilisé pour contrôler les éléments fonctionnels qui constituent le processeur.
Dans une implémentation typique, un mot de microprogramme horizontal comprend des groupes de bits assez précisément définis. Par exemple, une configuration simple pourrait être :
| Source du registre A | Source du registre B | Registre de destination | Opérations des unités arithmétiques et logiques | Type de saut | Adresse de saut |
Pour que ce type de micromachine implémente une instruction JUMP avec l'adresse suivant le code opération, le microcode peut nécessiter deux cycles d'horloge. L'ingénieur qui la conçoit écrirait un code source en microassembleur ressemblant à ceci :
For each tick it is common to find that only some portions of the CPU are used, with the remaining groups of bits in the microinstruction being no-ops. With careful design of hardware and microcode, this property can be exploited to parallelise operations that use different areas of the CPU; for example, in the case above, the ALU is not required during the first tick, so it could potentially be used to complete an earlier arithmetic instruction.
Vertical microcode
En microcode vertical, chaque micro-instruction est encodée de manière significative : les champs de bits transitent généralement par une logique combinatoire intermédiaire qui génère les signaux de contrôle et de séquencement pour les éléments internes du processeur (UAL, registres, etc.). Ceci contraste avec le microcode horizontal, dans lequel les champs de bits produisent directement les signaux de contrôle et de séquencement ou ne sont encodés que de manière minimale. Par conséquent, le microcode vertical nécessite des instructions plus courtes et moins d’espace de stockage, mais requiert un temps de décodage plus long, ce qui entraîne une fréquence d’horloge du processeur plus basse.
Certains microcodes verticaux ne sont autres que le langage assembleur d'un ordinateur conventionnel simple émulant un ordinateur plus complexe. Certains processeurs, tels que les processeurs DEC Alpha et les microprocesseurs CMOS des derniers mainframes IBM System/390 et z/Architecture , utilisent du code machine, exécuté dans un mode spécial lui donnant accès à des instructions, des registres et d'autres ressources matérielles spécifiques, inaccessibles au code machine classique, pour implémenter certaines instructions et fonctions , comme les parcours de table des pages sur les processeurs Alpha . Ce code est appelé PALcode sur les processeurs Alpha et millicode sur les processeurs des mainframes IBM.
Une autre forme de microcode vertical comporte deux champs :
| Sélection du champ | Valeur du champ |
Le champ de sélection détermine la partie du processeur qui sera contrôlée par ce mot de la mémoire de contrôle. La valeur de ce champ contrôle cette partie du processeur. Avec ce type de microcode, le concepteur choisit délibérément de créer un processeur plus lent afin de réaliser des économies en réduisant le nombre de bits inutilisés dans la mémoire de contrôle ; toutefois, la complexité réduite peut augmenter la fréquence d'horloge du processeur, ce qui atténue l'effet d'une augmentation du nombre de cycles par instruction.
Avec la baisse du prix des transistors, le microcode horizontal a fini par dominer la conception des processeurs utilisant le microcode, tandis que le microcode vertical était de moins en moins utilisé.
Lorsque le microcode vertical et horizontal est utilisé, le microcode horizontal peut être appelé nanocode ou picocode .
des mémoires de contrôle inscriptibles ; il existe également des machines commerciales qui utilisent du microcode inscriptible, telles que les Burroughs Small Systems , les premières stations de travail Xerox , la famille DEC VAX 8800 ( Nautilus ), les machines Symbolics L et G, un certain nombre d'implémentations IBM System/360 et System/370 , certaines machines DEC PDP-10 , et le Data General Eclipse MV/8000 . Le système IBM/370 comprend une fonction appelée Initial-Microprogram Load ( IML ou IMPL ) qui peut être invoquée depuis la console, dans le cadre d'une réinitialisation à la mise sous tension ( POR ) ou depuis un autre processeur dans un complexe multiprocesseur étroitement couplé .
Certaines machines commerciales, par exemple IBM 360/85, disposent à la fois d'un stockage en lecture seule et d'un stockage de contrôle inscriptible pour le microcode.
Le WCS offre plusieurs avantages, notamment la facilité de modification du microprogramme et, pour certaines générations de matériel, un accès plus rapide que celui des ROM. Programmable par l'utilisateur, le WCS permet d'optimiser la machine pour des applications spécifiques.
Depuis le Pentium Pro en 1995, plusieurs processeurs x86 intègrent un microcode Intel modifiable . Ceci a permis, par exemple, de corriger les bogues des microcodes Intel Core 2 et Intel Xeon en appliquant des correctifs à leurs microprogrammes, plutôt que de remplacer l'intégralité des puces. Autre exemple notable : les correctifs de microcode proposés par Intel pour certaines de ses architectures de processeurs, vieilles de près de dix ans, afin de contrer les failles de sécurité Spectre et Meltdown , révélées au public début 2018. Une mise à jour du microcode peut être installée par Linux, FreeBSD , Microsoft Windows, ou le BIOS de la carte mère.
Some machines offer user-programmable writable control stores as an option, including the HP 2100, DEC PDP-11/60, TI-990/12, and Varian Data Machines V-70 series minicomputers. WCS options extended down to microprocessors too. The DEC LSI-11 has an option to allow programming of the internal 8-bit micromachine to create application-specific extensions to the instruction set.
Some microcode peripheral devices and adapters have writable microcode, which is usually loaded by an operating system device driver. Such microcode is loaded to the device's SRAM or DRAM, for example, GDDR SDRAM of a video card.RISC design philosophy started becoming more prominent.
A CPU that uses microcode generally takes several clock cycles to execute a single instruction, one clock cycle for each step in the microprogram for that instruction. Some CISC processors include instructions that can take a very long time to execute. Such variations interfere with both interrupt latency and, what is far more important in modern systems, pipelining.
When designing a new processor, a hardwired control RISC has the following advantages over microcoded CISC:
- Programming has largely moved away from assembly level, so it's no longer worthwhile to provide complex instructions for productivity reasons.
- Simpler instruction sets allow direct execution by hardware, avoiding the performance penalty of microcoded execution.
- Analysis shows complex instructions are rarely used, hence the machine resources devoted to them are largely wasted.
- The machine resources devoted to rarely used complex instructions are better used for expediting performance of simpler, commonly used instructions.
- Complex microcoded instructions may require many clock cycles that vary, and are difficult to pipeline for increased performance.
There are counterpoints as well:
- The complex instructions in heavily microcoded implementations may not take much extra machine resources, except for microcode space. For example, the same ALU is often used to calculate an effective address and to compute the result from the operands, e.g., the original Z80, 8086, and others.
- The simpler non-RISC instructions (i.e., involving direct memory operands) are frequently used by modern compilers. Even immediate to stack (i.e., memory result) arithmetic operations are commonly employed. Although such memory operations, often with varying length encodings, are more difficult to pipeline, it is still fully feasible to do so - clearly exemplified by the i486, AMD K5, Cyrix 6x86, Motorola 68040, etc.
- Non-RISC instructions inherently perform more work per instruction (on average), and are also normally highly encoded, so they enable smaller overall size of the same program, and thus better use of limited cache memories.
Many RISC and VLIW processors are designed to execute every instruction (as long as it is in the cache) in a single cycle. This is very similar to the way CPUs with microcode execute one microinstruction per cycle. VLIW processors have instructions that behave similarly to very wide horizontal microcode, although typically without such fine-grained control over the hardware as provided by microcode. RISC instructions are sometimes similar to the narrow vertical microcode.
Micro-operations
Modern CISC implementations, such as the x86 family starting with the NexGen Nx586, Intel Pentium Pro, and AMD K5, decode instructions into dynamically buffered micro-operations with an instruction encoding similar to RISC or traditional microcode. A hardwired instruction decode unit directly emits microoperations for common x86 instructions, but falls back to a more traditional microcode ROM containing microoperations for more complex or rarely used instructions.
Par exemple, un x86 peut rechercher des microopérations dans le microcode pour gérer des opérations complexes à plusieurs étapes telles que les instructions de boucle ou de chaîne, les fonctions transcendantales de l'unité à virgule flottante ou les valeurs inhabituelles telles que les nombres dénormalisés , et les instructions à usage spécial telles que CPUID .
Autres significations du terme « microcode »
PDP-8
Le PDP-8 est une famille de mini-ordinateurs 12 bits lancée par Digital Equipment Corporation en 1965. L' instruction OPR (OPeRate) était alors qualifiée de « microcodée ». Ce terme avait une signification différente de celle qu'on lui attribue aujourd'hui : chaque bit du mot d'instruction spécifie une action précise, et le programmeur pouvait réaliser plusieurs actions en un seul cycle d'instruction en activant plusieurs bits. Parmi ces actions, on peut citer : la remise à zéro de l'accumulateur, le complément de l'accumulateur, la rotation à droite, la double rotation à droite et l'échange d'octets.
micrologiciel embarqué
Certains fabricants de matériel, notamment IBM et Lenovo , utilisent indifféremment les termes « microcode » et « firmware embarqué ». Dans ce contexte, tout code présent dans un périphérique est appelé microcode, qu'il s'agisse de microcode ou de code machine. Par exemple, les mises à jour du microcode d'un disque dur peuvent concerner à la fois son microcode et son firmware. Le firmware embarqué est largement utilisé dans les processeurs dédiés à des applications spécifiques, tels que les processeurs réseau , les processeurs de signaux numériques , les contrôleurs de canaux , les contrôleurs de disques , les contrôleurs d'interface réseau , les contrôleurs de mémoire flash , les unités de traitement graphique ( GPU ) et d'autres matériels.
Micro-operations
Modern CISC implementations, such as the x86 family starting with the NexGen Nx586, Intel Pentium Pro, and AMD K5, decode instructions into dynamically buffered micro-operations with an instruction encoding similar to RISC or traditional microcode. A hardwired instruction decode unit directly emits microoperations for common x86 instructions, but falls back to a more traditional microcode ROM containing microoperations for more complex or rarely used instructions.
Par exemple, un x86 peut rechercher des microopérations dans le microcode pour gérer des opérations complexes à plusieurs étapes telles que les instructions de boucle ou de chaîne, les fonctions transcendantales de l'unité à virgule flottante ou les valeurs inhabituelles telles que les nombres dénormalisés , et les instructions à usage spécial telles que CPUID .
Autres significations du terme « microcode »
PDP-8
Le PDP-8 est une famille de mini-ordinateurs 12 bits lancée par Digital Equipment Corporation en 1965. L' instruction OPR (OPeRate) était alors qualifiée de « microcodée ». Ce terme avait une signification différente de celle qu'on lui attribue aujourd'hui : chaque bit du mot d'instruction spécifie une action précise, et le programmeur pouvait réaliser plusieurs actions en un seul cycle d'instruction en activant plusieurs bits. Parmi ces actions, on peut citer : la remise à zéro de l'accumulateur, le complément de l'accumulateur, la rotation à droite, la double rotation à droite et l'échange d'octets.
micrologiciel embarqué
Certains fabricants de matériel, notamment IBM et Lenovo , utilisent indifféremment les termes « microcode » et « firmware embarqué ». Dans ce contexte, tout code présent dans un périphérique est appelé microcode, qu'il s'agisse de microcode ou de code machine. Par exemple, les mises à jour du microcode d'un disque dur peuvent concerner à la fois son microcode et son firmware. Le firmware embarqué est largement utilisé dans les processeurs dédiés à des applications spécifiques, tels que les processeurs réseau , les processeurs de signaux numériques , les contrôleurs de canaux , les contrôleurs de disques , les contrôleurs d'interface réseau , les contrôleurs de mémoire flash , les unités de traitement graphique ( GPU ) et d'autres matériels.