Je comprends qu’un processeur contient des milliards de transistors, et que pour une architecture donnée, il existe de grandes variations dans le nombre et la composition de ces transistors (AMD vs Intel ou i9-13900 vs i9-14900). Par quel mécanisme ces architectures peuvent-elles être exploitées par un système d’exploitation commun pour effectuer un travail utilisable, sans que le SE ait besoin d’être conscient de ces différences ?
Autrement dit, qu’est-ce qui décide de la manière de distribuer les opérations parmi ces immenses bancs de transistors et de rapatrier les résultats vers le système d’exploitation, de sorte que celui-ci reste largement inconscient et non affecté par les différences matérielles ?
Je suppose qu’il s’agit du microcode, bien que je ne sois pas très familier avec son fonctionnement réel. Cela semble être une tâche herculéenne de créer une abstraction spécifique à l’architecture entre le matériel et le SE pour accomplir cela. Que est-ce que je ne comprends pas ?
Merci.
Peut confirmer.
Cela fait des années que je suis technomancien, et les imprimantes sont des choses capricieuses qui fonctionnent sur l’ambiance et la discipline plutôt que sur la science.
Vous ne pouvez jamais contrôler la magie, mais vous pouvez la courber un peu.
L’assembleur x86 fonctionne sur tout processeur x86 (c’est au moins l’objectif). Le processeur reçoit les commandes x86 et a été conçu pour faire le bon choix selon les instructions x86.
À ce niveau, les commandes sont simplement l’application de courant à certains fils. Les circuits du processeur sont activés en alimentant certains fils et si vous alimentez le bon ensemble de fils, il exécutera l’instruction x86 correspondante.
L’x86 n’est qu’une seule norme, il y a aussi ARM et RISCV et d’autres architectures normalisées.
Ces normes indiquent « alimenter ces fils de cette manière pour effectuer ces actions ». Ces instructions devraient idéalement fonctionner sur tout processeur qui implémente la norme.
Je partais avec des extraterrestres, mais la magie a aussi du sens.
Pensez au processeur comme étant un ordinateur à lui seul. Il dispose d’instructions que vous pouvez lui envoyer et il possède une logique pour exécuter ces instructions.
L’ordinateur possède un noyau qui est responsable de fournir une couche d’abstraction entre ce que le processeur peut faire et ce que vous devez faire avec les composants de l’ordinateur suivant – mémoire, stockage, périphériques d’extension, etc.
Ensuite, au-dessus de ce noyau se trouve le reste du système d’exploitation qui communique avec le noyau et le noyau communique avec le processeur.
Un exemple de cela est Linux. Le système d’exploitation Unix n’était pas disponible pour les machines Intel. Puis Linus Torvalds a porté le code du noyau Unix sur l’architecture Intel x86 et soudainement Unix pouvait être compilé et utilisé sur les processeurs Intel.
Il y avait plus d’un système d’exploitation Unix ou similaire à Unix disponibles pour Intel lorsqu’Linux a commencé à travailler sur le noyau Linux. Microsoft, par exemple, avait une version Unix pour Intel et Linus créait Linux en partie parce qu’il ne voulait pas payer pour le système d’exploitation MINIX similaire à Unix.
Et non, Linus n’a pas porté le code Unix vers Intel. Il a commencé à zéro sur le noyau et l’a empaqueté avec des bibliothèques et des utilitaires créés par d’autres personnes pour fonctionner comme UNIX.
Cela remonte avant les distributions complètes de Linux, il y avait deux images de disquettes, une image de démarrage et une image du système racine. Je ne me souviens plus si Linus lui-même a jamais distribué les images du système racine/démarrage ou si quelqu’un d’autre les a construites, c’était il y a longtemps…
En 1984, je pouvais installer Unix sur une disquette de 720k. Suffisant pour démarrer, formater un disque dur, exécuter un shell et le construire à partir d’un port série. Système Mc68000.
Je ne me souviens pas exactement ce qui était sur le disque Linux racine et à quel point le système était complet.
Rien ne gère le calcul des transistors au système d’exploitation. Le système d’exploitation n’est qu’un calcul effectué par les transistors.
Les transistors sont connectés ensemble avec des « fils » (couches métalliques) pour former des portes logiques. Un circuit intégré a une disposition et une connectivité statique de transistors. Les portes sont des choses comme z = et(x, y). Certaines autres dispositions peuvent stocker des données de manière persistante et ne changer leur valeur que sur un « front d’horloge » (ceux-ci sont appelés registres ou bascules D). Ils sont combinés pour former des séquences qui effectuent des actions comme « prendre deux nombres sur un front d’horloge et produire la somme sur le prochain front d’horloge ». La logique prend du temps, donc nous divisons le calcul en ces étapes et les connectons ensemble.
Un processeur est une chaîne de logique qui se comporte d’une manière qui implémente une spécification appelée ISA (architecture d’ensemble d’instructions). Cette spécification indique comment les bits en mémoire sont interprétés comme des instructions et ce que font les instructions ainsi que ce que signifie les exécuter.
Tout le logiciel, y compris les systèmes d’exploitation, est un ensemble de bits écrits conformément à l’ISA. Un outil appelé compilateur traduit le code de la sémantique d’un langage de programmation vers la sémantique de l’ISA.
Ainsi, la réponse au premier niveau est que l’ISA abstrait le matériel du logiciel. Beaucoup de processeurs implémentent la même ISA. Le langage de programmation abstrait le programme de l’ISA. Des compilateurs pour un langage peuvent exister qui ciblent différentes ISAs. Ainsi, avec beaucoup de détails, je peux écrire un programme qui peut être compilé vers de nombreuses différentes ISAs, chacune pouvant être implémentée par de nombreux différents processeurs.
Beaucoup de choses sont passées sous silence ici, c’est pour les 5 ans.
Cela ne doit probablement pas être une réponse parfaite, car je suis loin d’être un expert en informatique. Selon ma compréhension, un CPU, bien qu’il soit composé de milliards de transistors, a des transistors organisés en parties de plus en plus complexes (comme les additionneurs par exemple), qui sont ensuite organisés en parties plus grandes (cache, cœurs). Ces parties plus grandes sont ensuite, comme vous l’avez dit, contrôlées par le microcode qui relie le CPU au bios. En général, tout cela est construit selon des normes (comme x86 par exemple), ce qui facilite son interopérabilité.
Personne ne travaille au niveau des interactions de transistors. Chaque architecture de processeur définit un ensemble d’instructions que le processeur peut exécuter, et l’interaction entre le logiciel et le processeur utilise cette langue. C’est quelque chose beaucoup plus simple à comprendre et à utiliser que les détails fins de milliards de transistors.
Comme l’ont dit les autres commentateurs, l’abstraction est essentielle. Cela dit, il est de la responsabilité du fabricant de puces d’assurer que leur architecture soit compatible avec ces systèmes d’exploitation, dans une certaine mesure. Ce que je veux dire par là, c’est qu’au-delà du fait qu’un i9-13900 et un i9-14900 aient une composition différente de transistors, ils supporteront tous les deux le même jeu d’instructions, donc, du point de vue du système d’exploitation, ils sont identiques. AMD aurait un autre jeu d’instructions, mais ils ont travaillé avec les différents systèmes d’exploitation pour s’assurer qu’ils soient pris en charge. Il y a une grande complexité dans l’électronique d’un processeur, mais au final, ils sont assez simples dans ce qu’ils font. Ils exécutent des instructions qui modifient des registres internes et interagissent avec des périphériques d’entrée/sortie via des lignes de bus. C’est à peu près tout ce qu’ils ont à faire du point de vue du système d’exploitation. Ils peuvent faire beaucoup plus à l’intérieur pour améliorer leurs performances, le cache, les instructions en parallèle, etc., mais tant qu’ils exécutent des instructions, le système d’exploitation n’en a pas besoin.
C’est à propos d’abstractions. Le processeur présente au système d’exploitation un modèle beaucoup plus simplifié et utilise ensuite beaucoup de matériel pour exécuter du code bien plus rapidement que ce que ce modèle permettrait naïvement, tout en préservant la logique du modèle afin que le système d’exploitation ne voie rien d’inattendu.
Certains des tours que le processeur cache au système d’exploitation consistent à exécuter du code dans un ordre différent et à deviner certains résultats à l’avance.
Oui, c’est comme comment vous pouvez écrire du texte avec un crayon ou un stylo ou un clavier sans avoir à vous soucier de la technologie sous-jacente. Cela est caché derrière une interface connue. Les ordinateurs ont des couches d’abstraction et des composants modulaires incroyablement nombreux, qui n’ont besoin de savoir que comment interagir avec les éléments adjacents et sont donc suffisamment simples pour que les humains les conçoivent.
En effet. Et cela conduit à certains cas limites où briser les abstractions vous permet d’extraire un peu plus de votre système (ou beaucoup) au détriment de la modularité.
Ou vous permettre d’exploiter le système pour faire fuiter des données provenant d’autres processus que vous ne devriez pas avoir le droit d’accéder.
La réponse est qu’il existe plusieurs couches d’abstraction ; c’est de l’abstraction jusqu’au niveau le plus bas.
La plupart du code exécuté a été écrit dans un langage de haut niveau, abstrait du code assembleur qui l’implémentait.
Le code assembleur est abstrait du code réel qui s’exécute sur le CPU.
Ensuite, dans le cas d’Intel, les instructions CPU envoyées au processeur sont abstraites (probablement via du microcode) de plusieurs instructions CPU beaucoup plus simples qui sont exécutées en interne.
Et ces instructions seront abstraites des blocs logiques du CPU qui font le travail réel.
À ce stade, nous ne sommes toujours pas au niveau des transistors individuels ; il y aura encore plusieurs niveaux d’abstraction supplémentaires.
Ainsi, tout fonctionne et nous pouvons construire des logiciels complexes parce qu’à chaque niveau, nous n’avons généralement pas besoin de nous soucier des détails de plus d’une ou deux couches d’abstraction en dessous de l’endroit où un travail de codage est effectué.
Dans la conception de systèmes en général, les fonctions sont isolées les unes des autres. Chaque unité peut faire ce que les concepteurs de ces unités souhaitent. La seule chose importante est que l’interface entre les unités soit connue et respectée. Prenons une roue sur une voiture. Il n’a pas d’importance si la voiture a un moteur électrique, un moteur à combustion interne, un moteur à vapeur ou un ressort à lame. Le moteur doit simplement faire tourner un arbre, et la roue doit simplement se connecter à un arbre qui tourne.
tout ce qui est exprimé est une abstraction.
Je ne sais pas quel point vous essayez de faire, voulez-vous l’expliquer davantage ?
Je comprends que ces « banques » de transistors sont dédiées à des opérations spécifiques, des additionneurs et autres, dont il peut y avoir des centaines ou des milliers disponibles pour effectuer le travail. Je suppose que le nœud de ce que j’essaie de comprendre est le suivant : lorsqu’un système d’exploitation a besoin qu’une opération soit effectuée, qu’est-ce qui décide comment répartir ce travail ? Lesquelles sont disponibles, où acheminer les sorties ou lire les entrées, l’ordre des opérations, la gestion des délais (c’est-à-dire l’attente de la réponse de la RAM, du SSD, du GPU, etc.).
C’est comme la proverbiale pièce pleine de singes avec des machines à écrire. Qu’est-ce qui organise ce chaos pour en tirer des résultats ?
Une instruction de processeur est simplement un nombre dont les bits sont interprétés d’une manière spécifique par les circuits de la carte processeur elle-même. Lorsque le système d’exploitation « souhaite » exécuter une instruction, il la charge dans une partie spécifique de la RAM désignée pour les instructions, que le processeur est câblé pour lire à chaque cycle (si vous avez entendu parler d’« overclocking », cela signifie faire fonctionner les cycles plus rapidement).
Il existe un niveau le plus bas « langage » dans lequel vous pouvez programmer un ordinateur, on l’appelle l’assembleur (et bien que cela ne soit pas tout à fait correct, c’est suffisamment proche), et une seule ligne d’assembleur représente généralement l’étape la plus simple qu’un ordinateur puisse effectuer. Par exemple, « Ajouter 1 à la valeur du registre 1 » est quelque chose que le circuit physique sait comment faire, comme des dominos qui tombent selon un motif complexe mais prévisible. Lorsque vous demandez à un processeur d’exécuter l’une de ces étapes les plus simples, l’ordinateur exécutant ce que vous lui avez demandé n’est qu’une question de physique, dirigée par la manière dont le fabricant a assemblé les transistors.
Il existe un grand nombre de types de processeurs différents, mais la plupart d’entre eux utilisent uniquement l’un ou l’autre de quelques types d’assembleur. Ainsi, lorsqu’un système d’exploitation veut faire quelque chose, comme additionner deux nombres, il a simplement besoin d’avoir l’instruction en assembleur de ce qui doit être fait. Les processeurs peuvent avoir différentes configurations de transistors, mais le système d’exploitation n’en tient pas compte, il indique simplement au processeur ce qu’il doit faire en assembleur, et le processeur le fera.
Ainsi, les programmeurs écrivent des programmes et des systèmes d’exploitation en assembleur, ou en un langage de niveau supérieur qui sera converti en assembleur, et ils n’ont pas besoin de s’inquiéter des détails du microprocesseur, et les fabricants de microprocesseurs se contentent de s’assurer que leur microprocesseur peut exécuter toutes les instructions en assembleur qu’il est censé gérer, et tant qu’il le fait, personne ne se soucie vraiment de savoir comment il fonctionne réellement à l’intérieur. C’est essentiellement ainsi que tout le chaos est géré, en le divisant en morceaux dans un langage partagé que tout le monde dans le processus peut accepter.
Pensez à l’abstraction comme à une grande entreprise.
Le PDG ne remplit pas les formulaires comptables, n’assemble pas de nouvelles pièces et ne nettoie pas les toilettes. Le PDG parle à quelques dirigeants de haut niveau sur la direction générale, puis ces dirigeants transmettent des directives plus précises aux personnes de rang inférieur, jusqu’à ce que vous ayez des personnes qui remplissent les formulaires comptables, fabriquent de nouvelles pièces et nettoient le bureau.
C’est l’abstraction. Il n’y a pas « une » entité qui dit à tout le monde comment faire son travail. Au lieu de cela, il y a une hiérarchie qui se déroule jusqu’aux tâches spécifiques, allant jusqu’au niveau du transistor. À chaque étape, c’est codé en dur pour faire exactement ce que son « patron » lui dit de faire.
À un niveau bas, vous suivez simplement des règles physiquement programmées dans votre circuit CPU.
Par exemple, une architecture CPU pourrait envoyer les premiers bits (votre opération) d’un « mot » de 32 bits à un démultiplexeur, et les autres bits (vos opérandes) au circuit désigné par le démultiplexeur.
À un niveau plus élevé, il pourrait y avoir un code qui vous dit d’attendre (impliquant des dizaines ou des centaines d’opérations de niveau inférieur) jusqu’à ce qu’une opération GPU soit terminée.
Jusqu’à ce que vous finissiez par voir ce que vous voyez sur votre écran d’ordinateur.
Une façon de le voir est que lorsqu’on fournit une instruction à un processeur, ce dernier a été spécifiquement conçu pour que l’information circule à travers lui de manière à obtenir le résultat souhaité à la fin. Comme verser de l’eau à travers une série de canaux et de écluses, elle coule de cette manière parce qu’elle *doit* le faire, elle ne fait que descendre en bas. Au fil des décennies, nous avons ajouté de plus en plus de couches à ce principe simple, avec une complexité croissante, mais la physique reste la même. Toutes les décisions que vous demandez sont simplement gérées par la conception de la structure elle-même.
Cela ne signifie pas que nous n’obtenons parfois des résultats inattendus, c’est ce qu’on appelle un bug ou un plantage. Mais très rarement, un tel cas correspond à un comportement réellement anormal du matériel. Généralement, il fait exactement ce pour quoi il a été conçu, c’est le programmeur qui a mal compris ce qui devait se produire en fonction de l’entrée fournie. Avec toutes les couches de complexité qui existent maintenant, cela n’a rien de surprenant.
Dans le système d’exploitation, cela est géré par ce qu’on appelle le Planificateur.
Il décide quels processus s’exécutent sur quelles cœurs et à quel moment.
Les planificateurs plus avancés dans les systèmes d’exploitation serveurs ne sont pas seulement conscients des cœurs, mais aussi de NUMA, car les grands processeurs serveurs peuvent être logiquement divisés en plus petites unités, chaque unité étant optimisée en termes d’interconnexion entre le cœur et la mémoire RAM. Cela aide lorsque vous avez beaucoup de processus individuels ou lorsqu’un hyperviseur exécute de nombreuses machines virtuelles. Les applications plus monothreadées ne tireront pas beaucoup avantage de NUMA.
C’est ce que fait un compilateur, un compilateur génère du code assembleur spécifique à l’architecture du processeur qui sait comment communiquer avec la microcode
Donc vous écrivez un ensemble de code C puis utilisez un compilateur Intel pour qu’il génère du code assembleur qui sait comment communiquer avec la microcode d’Intel. Si vous souhaitez qu’il s’exécute sur un processeur ARM, vous devez le recompiler en utilisant un compilateur ARM.
Oui, c’est un processus très complexe. À l’époque initiale, la surface 2D suffisait pour placer tous les transistors et les connexions entre eux, mais aujourd’hui, les puces sont également conçues en 3D.
Cela est réalisé avec la lithographie UV, et cela ressemble presque à de la magie, et je ne comprends toujours pas correctement comment cela fonctionne. Ce processus est si complexe que seules quelques entreprises dans le monde possèdent la technologie et l’expertise nécessaires pour produire des puces avec la densité de transistors que nous avons aujourd’hui.
Abstractions
La complexité est cachée par des constructions de niveau inférieur. Chaque construction est simple
Un seul transistor se trouve au plus bas niveau. Un seul commutateur. Ces éléments peuvent être regroupés en une structure de niveau supérieur comme un additionneur ou des portes logiques. Lorsque l’on travaille avec des additionneurs ou des portes logiques, on n’a plus besoin de considérer un seul transistor.
Vous construisez ensuite des constructions de niveau supérieur à partir d’additionneurs et de portes. En travaillant avec ces constructions de niveau supérieur, vous n’avez plus besoin de considérer un additionneur individuel.
Et ainsi de suite, jusqu’à arriver à un processeur. Une seule entité, constituée de milliards de transistors.
Le système d’exploitation *sait* sur quel processeur il s’exécute et ajustera les paramètres internes pour faire face aux différences. Par exemple, il lira divers registres du processeur pour savoir combien de cœurs de différents types sont disponibles, si des contournements sont nécessaires en raison de bogues sur ces processeurs (bien que ceux-ci puissent être corrigés par des mises à jour de microcode). Il se peut qu’une instruction mathématique ait un bogue, et elle sera remplacée par une version logicielle moins problématique si elle est détectée.
Même au niveau de l’application, il peut y avoir des exécutables « graisseux » qui contiennent différentes versions pour différents processeurs, qui chargeront les parties spécifiques au processeur lors de leur exécution.
Votre ordinateur n’est qu’un calculateur très coûteux, et l’envoi d’électricité à travers les transistors effectue des calculs. Les transistors qui doivent être alimentés et comment cela est déterminé par l’architecture de votre processeur. AMD et Intel utilisent ce qu’on appelle x86 ou x86_64 en raison de plusieurs accords et licences croisées. Mais les applications x86 ne peuvent jamais fonctionner sur ARM, couramment trouvé dans les téléphones.
En bref, les entreprises ont convenu d’utiliser un système cohérent afin que vous n’ayez pas à créer des milliers de versions du même logiciel pour chaque modèle de processeur.
> Qu’est-ce qui détermine la distribution des opérations parmi ces grands groupes de transistors
Un autre ensemble de transistors, appelé démultiplexeur. En bref, c’est un dispositif qui change le sens du flux d’électricité.
Merci. Je pense que vous avez fait le plus pour ma compréhension et j’espère que vos votes positifs refléteront cela un jour. Développons cependant ma question initiale. Qu’est-ce qui gère le routage des opérations ? Quel système sait quels blocs sont disponibles, comment aiguiller les entrées vers ces blocs, où aiguiller les sorties de ces blocs, comment gérer les délais lorsqu’une opération nécessite des entrées ou sorties vers le matériel système (mémoire RAM, disque SSD, GPU, etc.). Dit autrement, qu’est-ce qui apporte un ordre au chaos ?
Chacun de ces problèmes a des mécanismes différents pour les résoudre. Mais beaucoup d’entre eux se réduisent à des abstractions qui cachent une grande partie de la complexité au système d’exploitation/programme.
Quelques exemples :
Les processeurs ont un logique de gestion spéciale conçue pour acheminer les données et les opérations vers le bon endroit et suivre les dépendances entre les instructions. Ainsi, le programme ou le système d’exploitation n’a pas besoin de s’inquiéter de savoir quels additionneurs sont libres ou quelles instructions dépendent les unes des autres, le processeur gère cela en interne.
Pour les dépendances d’entrée/sortie, un programme peut envoyer une demande et « ne rien faire » jusqu’à ce qu’il reçoive une réponse. Une version simplifiée de « ne rien faire » est de poser constamment « la donnée est-elle prête ? » Jusqu’à ce que la réponse soit oui. Une fois que les données sont disponibles, cette boucle « ne rien faire » peut se terminer et les données peuvent être utilisées par les instructions suivantes.
Au niveau architectural, les horloges et la synchronisation des horloges. Au niveau utilisateur des choses, toujours des horloges, mais avec un tas d’instructions IF et de correction d’erreurs et de bits de parité intégrés dans chaque octet. Oh et plus de synchronisation des horloges.
La puce est une boîte noire. Certains entrées entraînent certaines sorties. Tant que c’est vrai, les détails de ce qui se passe à l’intérieur de cette boîte noire sont sans importance pour le système d’exploitation.
C’est comme une voiture. Ajoutez du carburant, allumez la voiture, mettez-la en marche, appuyez sur l’accélérateur, la voiture avance. Le conducteur n’a pas besoin de se soucier si c’est un moteur rotatif, un six cylindres en ligne ou un V8. Il n’a pas besoin de s’inquiéter si la transmission est un automatique à double embrayage ou des engrenages planétaires avec couplage hydraulique. L’injection de carburant ? Le DOHC ? Des détails sans importance.
Je ne pense pas qu’il y ait de réponse ELI5 ici, c’est une question très technique. Pour information, j’ai un diplôme en informatique et j’ai suivi un cours spécifique sur ce sujet, et je ne pourrais pas vous dire exactement comment les choses fonctionnent (en fait, je suis assez sûr que personne sur Terre ne sait comment tout cela fonctionne, d’autant plus que beaucoup de cela est propriétaire et gardé secret intentionnellement).
Le concept clé est celui des couches d’abstraction. Le système d’exploitation n’interagit pas directement avec ces milliards de transistors, mais plutôt il émet un ensemble d’instructions en langage assembleur, qui peuvent être lues comme un code machine correspondant, que le microcode traduit en signaux électriques physiques qui font effectivement ouvrir et fermer les transistors.
Mais comme je l’ai dit, c’est une réponse profondément incomplète (et si vous êtes comme moi, profondément insatisfaisante). Je recommanderais Nand 2 Tetris si vous êtes intéressé par la compréhension réelle de chaque couche, du matériel au logiciel utilisateur. Cependant, comme son nom l’indique, cela ne couvre pas non plus les étapes les plus basses, car à ce stade nous entrons dans le domaine de la physique, et non plus de l’informatique.
Les processeurs d’une famille partagent un jeu d’instructions. C’est la couche de compatibilité de base.
Le jeu d’instructions est l’ensemble des commandes en langage machine réel qui sont envoyées au processeur pour être exécutées.
Chaque processeur de la famille produira le même résultat lorsqu’il exécute la même instruction et rien au-dessus du processeur (par exemple, le système d’exploitation, les applications) n’a besoin de savoir comment l’électronique du processeur a accompli cela.
Tout le code est transformé en une série d’instructions de bas niveau via la chaîne de construction logicielle ou à l’exécution par un autre code.
Les processeurs sont littéralement conçus pour s’assurer qu’ils respectent la spécification du jeu d’instructions.
Nous intégrons des milliards de transistors sur un seul circuit en les rendant extrêmement petits grâce à la photolithographie avancée, qui grave des motifs microscopiques sur des plaquettes de silicium. Chaque nouvelle génération de technologie de fabrication (mesurée en nanomètres) réduit la taille du transistor, permettant d’en placer davantage dans la même surface. Des techniques innovantes de superposition 3D et de conception aident également à augmenter la densité tout en maintenant des performances et une efficacité énergétique élevées.
Vous devez lire au-delà du titre, ils ne demandaient pas comment ils ont inséré ce transistor dans le processeur.
Oui, je comprends. Mon point portait sur le fait que nous sommes même capables d’avoir des milliards de transistors sur un seul circuit — la fiabilité est implicite, autrement personne ne pourrait vendre ces puces. Je n’essayais pas d’expliquer la partie abstraction du système d’exploitation/ISA, juste le côté physique de la façon dont ils y tiennent tous et fonctionnent encore.