Word (architecture informatique) - Word (computer architecture)
Largeurs de bits de l'architecture informatique |
---|
Bit |
Application |
Précision à virgule flottante binaire |
Précision décimale à virgule flottante |
En informatique , un mot est l'unité naturelle de données utilisée par une conception de processeur particulière . Un mot est une taille fixe donnée traitée comme une unité par le jeu d'instructions ou le matériel du processeur. Le nombre de bits 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 informatique 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 sont généralement de la taille d'un mot et la plus grande partie de données 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 typiquement un mot matériel (ici, « mot matériel » signifie le mot naturel de taille normale du processeur, par opposition à toute autre définition utilisée).
Documentation pour les ordinateurs avec une taille de mot fixe, des tailles de mémoire généralement exprimées en mots plutôt qu'en octets ou en caractères. Des termes tels que kilomots (KW) signifiant 1024 mots (2 10 ) et mégamots (MW) signifiant 1 048 576 mots (2 20 ) étaient normalement utilisés. Avec la normalisation sur les octets 8 bits et l'adressabilité des octets, l'indication des tailles de mémoire en octets, kilo-octets et mégaoctets est devenue la norme.
Plusieurs des premiers ordinateurs (et quelques-uns aussi modernes) utilisaient des décimales codées en binaire plutôt que des binaires simples , ayant généralement une taille de mot de 10 ou 12 chiffres décimaux , et certains premiers ordinateurs décimaux n'avaient aucune longueur de mot fixe. Les premiers systèmes binaires avaient tendance à utiliser des longueurs de mots 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 dont la longueur des mots était 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écial 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 celle 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 par la taille des mots, leur documentation et leur logiciel peuvent devenir complexes sur le plan de la notation pour tenir compte de la différence (voir Familles de tailles ci-dessous).
Utilisations des mots
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 virgule fixe , généralement entier , les valeurs numériques 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 plus petites tailles ne sont normalement utilisées que pour une utilisation efficace de la mémoire ; lorsqu'elles sont chargées dans le processeur, leurs valeurs vont généralement dans un support plus grand et de la taille d'un mot.
- Nombres à virgule flottante
- Les détenteurs des valeurs numériques à virgule flottante sont généralement soit un mot, soit un multiple d'un mot.
- Adresses
- Les détenteurs d'adresses mémoire doivent être d'une taille capable d'exprimer la plage de valeurs nécessaire mais pas excessivement grande, donc souvent la taille utilisée est le mot bien qu'elle puisse aussi être un multiple ou une fraction de la taille du mot.
- Registres
- Les registres de processeur sont conçus avec une taille approprié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 le sous-système de mémoire dans un registre ou écrit la valeur d'un registre dans la mémoire, la quantité de données transférées est souvent un mot. Historiquement, cette quantité de bits pouvant être transférés 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 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, des valeurs d'adresses successives désignent des unités de mémoire successives ; 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, alors une plus grande quantité de mémoire peut être accédée en utilisant une adresse d'une taille donnée au prix d'une complexité supplémentaire pour accéder aux caractères individuels. D'autre part, si l'unité est un octet, 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 "char" qui en est une fraction. C'est un choix naturel car les instructions et les données partagent généralement le même sous-système de mémoire. Dans les architectures de Harvard, les tailles de mots des instructions et des données n'ont pas besoin d'ê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 avait des instructions de 37 bits et des mots de données de 23 bits.
Choix de la taille du mot
Lorsqu'une architecture informatique est conçue, le choix d'une taille de mot est d'une importance considérable. Il existe des considérations de conception qui encouragent des tailles de groupes de bits particulières pour des utilisations particulières (par exemple pour des adresses), et ces considérations indiquent des tailles différentes pour des utilisations différentes. Cependant, des considérations d'économie dans la conception poussent fortement pour une taille, ou très peu 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 dans le passé ( codage de caractères de taille pré-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 n'autorisait pas plus de 64 caractères, donc l'alphabet était limité aux majuscules. Puisqu'il est efficace dans le temps et dans l'espace d'avoir la taille du mot un multiple de la taille des caractères, les tailles des mots dans cette période é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 utilisait des caractères à huit bits et prenait en charge les lettres minuscules, la taille standard d'un caractère (ou plus précisément, un octet ) est devenue huit bits. Les tailles de mots par la suite étaient naturellement des multiples de huit bits, 16, 32 et 64 bits étant couramment utilisés.
Architectures de mots variables
Les premières conceptions de machines en incluaient certaines qui utilisaient ce que l'on appelle souvent une longueur de mot variable . Dans ce type d'organisation, un opérande numérique n'avait pas de longueur fixe mais sa fin était plutôt détectée lorsqu'un caractère avec un marquage spécial, souvent appelé marque verbale , était rencontré. Ces machines utilisaient souvent des décimales codées en binaire pour les nombres. Cette classe de machines comprenait l' IBM 702 , l' IBM 705 , l' IBM 7080 , l' IBM 7010 , l' UNIVAC 1050 , l' IBM 1401 et l' IBM 1620 .
La plupart de ces machines fonctionnent sur une unité de mémoire à la fois et comme chaque instruction ou donnée fait plusieurs unités, chaque instruction prend plusieurs cycles juste pour accéder à la mémoire. Ces machines sont souvent assez lentes à cause de cela. Par exemple, les lectures d'instructions sur un IBM 1620 modèle I prennent 8 cycles juste pour lire les 12 chiffres de l'instruction (le modèle II a réduit cela à 6 cycles, ou 4 cycles si l'instruction n'avait pas besoin des deux champs d'adresse). L'exécution des instructions prenait un nombre de cycles complètement variable, en fonction de la taille des opérandes.
Adressage de mots et d'octets
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 pour être le mot. Dans cette approche, l' approche de la machine adressable par mot , des valeurs d'adresse qui diffèrent d'un mot de mémoire adjacent désigné. Ceci est naturel dans les machines qui traitent presque toujours des unités de mot (ou de plusieurs mots), et a l'avantage de permettre aux instructions d'utiliser des champs de taille minimale pour contenir des adresses, ce qui peut permettre une taille d'instruction plus petite ou une plus grande variété d'instructions.
Lorsque le traitement des octets doit représenter une partie 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 octets adjacents désignés dans la 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 des caractères 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.
Dans une machine orientée octet ( adressable par octet ), déplacer un seul octet d'un emplacement arbitraire à un autre est généralement :
- CHARGER l'octet source
- STOCKEZ le résultat dans l'octet cible
Les octets individuels sont accessibles 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 masque 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 :
- CHARGER le mot contenant l'octet source
- MAJ le mot source pour aligner l'octet souhaité à la bonne position dans le mot cible
- ET le mot source avec un masque pour mettre à zéro tout sauf les bits souhaités
- CHARGER le mot contenant l'octet cible
- ET le mot cible avec un masque pour mettre à zéro l'octet cible
- OU les registres contenant les mots source et cible pour insérer l'octet source
- STOCKEZ le résultat dans l'emplacement cible
Alternativement, de nombreuses machines orientées mots implémentent des opérations sur les octets avec des instructions utilisant des pointeurs d'octets spéciaux dans les registres ou la mémoire. Par exemple, le pointeur d'octet PDP-10 contenait la taille de l'octet en bits (permettant d'accéder à des octets de tailles différentes), la position de bit de l'octet dans le mot et l'adresse de mot des données. Les instructions pourraient ajuster automatiquement le pointeur à l'octet suivant, par exemple, les opérations de chargement et de dépôt (stockage).
Pouvoirs de deux
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. En conséquence, la plupart des conceptions informatiques 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.
Familles de tailles
À mesure que les conceptions informatiques sont devenues plus complexes, l'importance centrale d'une taille de mot unique pour une architecture a diminué. Bien qu'un matériel plus performant puisse utiliser une plus grande variété de tailles de données, les forces du marché font pression pour maintenir la rétrocompatibilité tout en étendant la capacité du processeur. En conséquence, ce qui aurait pu être la taille de mot centrale dans une nouvelle conception doit coexister en tant que taille alternative à la taille de mot d'origine dans une conception rétrocompatible. La taille du 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 un successeur 32 bits du PDP-11 16 bits . Ils ont utilisé word pour une quantité de 16 bits, tandis que longword se référait à une quantité de 32 bits. C'était contrairement aux machines antérieures, où l'unité naturelle de la mémoire d' adressage serait appelé un mot , tandis qu'une quantité qui est la moitié d' un mot serait appelé un demi - mot . En accord avec ce schéma, un quadword VAX est de 64 bits. Ils ont continué cette terminologie mot/mot long/quadword avec l' Alpha 64 bits .
Un autre exemple est la famille x86 , dont les processeurs de trois longueurs de mots différentes (16 bits, plus tard 32 et 64 bits) ont été libérés, tandis que mot continue de désigner une quantité de 16 bits. Comme le logiciel est systématiquement porté d'une longueur de mot à l'autre, 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 CPU 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 beaucoup d'espace de pile ou de cache espace mémoire). Par exemple, l' API Windows de Microsoft maintient la définition du langage de programmation de WORD sur 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 différentes les appellent respectivement WORD (16 bits/2 octets), DWORD (32 bits/4 octets) et 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 compatibilité descendante) dans le jeu d'instructions, certains mnémoniques d'instructions portent des identifiants "d" ou "q" indiquant "double", "quad-". ou "double-quad-", qui sont en termes de taille de mot de 16 bits d'origine de l'architecture.
En général, les nouveaux processeurs doivent utiliser les mêmes longueurs de mots de données et largeurs d'adresse virtuelle qu'un processeur plus ancien pour avoir une compatibilité binaire avec cet ancien processeur.
Le code source souvent soigneusement écrit - écrit avec la compatibilité du code source et la portabilité logicielle à l'esprit - peut être recompilé pour s'exécuter sur une variété de processeurs, même ceux avec différentes longueurs de mots de données ou différentes largeurs d'adresses ou les deux.
Tableau des tailles de mots
clé : bit : bits , d : chiffres décimaux , w : taille de mot de l'architecture, n : taille variable | |||||||
---|---|---|---|---|---|---|---|
Année | Architecture informatique |
Taille du mot w | Tailles entières |
À virgule flottante tailles |
Tailles d' instructions |
Unité de résolution d' adresse |
Taille du caractère |
1837 |
Moteur d'analyse Babbage |
50 jours | w | - | Cinq cartes différentes ont été utilisées pour différentes fonctions, la taille exacte des cartes n'est pas connue. | w | - |
1941 | Zuse Z3 | 22 bits | - | w | 8 bits | w | - |
1942 | abc | 50 bits | w | - | - | - | - |
1944 | Harvard Mark I | 23 jours | w | - | 24 bits | - | - |
1946 (1948) {1953} |
ENIAC (avec panneau n° 16) {avec panneau n° 26} |
10 jours |
w , 2 w (w) {w} |
- | — (2 j, 4 j, 6 j, 8 j) {2 j, 4 j, 6 j, 8 j} |
— — {w} |
- |
1948 | Bébé Manchester | 32 bits | w | - | w | w | - |
1951 | UNIVAC I | 12 jours | w | - | 1 ⁄ 2 w | w | 1 jour |
1952 | machine IAS | 40 bits | w | - | 1 ⁄ 2 w | w | 5 bits |
1952 | Ordinateur numérique universel rapide M-2 | 34 bits | w? | w | 34 bits = code opération 4 bits plus adresse 3 × 10 bits | 10 bits | - |
1952 | IBM 701 | 36 bits | 1 ⁄ 2 w , w | - | 1 ⁄ 2 w | 1 ⁄ 2 w , w | 6 bits |
1952 | UNIVAC 60 | n d | 1 j, ... 10 j | - | - | - | 2 jours, 3 jours |
1952 | ARRA I | 30 bits | w | - | w | w | 5 bits |
1953 | IBM 702 | n d | 0 j, ... 511 j | - | 5 jours | ré | 1 jour |
1953 | UNIVAC 120 | n d | 1 j, ... 10 j | - | - | - | 2 jours, 3 jours |
1953 | ARRA II | 30 bits | w | 2 semaines | 1 ⁄ 2 w | w | 5 bits |
1954 (1955) |
IBM 650 (avec IBM 653 ) |
10 jours | w | - (w) |
w | w | 2 jours |
1954 | IBM 704 | 36 bits | w | w | w | w | 6 bits |
1954 | IBM 705 | n d | 0 j, ... 255 j | - | 5 jours | ré | 1 jour |
1954 | IBM NORC | 16 jours | w | w , 2 w | w | w | - |
1956 | IBM 305 | n d | 1 j, ... 100 j | - | 10 jours | ré | 1 jour |
1956 | ARMAC | 34 bits | w | w | 1 ⁄ 2 w | w | 5 bits, 6 bits |
1957 | Autonetics Recomp I | 40 bits | w , 79 bits, 8 d, 15 d | - | 1 ⁄ 2 w | 1 ⁄ 2 w , w | 5 bits |
1958 | UNIVAC II | 12 jours | w | - | 1 ⁄ 2 w | w | 1 jour |
1958 | SAUGE | 32 bits | 1 ⁄ 2 w | - | w | w | 6 bits |
1958 | Autonetics Recomp II | 40 bits | w , 79 bits, 8 d, 15 d | 2 semaines | 1 ⁄ 2 w | 1 ⁄ 2 w , w | 5 bits |
1958 | Setun | 6 bits (~9,5 bits) | jusqu'à 6 essais | jusqu'à 3 essais | 4 trit ? | ||
1958 | Electrologica X1 | 27 bits | w | 2 semaines | w | w | 5 bits, 6 bits |
1959 | IBM 1401 | n d | 1 j, ... | - | 1 j, 2 j, 4 j, 5 j, 7 j, 8 j | ré | 1 jour |
1959 (à déterminer) |
IBM 1620 | n d | 2 jours, ... | — (4 j, ... 102 j) |
12 jours | ré | 2 jours |
1960 | LARC | 12 jours | w , 2 w | w , 2 w | w | w | 2 jours |
1960 | CDC 1604 | 48 bits | w | w | 1 ⁄ 2 w | w | 6 bits |
1960 | IBM 1410 | n d | 1 j, ... | - | 1 j, 2 j, 6 j, 7 j, 11 j, 12 j | ré | 1 jour |
1960 | IBM 7070 | 10 jours | w | w | w | w , d | 2 jours |
1960 | PDP-1 | 18 bits | w | - | w | w | 6 bits |
1960 | Elliott 803 | 39 bits | |||||
1961 |
IBM 7030 (Extensible) |
64 bits | 1 bit, ... 64 bits, 1 d, ... 16 d |
w | 1 ⁄ 2 w , w | b, 1 / deux w , w | 1 bit, ... 8 bits |
1961 | IBM 7080 | n d | 0 j, ... 255 j | - | 5 jours | ré | 1 jour |
1962 | GE-6xx | 36 bits | w , 2 w | w , 2 w , 80 bits | w | w | 6 bits, 9 bits |
1962 | UNIVAC III | 25 bits | w , 2 w , 3 w , 4 w , 6 j, 12 j | - | w | w | 6 bits |
1962 | Ordinateur de guidage
Autonetics D-17B Minuteman I |
27 bits | 11 bits, 24 bits | - | 24 bits | w | - |
1962 | UNIVAC 1107 | 36 bits | 1 ⁄ 6 w , 1 ⁄ 3 w , 1 ⁄ 2 w , w | w | w | w | 6 bits |
1962 | IBM 7010 | n d | 1 j, ... | - | 1 j, 2 j, 6 j, 7 j, 11 j, 12 j | ré | 1 jour |
1962 | IBM 7094 | 36 bits | w | w , 2 w | w | w | 6 bits |
1962 | Série FDS 9 | 24 bits | w | 2 semaines | w | w | |
1963 (1966) |
Ordinateur de guidage Apollo | 15 bits | w | - | w , 2 w | w | - |
1963 | Ordinateur numérique du véhicule de lancement Saturn | 26 bits | w | - | 13 bits | w | - |
1964/1966 | PDP-6 / PDP-10 | 36 bits | w | w , 2 w | w | w | 6 bits, 9 bits (typique) |
1964 | Titan | 48 bits | w | w | w | w | w |
1964 | CDC 6600 | 60 bits | w | w | 1 ⁄ 4 w , 1 ⁄ 2 w | w | 6 bits |
1964 | Ordinateur de guidage
Autonetics D-37C Minuteman II |
27 bits | 11 bits, 24 bits | - | 24 bits | w | 4 bits, 5 bits |
1965 | Ordinateur de guidage Gemini | 39 bits | 26 bits | - | 13 bits | 13 bits, 26 | -bit |
1965 | IBM 360 | 32 bits |
1 ⁄ 2 w , w , 1 d, ... 16 j |
w , 2 w | 1 ⁄ 2 w , w , 1 1 ⁄ 2 w | 8 bits | 8 bits |
1965 | UNIVAC 1108 | 36 bits | 1 / six w , 1 / quatre w , 1 / trois w , 1 / 2 w , w , 2 w | w , 2 w | w | w | 6 bits, 9 bits |
1965 | PDP-8 | 12 bits | w | - | w | w | 8 bits |
1965 | Electrologica X8 | 27 bits | w | 2 semaines | w | w | 6 bits, 7 bits |
1966 | FDS Sigma 7 | 32 bits | 1 ⁄ 2 w , w | w , 2 w | w | 8 bits | 8 bits |
1969 | Systèmes à quatre phases AL1 | 8 bits | w | - | ? | ? | ? |
1970 | MP944 | 20 bits | w | - | ? | ? | ? |
1970 | PDP-11 | 16 bits | w | 2 w , 4 w | w , 2 w , 3 w | 8 bits | 8 bits |
1971 | TMS1802NC | 4 bits | w | - | ? | ? | - |
1971 | Intel 4004 | 4 bits | w , d | - | 2 w , 4 w | w | - |
1972 | Intel 8008 | 8 bits | w , 2 d | - | w , 2 w , 3 w | w | 8 bits |
1972 | Calcomp 900 | 9 bits | w | - | w , 2 w | w | 8 bits |
1974 | Intel 8080 | 8 bits | w , 2 w , 2 d | - | w , 2 w , 3 w | w | 8 bits |
1975 | ILLIAQUE IV | 64 bits | w | w , une / deux w | w | w | - |
1975 | Motorola 6800 | 8 bits | w , 2 d | - | w , 2 w , 3 w | w | 8 bits |
1975 |
MOS Tech. 6501 MOS Tech. 6502 |
8 bits | w , 2 d | - | w , 2 w , 3 w | w | 8 bits |
1976 | Cray-1 | 64 bits | 24 bits, avec | w | 1 ⁄ 4 w , 1 ⁄ 2 w | w | 8 bits |
1976 | Zilog Z80 | 8 bits | w , 2 w , 2 d | - | w , 2 w , 3 w , 4 w , 5 w | w | 8 bits |
1978 (1980) |
16 bits x86 ( Intel 8086 ) (avec virgule flottante : Intel 8087 ) |
16 bits | 1 ⁄ 2 w , w , 2 d | — (2 semaines , 4 semaines , 5 semaines , 17 jours) |
1 ⁄ 2 w , w , ... 7 w | 8 bits | 8 bits |
1978 | VAX | 32 bits | 1 / quatre w , 1 / deux w , w , 1 d, 31 d ..., 1 bit, ... 32 bits | w , 2 w | 1 / 4 w , ... 14 1 / 4 w | 8 bits | 8 bits |
1979 (1984) |
Motorola série 68000 (avec virgule flottante) |
32 bits | 1 / 4 w , 1 / 2 w , w , d 2 | — ( w , 2 w , 2 1 ⁄ 2 w ) |
1 ⁄ 2 w , w , ... 7 1 ⁄ 2 w | 8 bits | 8 bits |
1985 | IA-32 ( Intel 80386 ) (avec virgule flottante) | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | — ( w , 2 w , 80 bits) |
8 bits, le bit 120 ... une / 4 w ... 3 3 / 4 w |
8 bits | 8 bits |
1985 | ARMv1 | 32 bits | 1 ⁄ 4 w , w | - | w | 8 bits | 8 bits |
1985 | MIPS | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | w , 2 w | w | 8 bits | 8 bits |
1991 | Cray C90 | 64 bits | 32 bits, avec | w | 1 / 4 w , 1 / deux w , 48 bits | w | 8 bits |
1992 | Alpha | 64 bits | 8 bits, 1 / quatre w , 1 / 2 w , w | 1 ⁄ 2 w , w | 1 ⁄ 2 w | 8 bits | 8 bits |
1992 | PowerPC | 32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | w , 2 w | w | 8 bits | 8 bits |
1996 |
ARMv4 (avec pouce ) |
32 bits | 1 ⁄ 4 w , 1 ⁄ 2 w , w | - |
w ( 1 ⁄ 2 w , w ) |
8 bits | 8 bits |
2000 |
IBM z/Architecture (avec fonction vectorielle) |
64 bits |
1 ⁄ 4 w , 1 ⁄ 2 w , w 1 d, ... 31 j |
1 ⁄ 2 w , w , 2 w | 1 / quatre w , 1 / deux w , 3 / quatre w | 8 bits | 8 bits, UTF-16 , UTF-32 |
2001 | IA-64 | 64 bits | 8 bits, 1 / quatre w , 1 / 2 w , w | 1 ⁄ 2 w , w | 41 bits | 8 bits | 8 bits |
2001 |
ARMv6 (avec VFP) |
32 bits | 8 bits, une / deux w , w | - (w, 2w) |
1 ⁄ 2 w , w | 8 bits | 8 bits |
2003 | x86-64 | 64 bits | 8 bits, 1 / quatre w , 1 / 2 w , w | 1 ⁄ 2 w , w , 80 bits | 8 bits, ... 120 bits | 8 bits | 8 bits |
2013 | ARMv8-A et ARMv9-A | 64 bits | 8 bits, 1 / quatre w , 1 / 2 w , w | 1 ⁄ 2 w , w | 1 ⁄ 2 w | 8 bits | 8 bits |
Année | Architecture informatique |
Taille du mot w | Tailles entières |
À virgule flottante tailles |
Tailles d' instructions |
Unité de résolution d' adresse |
Taille du caractère |
clé : bit : bits, d : chiffres décimaux, w : taille de mot de l'architecture, n : taille variable |