Mot (architecture informatique)

En informatique , un mot est l'unité naturelle de données utilisée par une conception de processeur particulière . Un mot est une donnée de taille fixe traitée comme une unité par le jeu d'instructions ou le matériel du processeur. Le nombre de bits ou de chiffres dans un mot (la taille du mot , la largeur du mot ou la longueur du mot ) est une caractéristique importante de toute conception de processeur ou architecture d'ordinateur spécifique .

La taille d'un mot se reflète dans de nombreux aspects de la structure et du fonctionnement d'un ordinateur. La majorité des registres d'un processeur ont généralement la taille d'un mot et la plus grande donnée pouvant être transférée vers et depuis la mémoire de travail en une seule opération est un mot dans de nombreuses architectures (pas toutes). La plus grande taille d'adresse possible , utilisée pour désigner un emplacement en mémoire, est généralement un mot matériel (ici, « mot matériel » signifie le mot naturel de taille complète du processeur, par opposition à toute autre définition utilisée).

La documentation des ordinateurs plus anciens avec une taille de mot fixe indique généralement les tailles de mémoire en mots plutôt qu'en octets ou en caractères. La documentation utilise parfois correctement les préfixes métriques , parfois en les arrondissant, par exemple 65 kilomots (kW) signifiant 65 536 mots, et parfois de manière incorrecte, les kilomots (kW) signifiant 1 024 mots (2 ¹⁰ ) et les mégamots (MW) signifiant 1 048 576 mots (2 ²⁰ ). Avec la normalisation des octets 8 bits et de l'adressabilité des octets, l'indication des tailles de mémoire en octets, kilooctets et mégaoctets avec des puissances de 1 024 plutôt que de 1 000 est devenue la norme, bien qu'il existe une certaine utilisation des préfixes binaires IEC .

Plusieurs des premiers ordinateurs (et quelques-uns modernes également) utilisent un système décimal codé en binaire plutôt qu'un système binaire simple , avec généralement une taille de mot de 10 ou 12 chiffres décimaux , et certains des premiers ordinateurs décimaux n'ont aucune longueur de mot fixe. Les premiers systèmes binaires avaient tendance à utiliser des longueurs de mot qui étaient des multiples de 6 bits, le mot de 36 bits étant particulièrement courant sur les ordinateurs centraux . L'introduction de l'ASCII a conduit au passage à des systèmes avec des longueurs de mot qui étaient un multiple de 8 bits, les machines 16 bits étant populaires dans les années 1970 avant le passage aux processeurs modernes à 32 ou 64 bits. Les conceptions à usage spécifique comme les processeurs de signaux numériques peuvent avoir n'importe quelle longueur de mot de 4 à 80 bits.

La taille d'un mot peut parfois différer de la taille attendue en raison de la rétrocompatibilité avec les ordinateurs antérieurs. Si plusieurs variantes compatibles ou une famille de processeurs partagent une architecture et un jeu d'instructions communs mais diffèrent dans leurs tailles de mots, leur documentation et leur logiciel peuvent devenir complexes en termes de notation pour s'adapter à la différence (voir Familles de tailles ci-dessous).

Selon la façon dont un ordinateur est organisé, les unités de taille de mot peuvent être utilisées pour :

Nombres à virgule fixe

Les supports pour les valeurs numériques à virgule fixe , généralement des entiers , peuvent être disponibles dans une ou plusieurs tailles différentes, mais l'une des tailles disponibles sera presque toujours le mot. Les autres tailles, le cas échéant, sont susceptibles d'être des multiples ou des fractions de la taille du mot. Les tailles plus petites ne sont normalement utilisées que pour une utilisation efficace de la mémoire ; lorsqu'elles sont chargées dans le processeur, leurs valeurs sont généralement placées dans un support plus grand, de la taille d'un mot.

Nombres à virgule flottante

Les supports pour les valeurs numériques à virgule flottante sont généralement soit un mot, soit un multiple d'un mot.

Adresses

Les supports pour les adresses mémoire doivent avoir une taille capable d'exprimer la plage de valeurs nécessaire, mais ne pas être excessivement grands. La taille utilisée est donc souvent le mot, bien qu'elle puisse également être un multiple ou une fraction de la taille du mot.

Registres

Les registres du processeur sont conçus avec une taille adaptée au type de données qu'ils contiennent, par exemple des entiers, des nombres à virgule flottante ou des adresses. De nombreuses architectures informatiques utilisent des registres à usage général capables de stocker des données dans plusieurs représentations.

