En fait, votre première hypothèse n'est pas aussi lointaine que certains le prétendent.

Un processeur est construit autour de quelque chose appelé "Unité logique arithmétique" (ALU) et une implémentation simpliste de cela est d'avoir le portes logiques mettant en œuvre toutes les opérations de base câblées aux entrées en parallèle. Tous les calculs élémentaires possibles sont ainsi effectués en parallèle, la sortie de celui réellement souhaité étant sélectionnée par un multiplexeur.

Dans un processeur extrêmement simple (modèle de tableau de craie), quelques bits de l'opcode de l'instruction en cours d'exécution sont câblés à ce multiplexeur pour lui indiquer le résultat de la fonction logique à utiliser. (Les autres résultats indésirables sont tout simplement gaspillés)

La technologie réelle utilisée pour implémenter les calculs dans l'ALU varie - il peut s'agir de "vraies" portes logiques, ou de LUT si le CPU est implémenté à l'intérieur un FPGA basé sur LUT (un très bon moyen de comprendre l'essentiel du calcul de programme stocké est de concevoir un processeur simple et de le construire dans un simulateur logique et peut-être ensuite un FPGA).

Assez loin.

Un CPU est composé de vraies portes (LUT non programmables). Les opérations clés sur les données sont effectuées dans un bloc de logique souvent appelé ALU (unité arithmétique-logique). À l'intérieur de ce bloc se trouve un ensemble de portes qui peuvent, par exemple, ET deux opérandes ensemble, bit par bit. Il existe un autre ensemble de portes qui peuvent les additionner, et ainsi de suite.

Lorsque vous exécutez des instructions sur le CPU, les instructions sont décodées une par une, et la logique associée à cette instruction est activée dans le ALU.

La différence est un compromis entre le temps et la zone. Si vous avez beaucoup de AND à faire, vous pouvez les faire dans un FPGA en utilisant plusieurs LUT en parallèle et les faire en peu de temps. Si vous les faites dans un processeur, elles seront exécutées une par une (séquentiellement) dans le petit bloc de logique conçu pour cette tâche.

Le CPU n'a pas seulement «un certain nombre» de portes logiques pré-construites. Un processeur moderne compte entre 50 millions et plusieurs milliards de transistors, ce qui correspond à plusieurs millions de portes.

Le CPU a déjà toutes les ressources nécessaires pour exécuter votre programme C ++. Les ressources fournies remplissent le jeu d'instructions défini par cette plate-forme matérielle, que ce soit x86, ARM, MIPS, etc. Ces instructions incluent toutes les instructions arithmétiques, le déplacement de la mémoire, les conditions, etc. Regardez les jeux d'instructions de votre plate-forme pour comprendre du fonctionnement réel du CPU.

Quand le CPU effectue une opération "ET", alors qu'il utilise quelque part une porte ET, il y a des millions de portes ET dans le CPU pour toutes sortes d'opérations.

Ces instructions sont toutes implémentées dans la disposition des transistors dans la puce. Pour voir comment certains d'entre eux fonctionnent, recherchez des éléments tels que des bascules, des ajouts ou d'autres logiques numériques.

D'autres réponses ont abordé les questions spécifiques à un niveau de détail des écrous et boulons, mais je pense qu'il y a ici une opportunité de regarder les choses sous un angle différent. Les processeurs ont aujourd'hui plusieurs millions (des milliards de processeurs de bureau de la génération actuelle) de transistors mettant en œuvre un nombre comparativement élevé de portes. Bien que seules quelques-unes de ces portes soient réellement utilisées pour implémenter le calcul XOR , il est difficile de les voir dans l'immense forêt de fonctions de support.

Les anciens ici ( Je pense que je peux admettre avoir aussi gagné cette étiquette) regardé cette forêt grandir, mais il est facile de voir comment un nouveau venu sur le terrain avec juste une petite expérience de conception numérique pourrait avoir du mal à voir les parallèles entre un pur-matériel calcul et un processeur multicœur moderne avec de nombreuses couches de cache, prédiction de branche et exécution en pipeline.

Je vous recommanderais de trouver les fiches techniques et le matériel de référence du programmeur pour plusieurs (mais un à la fois) des anciens microprocesseurs 8 bits des années 70 et 80. Dans de nombreux cas, vous pouvez même en trouver des implémentations open source sous la forme d'émulateurs logiciels purs ainsi que Verilog ou VHDL pour une utilisation dans un FPGA.

