« Fonctionnement d'un ordinateur/Les jeux d'instructions » : différence entre les versions

aucun résumé des modifications
Aucun résumé des modifications
===Les processeurs CISC===
 
Les jeux d'instructions CISC sont les plus anciens et étaient à la mode jusqu'à la fin des années 1980. AÀ cette époque, on programmait rarement avec des langages de haut niveau et beaucoup de programmeurs codaient en assembleur. Avoir un jeu d'instruction complexe, avec des instructions de "haut niveau" qu'on ne devait pas refaire à partir d'instructions plus simples, facilitait la vie des programmeurs.
 
Cette complexité des jeux d'instructions n'a pas que des avantages "humains", mais a aussi quelques avantages techniques. Le premier est une meilleure densité de code : un programme codé sur CISC utilise moins d'instructions et prend moins de mémoire. AÀ l'époque des processeurs CISC, la mémoire était rare et chère, ce qui faisait que les ordinateurs n'avaient pas plusieurs gigaoctets de mémoire : économiser celle-ci était crucial. Cet avantage était donc crucial, ce qui contrebalançait les défauts de ces architectures. Ces défauts étaient essentiellement le fait que le grand nombre d'instructions entraîne une grande consommation de transistors et d'énergie. La difficulté de conception de ces processeur était aussi sans précédent.
 
===Les processeurs RISC===
Certains processeurs sont carrément conçus pour un langage de programmation en particulier. On appelle ces processeurs, conçus pour des besoins particuliers, des '''processeurs dédiés'''. Par exemple, l'ALGOL-60, le COBOL et le FORTRAN ont eu leurs architectures dédiées. Les fameux ''Burrough E-mode'' B5000/B6000/B7000 étaient spécialement conçus pour exécuter de l'ALGOL-60. Leurs cousins B2000/B3000/B4000 étaient eux conçus pour le COBOL. Le FORTH, un des premiers langages à pile de haut niveau, possède de nombreuses implémentations hardware et est un des rares langages de haut niveau à avoir été directement câblé en assembleur sur certains processeurs. Par exemple, on peut citer le processeur FC16, capable d’exécuter nativement du FORTH. Des langages fonctionnels ont aussi eu droit à leurs processeurs dédiés. Le prolog en est un bel exemple, avec les superordinateurs de 5ème génération qui lui étaient dédié. On peut aussi citer les machines LISP, dédiés au langage LISP, qui datent des années 1970. Elles étaient capables d’exécuter certaines fonctions de base du langage directement dans leur circuits : elles possédaient notamment un ''garbage collector'' câblé dans ses circuits ainsi que des instructions machines supportant un typage déterminé à l’exécution.
 
Les processeurs dédiés ont eu leur heure de gloire au début de l'informatique, à une époque où les langages de haut niveau venaient d'être inventés. AÀ cette époque, les compilateurs n'étaient pas performants et ne savaient pas bien optimiser le code machine. Les programmes compilés faisaient un mauvais usage des instructions machines, ne savaient pas bien utiliser les modes d'adressages adéquats, manipulaient assez mal les registres, etc. Il était alors rationnel, pour l'époque, de rapprocher le code machine cible et le langage de programmation de haut niveau. De nombreuses architectures dédiés ont ainsi étés inventées, avant que les concepteurs se rendent compte des défauts de cette approche. AÀ l'heure actuelle, les algorithmes des compilateurs se sont améliorés et savent nettement mieux utiliser le matériel. Ils produisent du code machine efficace, ce qui rend les architecture dédiées bien moins intéressantes. Si on ajoute les défauts de ces architectures dédiées, par étonnant que les architectures dédiées aient presque disparues. Les défauts en question ne sont pas nombreux, mais assez simples à comprendre. Premièrement, elles sont très rapides pour un langage de programmation en particulier, mais sont assez mauvaises pour les autres, d'où un problème de "compatibilité". Ajoutons à cela que les langages de programmation peuvent évoluer, devenir de moins en moins populaires/utilisés, ce qui rend la création d'architectures généralistes plus pertinente. Enfin, les architectures dédiées sont évidemment des processeurs CISC, pour implémenter les nombreuses fonctionnalités des langages évolués. Et les défauts des CISC sont assez rédhibitoires à l'heure actuelle.
 
En regardant dans les langages de programmation un peu plus connus, on peut aussi citer des processeurs spécialisés pour Java. Certains processeurs ARM, qu'on trouve dans des système embarqués, sont de ce type. Mais ceux-ci sont un petit peu à part et ne sont pas vraiment des architectures dédiées. En réalité, ces processeurs sont une implémentation matérielle de la machine virtuelle Java. Rappelons que la machine virtuelle JAVA est un design de processeur comme un autre, avec un jeu d'instruction simple, une architecture à pile, etc. Le code machine associé à cette architecture est appelé le ''bytecode'' Java. En temps normal, le ''bytecode'' Java n'est pas exécuté directement par le processeur, qui utilise un langage machine différent. AÀ la place, le ''bytecode'' est traduit dans le langage machine adéquat, par un interpréteur/compilateur. c'est ce qui permet au ''bytecode'' Java d'être portable sur des architectures différentes. En fait, le ''bytecode'' Java est utilisé comme intermédiaire : on compile du code Java en ''bytecode'' Java, qui est traduit sur l'architecture cible quand on en a besoin. Les architectures Java permettent de se passer de l'étape de traduction ''bytecode'' -> langage machine, vu que eur langage machine est le ''bytecode'' Java lui-même.
 
===Les architectures à capacités===