Transfert mémoire-processeur

Lorsque le processeur lit depuis le sous-système mémoire dans un registre ou écrit la valeur d'un registre en mémoire, la quantité de données transférée est souvent un mot. Historiquement, cette quantité de bits pouvant être transférée en un cycle était également appelée catena dans certains environnements (comme le Bull GAMMA 60 ). Dans les sous-systèmes de mémoire simples, le mot est transféré sur le bus de données mémoire , qui a généralement une largeur d'un mot ou d'un demi-mot. Dans les sous-systèmes de mémoire qui utilisent des caches , le transfert de la taille d'un mot est celui entre le processeur et le premier niveau de cache ; aux niveaux inférieurs de la hiérarchie de la mémoire, des transferts plus importants (qui sont un multiple de la taille du mot) sont normalement utilisés.

Unité de résolution d'adresse

Dans une architecture donnée, les valeurs d'adresse successives désignent presque des unités successives de mémoire ; cette unité est l'unité de résolution d'adresse. Dans la plupart des ordinateurs, l'unité est soit un caractère (par exemple un octet) soit un mot. (Quelques ordinateurs ont utilisé la résolution en bits.) Si l'unité est un mot, une plus grande quantité de mémoire peut être accessible en utilisant une adresse d'une taille donnée au prix d'une complexité accrue pour accéder à des caractères individuels. D'un autre côté, si l'unité est un octet, alors des caractères individuels peuvent être adressés (c'est-à-dire sélectionnés pendant l'opération de mémoire).

Instructions

Les instructions machine ont normalement la taille du mot de l'architecture, comme dans les architectures RISC , ou un multiple de la taille du "char" qui en est une fraction. Il s'agit d'un choix naturel puisque les instructions et les données partagent généralement le même sous-système de mémoire. Dans les architectures Harvard, les tailles de mots des instructions et des données ne doivent pas nécessairement être liées, car les instructions et les données sont stockées dans des mémoires différentes ; par exemple, le processeur du commutateur téléphonique électronique 1ESS possède des instructions de 37 bits et des mots de données de 23 bits.

Lors de la conception d'une architecture informatique, le choix d'une taille de mot revêt une importance considérable. Certaines considérations de conception encouragent des tailles de groupe de bits particulières pour des utilisations particulières (par exemple pour les adresses), et ces considérations indiquent des tailles différentes pour différentes utilisations. Cependant, des considérations d'économie dans la conception poussent fortement à une taille unique, ou à un très petit nombre de tailles liées par des multiples ou des fractions (sous-multiples) à une taille primaire. Cette taille préférée devient la taille de mot de l'architecture.

