Microprocesseur à jeu d'instruction étendu

Le premier microprocesseur est l'Intel 4004, d'architecture 4 bits, sorti en 1971, suivi de l'Intel 8008, d'architecture 8 bits, sorti en 1972. Intel sort ensuite en 1974, le 8080, toujours 8 bits, dont le langage assembleur est différent de celui du 8008, mais pose les bases de l'assembleur x86. Différents processeurs concurrents, également d'architecture CISC apparaissent alors, tels que le MOS Technology 6502 (1975) ou le Zilog Z80 (1976), qui équipent la majorité des micro-ordinateurs du début des années 1980.

L'Intel 8086, sorti en 1978 est le premier processeur x86, d'architecture 16 bits. L'unité de calcul en virgule flottante (FPU) n'est alors pas inclus dans le microprocesseur dans ces séries. c'est un circuit intégré séparé et optionnel. Le 8087 est le premier processeur arithmétiques des processeurs 16 bits d'Intel. Les processeurs 16/32 bits (adressage 16 bits, registres 32 bits) des Motorola 68000, sorti en 1979, sont le 68881 et ses successeurs.

Sur tout matériel informatique, le système de démarrage des composants est contenu dans une EEPROM (appelé « BIOS » sur les IBM/PC et compatibles, équipés de processeurs x86 16 bits et supérieurs). Le compilateur étant responsable de convertir toutes les instructions écrites en langages source (Fortran, Cobol, etc.) en langage machine, ce qui pouvait nécessiter des milliers de lignes de code et des compilateurs complexes, avec des ordinateurs avec très peu de mémoire vive, des périphériques assez lents (ruban perforé, carte perforée, bande magnétique, etc.) et/ou de capacité limitée (tambour magnétique, disque dur, etc.).

Avec le développement des capacités de gravure des microprocesseurs, ceux-ci se sont développés pour couvrir de plus en plus d'instructions utilisées dans les langages de programmation. Cela pouvait souvent comprendre :

• les accès aux périphériques (chargement du système en mémoire vive plus lecture/écriture des données) ;
• l'interface homme-machine (clavier, écran, bande magnétique, etc.) ;
• tous les calculs de base mais aussi :
  • les nombres à virgule flottante utilisés dans les calculs scientifiques (à diverses finalités, mathématiques, physique, statistiques, finance, etc.),
  • le calcul des fonctions trigonométriques utilisées, entre autres, en mathématiques,
  • le calcul de fonctions financières utilisées, entre autres, pour les statistiques (moyenne, écart type, etc.),
  • etc.

• L'empreinte mémoire du code est beaucoup plus dense (facteur deux entre de l'ARM thumb et le x86), ce qui est intéressant pour minimiser la taille du cache instruction.
• Possibilité de microprogrammation, donc de corriger le jeu d'instructions (cela peut être utile pour corriger des bugs).
• Permet d'utiliser des instructions très complexes, rendant la tâche des compilateurs plus complexes. En outre, ces instructions prennent du fait de leur microcode plusieurs cycles d'horloge, et sont donc plus lentes que des instructions câblées. Lors de la programmation en assembleur, il est important de connaître le temps pris par chaque instruction pour l'optimisation.

Les instructions de types SIMD (instruction unique, multiples données) ne sont pas spécifiques au CISC, ces instructions sont d'ailleurs d'abord apparues sur des architectures RISC dédiés au calcul, dans ce que l'on appelle un processeur vectoriel, notamment utilisé sur le supercalculateur Cray-1 en 1976. Ce sont des instructions simples (addition, soustraction, multiplications), gérées en parallèle sur plusieurs données, afin d'accélérer les calculs d'algèbre linéaire, fondamentaux en analyse numérique. Elles sont très parallélisables et ne prennent généralement qu'un cycle d'horloge. Dans les années 1990, les processeurs grand public tels que les CISC d'Intel (MMX, puis SSE) ou les RISC de PowerPC (AltiVec) ont intégré des SIMD plus limités que les processeurs vectoriels. Permettant des traitements sur des vecteurs chargés dans les registres des processeurs. Tandis que dans le cas des processeur vectoriels, tels qu'ils sont présents sur les processeurs RISC, comme Cell, dérivé de l'architecture IBM POWER, ou l'extension V de RISC-V, le principe de Cray, plus simple mais plus efficace est repris, on charge dans les registres l'adresse d'une table de vecteur, ainsi que sa taille, puis exécute une instruction vectorielle qui va parcourir toute la table.

• Le microprocesseur est plus compliqué à accélérer (problème pour pipeliner le moteur d'exécution).
• Le processeur est globalement plus complexe qu'un processeur RISC.
• Les compilateurs ont des difficultés à générer des instructions complexes.
• Certaines instructions complexes sont exécutées sur plusieurs cycles d'horloge, dont le nombre peut dépendre des arguments. Il est difficile de prévoir la durée de certains calculs, ce qui peut mener à des problèmes de synchronisation.
• Ces éléments, obligent à multiplier le nombre de transistors au sein de la puce, la rendant plus coûteuse et lui conférant une moins bonne efficacité énergétique.

Cette famille regroupe différents types de processeurs[1], des architectures datant principalement des années 1970 à 1990 :

• les processeurs 8 bits sortis à la fin des années 1970 MOS Technology 6502, Zilog Z80, Intel 8080 ou Motorola 6800 ;
• les processeurs 16/32 puis 32 bits 680x0, qui passent à l'architecture RISC 32 bits PowerPC ;
• les processeurs 16 puis 32 bits x86, qui passent à l'architecture compatible et toujours CISC, mais en 64 bits, AMD64 et Intel 64 (ce dernier n'ayant pas eu de succès, tout comme les processeurs RISC 32 bits d'Intel i860 et i960, car incompatibles avec l'architecture CISC) ;
• le S390 et S390x (pour les mainframes d'IBM), qui développe ensuite l'architecture RISC 64 bits POWER ;
• le VAX de DEC, qui passe en suite à l'architecture RISC 64 bits DEC Alpha.