Je recommande de commencer ici car le 8080 (utilisé dans l'Altair 8800 de 1975 qui a lancé le marché informatique le plus moderne), MC6800 (est apparu dans de nombreux petits ordinateurs à la fin des années 70), 6809 (RadioShack Coco et autres), 6502 (Apple 1, Apple] [et bien d’autres) et bien d’autres comme eux étaient en grande partie conçu et mis en œuvre par des ingénieurs uniques ou de très petites équipes et devait donc être pleinement compris par une très petite équipe. Ils démontrent également le nombre minimum de fonctionnalités nécessaires pour un processeur commercialement réussi sans ajouter de mémoire supplémentaire, de cache ou de périphériques.

Une grande partie du patrimoine 8080 est préservée sur la page de la famille Z80. Le Z80 était l'extension Zilog de la plate-forme Intel 8080, et les cœurs qui l'implémentent peuvent encore être trouvés aujourd'hui. Un Verilog 8080 est disponible sur OpenCores.org, ainsi que plusieurs autres implémentations 8080 et Z80. Une richesse de documentation, de systèmes d'exploitation, d'assembleurs et de compilateurs existe pour l'architecture MCS80 et sa vaste famille.

OpenCores a un grand nombre de cœurs open source. Il existe près de 100 processeurs purs, ainsi qu'une cinquantaine de SOC supplémentaires qui pourraient servir de base à une exploration plus approfondie.

Comme vous l'avez observé, le contenu de la table de recherche détermine si une certaine LUT est une porte OU (0, 1, 1, 1) et une porte ET (0, 0, 0, 1), un XOR (0 , 1, 1, 0) etc.

La table de recherche elle-même est implémentée en utilisant des portes codées en dur, c'est-à-dire que le résultat est

  (lut [0] AND NOT a AND NOT b) OR (lut [1] AND a AND NOT b) OR (lut [2] AND NOT a AND b) OR (lut [3] AND a AND b)  

Si vous regardez cette ligne par ligne, vous pouvez voir qu'une seule de ces lignes peut jamais avoir une ligne logique, donc cela sélectionne l'une des entrées LUT. De la même manière, vous pouvez également choisir entre plusieurs sources de données:

Si op1 est le numéro de registre à deux bits, l'opérande lhs peut être sélectionné comme

  (reg0 AND NOT op1 [0] AND NOT op1 [1]) OR (reg1 AND op1 [0] AND NOT op1 [1]) OR (reg2 AND NOT op1 [0 ] AND op1 [1]) OR (reg3 AND op1 [0] AND op1 [1])  

Ensuite, opcode peut sélectionner l'opération à effectuer:

  ((lhs AND rhs) AND NOT opcode [0] AND NOT opcode [1]) OR ((lhs OR rhs) AND opcode [0] AND NOT opcode [1]) OR ( (lhs + rhs) AND NOT opcode [0] AND opcode [1]) OR ((lhs - rhs) AND opcode [0] AND opcode [1])  

Où res = (lhs + rhs) est défini comme

  res [0] = lhs [0] XOR rhs [0]; res [1] = lhs [1] XOR rhs [1] XOR (lhs [0] AND rhs [0]); ...  

Donc à la fin, je peux tout réduire à des portes fixes, ne laissant que la variable d'entrées. Un FPGA est l'une de ces variantes, où les portes sont disposées de manière à effectuer une recherche de table.

Dans un système réel, j'optimiserais en plus, par exemple combiner des signaux équivalents et tenter de minimiser la commutation des portes lorsque ce signal est ensuite éliminé par une porte ET et n'aura aucun effet sur le résultat:

  is_and_op = NOT opcode [0] AND NOT opcode [1];  

Plusieurs éléments de circuit veulent savoir si nous exécutons actuellement une opération "et".

  lhs_and = lhs AND is_and_op; rhs_and = rhs AND is_and_op;  

Sinon, nous passons des zéros dans les portes effectuant l'opération.

  res_and = lhs_and AND rhs_and;  

Ceci est l'opération réelle, comme auparavant.

  res = res_and AND is_and_op OR ...;  

La sélection peut également utiliser notre raccourci.

La différence entre un CPU et un FPGA est le parallélisme. Les FPGA sont très bons pour effectuer un certain nombre de tâches (logiquement) plus simples à la fois avec un délai minimal. Une logique et des séquences d'opérations plus complexes sont mieux prises en charge par l'ALU (unité arithmétique et logique) du CPU.

Si vous êtes intéressé par une émulation logicielle commune de conception de portes, qui est généralement (si naïvement) utilisée pour simplifier les fonctions logiques booléennes, jetez un œil à l ' algorithme Quine – McCluskey. Je l'ai utilisé pour concevoir mon propre logiciel de synthèse à Uni lorsque je ne pouvais pas transférer les studios coûteux, et pour le plaisir.