La taille des caractères était autrefois (avant l'encodage des caractères à taille variable ) l'une des influences sur l'unité de résolution d'adresse et le choix de la taille des mots. Avant le milieu des années 1960, les caractères étaient le plus souvent stockés sur six bits ; cela ne permettait pas d'en avoir plus de 64, de sorte que l'alphabet était limité aux majuscules. Comme il est efficace dans le temps et l'espace que la taille des mots soit un multiple de la taille des caractères, les tailles des mots à cette époque étaient généralement des multiples de 6 bits (dans les machines binaires). Un choix courant était alors le mot de 36 bits , qui est également une bonne taille pour les propriétés numériques d'un format à virgule flottante.

Après l'introduction de la conception IBM System/360 , qui utilise des caractères de huit bits et prend en charge les lettres minuscules, la taille standard d'un caractère (ou plus précisément, d'un octet ) passe à huit bits. Les tailles de mots sont désormais naturellement des multiples de huit bits, 16, 32 et 64 bits étant couramment utilisés.

Les premières conceptions de machines comprenaient certaines qui utilisaient ce que l'on appelle souvent une longueur de mot variable . Dans ce type d'organisation, un opérande n'a pas de longueur fixe. Selon la machine et l'instruction, la longueur peut être indiquée par un champ de comptage, par un caractère de délimitation ou par un bit supplémentaire appelé, par exemple, indicateur ou marque verbale . Ces machines utilisent souvent des décimales codées en binaire en chiffres de 4 bits ou en caractères de 6 bits pour les nombres. Cette classe de machines comprend les IBM 702 , IBM 705 , IBM 7080 , IBM 7010 , UNIVAC 1050 , IBM 1401 , IBM 1620 et RCA 301.

La plupart de ces machines fonctionnent sur une unité de mémoire à la fois et comme chaque instruction ou donnée est longue de plusieurs unités, chaque instruction nécessite plusieurs cycles pour accéder à la mémoire. Ces machines sont souvent assez lentes à cause de cela. Par exemple, les recherches d'instructions sur un IBM 1620 Model I prennent 8 cycles (160 μs) pour lire les 12 chiffres de l'instruction (le Model II a réduit ce temps à 6 cycles, ou 4 cycles si l'instruction n'avait pas besoin des deux champs d'adresse). L'exécution d'une instruction prend un nombre variable de cycles, en fonction de la taille des opérandes.

Le modèle de mémoire d'une architecture est fortement influencé par la taille des mots. En particulier, la résolution d'une adresse mémoire, c'est-à-dire la plus petite unité pouvant être désignée par une adresse, a souvent été choisie comme étant le mot. Dans cette approche, l' approche machine adressable par mot , les valeurs d'adresse qui diffèrent d'une unité désignent des mots de mémoire adjacents. Cela est naturel dans les machines qui traitent presque toujours en unités de mots (ou de plusieurs mots), et présente l'avantage de permettre aux instructions d'utiliser des champs de taille minimale pour contenir des adresses, ce qui peut autoriser une taille d'instruction plus petite ou une plus grande variété d'instructions.

Lorsque le traitement des octets doit constituer une part importante de la charge de travail, il est généralement plus avantageux d'utiliser l' octet plutôt que le mot comme unité de résolution d'adresse. Les valeurs d'adresse qui diffèrent d'un octet désignent les octets adjacents en mémoire. Cela permet d'adresser directement un caractère arbitraire dans une chaîne de caractères. Un mot peut toujours être adressé, mais l'adresse à utiliser nécessite quelques bits de plus que l'alternative de résolution de mot. La taille du mot doit être un multiple entier de la taille du caractère dans cette organisation. Cette approche d'adressage a été utilisée dans l'IBM 360 et a été l'approche la plus courante dans les machines conçues depuis lors.

Lorsque la charge de travail implique le traitement de champs de tailles différentes, il peut être avantageux d'adresser les bits. Les machines avec adressage par bits peuvent avoir des instructions qui utilisent une taille d'octet définie par le programmeur et d'autres instructions qui fonctionnent sur des tailles de données fixes. À titre d'exemple, sur l' IBM 7030 (« Stretch »), une instruction à virgule flottante ne peut adresser que des mots tandis qu'une instruction arithmétique sur nombre entier peut spécifier une longueur de champ de 1 à 64 bits, une taille d'octet de 1 à 8 bits et un décalage d'accumulateur de 0 à 127 bits.

Dans une machine adressable par octet avec des instructions de stockage à stockage (SS), il existe généralement des instructions de déplacement pour copier un ou plusieurs octets d'un emplacement arbitraire vers un autre. Dans une machine orientée octet ( adressable par octet ) sans instructions SS, le déplacement d'un seul octet d'un emplacement arbitraire vers un autre est généralement :

1. CHARGER l'octet source
2. STOCKER le résultat dans l'octet cible

Les octets individuels peuvent être consultés sur une machine orientée mots de deux manières. Les octets peuvent être manipulés par une combinaison d'opérations de décalage et de masquage dans les registres. Le déplacement d'un seul octet d'un emplacement arbitraire à un autre peut nécessiter l'équivalent de ce qui suit :

1. CHARGER le mot contenant l'octet source
2. DÉCALAGE du mot source pour aligner l'octet souhaité à la position correcte dans le mot cible
3. ET le mot source avec un masque pour mettre à zéro tous les bits sauf les bits souhaités
4. CHARGER le mot contenant l'octet cible
5. ET le mot cible avec un masque pour mettre à zéro l'octet cible
6. OU les registres contenant les mots source et cible pour insérer l'octet source
7. STOCKER le résultat à l'emplacement cible

De nombreuses machines orientées mots implémentent également des opérations sur octets avec des instructions utilisant des pointeurs d'octets spéciaux dans les registres ou la mémoire. Par exemple, le pointeur d'octet du PDP-10 contenait la taille de l'octet en bits (permettant d'accéder à des octets de tailles différentes), la position de l'octet dans le mot et l'adresse du mot des données. Les instructions pouvaient ajuster automatiquement le pointeur sur l'octet suivant, par exemple, lors des opérations de chargement et de dépôt (stockage).

Différentes quantités de mémoire sont utilisées pour stocker des valeurs de données avec différents degrés de précision. Les tailles couramment utilisées sont généralement une puissance de deux multiples de l'unité de résolution d'adresse (octet ou mot). La conversion de l'index d'un élément d'un tableau en décalage d'adresse mémoire de l'élément ne nécessite alors qu'une opération de décalage plutôt qu'une multiplication. Dans certains cas, cette relation peut également éviter l'utilisation d'opérations de division. Par conséquent, la plupart des conceptions d'ordinateurs modernes ont des tailles de mots (et d'autres tailles d'opérandes) qui sont une puissance de deux fois la taille d'un octet.

Les ordinateurs étant devenus plus complexes, l'importance centrale d'une taille de mot unique pour une architecture a diminué. Bien que les matériels les plus performants puissent utiliser une plus grande variété de tailles de données, les forces du marché exercent une pression pour maintenir la compatibilité ascendante tout en étendant les capacités des processeurs. Par conséquent, ce qui aurait pu être la taille de mot centrale dans une nouvelle conception doit coexister comme taille alternative à la taille de mot d'origine dans une conception rétrocompatible. La taille de mot d'origine reste disponible dans les conceptions futures, formant la base d'une famille de tailles.

Au milieu des années 1970, DEC a conçu le VAX comme successeur 32 bits du PDP-11 16 bits . Ils ont utilisé le mot pour une quantité de 16 bits, tandis que le mot long faisait référence à une quantité de 32 bits ; cette terminologie est la même que celle utilisée pour le PDP-11. Cela contrastait avec les machines précédentes, où l'unité naturelle d'adressage de la mémoire était appelée un mot , tandis qu'une quantité qui est un demi-mot était appelée un demi-mot . Conformément à ce schéma, un quad-mot VAX est de 64 bits. Ils ont continué cette terminologie mot de 16 bits/mot long de 32 bits/quad-mot de 64 bits avec l' Alpha 64 bits .

Un autre exemple est la famille x86 , dont des processeurs de trois longueurs de mots différentes (16 bits, puis 32 et 64 bits) ont été commercialisés, tandis que le mot continue de désigner une quantité de 16 bits. Comme les logiciels sont régulièrement portés d'une longueur de mot à la suivante, certaines API et documentations définissent ou font référence à une longueur de mot plus ancienne (et donc plus courte) que la longueur de mot complète sur le processeur pour lequel le logiciel peut être compilé. De plus, de la même manière que les octets sont utilisés pour les petits nombres dans de nombreux programmes, un mot plus court (16 ou 32 bits) peut être utilisé dans des contextes où la plage d'un mot plus large n'est pas nécessaire (en particulier lorsque cela peut économiser un espace de pile ou de mémoire cache considérable). Par exemple, l'API Windows de Microsoft maintient la définition du langage de programmation WORD à 16 bits, malgré le fait que l'API puisse être utilisée sur un processeur x86 32 ou 64 bits, où la taille de mot standard serait respectivement de 32 ou 64 bits. Les structures de données contenant des mots de tailles aussi différentes les désignent comme suit :

• MOT (16 bits/2 octets)
• DWORD (32 bits/4 octets)
• QWORD (64 bits/8 octets)

Un phénomène similaire s'est développé dans le langage assembleur x86 d'Intel : en raison de la prise en charge de différentes tailles (et de la rétrocompatibilité) dans le jeu d'instructions, certains mnémoniques d'instructions portent des identifiants « d » ou « q » indiquant « double- », « quad- » ou « double-quad- », qui sont exprimés en termes de taille de mot 16 bits d'origine de l'architecture.

La famille IBM System/360 est un exemple de famille avec une taille de mot différente . Dans les architectures System/360 , System/370 et System/390 , il existe des octets de 8 bits, des demi-mots de 16 bits , des mots de 32 bits et des doubles mots de 64 bits . L' architecture z/ , qui est le membre 64 bits de cette famille d'architectures, continue de faire référence aux demi- mots de 16 bits, aux mots de 32 bits et aux doubles mots de 64 bits , et propose en plus des quadruples mots de 128 bits .

En général, les nouveaux processeurs doivent utiliser les mêmes longueurs de mots de données et largeurs d'adresses virtuelles qu'un processeur plus ancien pour avoir une compatibilité binaire avec cet ancien processeur.

Souvent, un code source soigneusement écrit – écrit en gardant à l’esprit la compatibilité du code source et la portabilité du logiciel – peut être recompilé pour s’exécuter sur une variété de processeurs, même ceux avec des longueurs de mots de données différentes ou des largeurs d’adresse différentes ou les deux.