# Mot (architecture informatique)

En architecture informatique, un mot est une unité de base manipulée par un microprocesseur. On parle aussi de mot machine. La taille d’un mot s’exprime en bits, parfois même en octets. Elle est souvent utilisée pour classer les microprocesseurs (32 bits, 64 bits, etc.). Toutes choses étant égales par ailleurs, un microprocesseur est d’autant plus rapide que ses mots sont longs, car les données qu'il traite à chaque cycle sont plus importantes. Sur les microprocesseurs qui peuvent manipuler différentes tailles de données, la taille des mots est choisie arbitrairement, dans le but d’avoir une convention de nommage (en particulier, les instructions dont le mnémonique ne contient pas d’indication explicite de taille s’appliquent à des mots). On prend généralement la taille des principaux registres de données, ou la taille du bus de données.
Les ordinateurs grand public modernes et processeurs modernes utilisent généralement des données de 8, 16, 32 ou 64 bits, bien que d'autres tailles soient possibles. Ces tailles ont été historiquement fixées par l'architecture matérielle, qui a évolué au cours des âges. Avec l'interopérabilité, la nomenclature la plus couramment utilisée par les éditeurs de langages de développement logicielle est normalisée comme suit :
* donnée de 8 bits : « octet », parfois abusivement « byte » ;
* donnée de 16 bits : « word » ou « mot », parfois « seizet » voire « doublet » ;
* donnée de 32 bits : « dword » ou « double mot », parfois (rarement) « trente-deuzet » ;
* donnée de 64 bits : « qword » ou « quadruple mot ».
En revanche, au niveau architecture matérielle, le « mot » est fondamentalement la taille du bus mémoire, soit la taille de la donnée unitaire capable de transiter entre les zones de stockage mémoire et les registres du processeur central (voir plus bas). Cette taille n'est pas normalisée, mais est généralement un multiple entier ou fractionnaire du mot « logiciel », c'est-à-dire un multiple de 16.

## Utilisation

En fonction de l'architecture étudiée, une donnée unitaire réduite au mot peut être utilisée pour :

### Nombre réel à virgule fixe

Le nombre réel à virgule fixe sert à contenir un nombre à virgule fixe ; classiquement un entier, une valeur numérique disponible en une ou plusieurs capacités, mais l'une de ces tailles sera quasiment toujours le mot.
Les autres tailles, s'il y en a, étant des fractions ou des multiples du mot, et de l'entier de référence, pour des raisons d'optimisation de la mémoire : lorsque mises à disposition au sein du processeur, les valeurs multiples iront dans un registre ajusté à la taille d'un ou plusieurs mots.

### Nombre à virgule flottante

Le nombre à virgule flottante contient un nombre réel à virgule flottante, valeur numérique classiquement de la taille d'un mot, ou d'un multiple d'un mot.

### Adresse

L'adresse contient un pointeur vers un emplacement de mémoire, et doit par conséquent être de la taille nécessaire pour pouvoir adresser n'importe quel emplacement en mémoire, sans être exagérément large. La taille est souvent ajustée au mot, permettant d'adresser la capacité mémoire, mais elle peut aussi être une fraction de la taille d'un mot.

### Registre

Le registre de processeur est conçu pour avoir une taille adaptée à la taille de la donnée qu'il devra contenir, par exemple, un entier, virgule flottante ou pointeur. De nombreuses architectures utilisent des « registres multi-usages » pouvant contenir de nombreux types de données ; ils doivent alors être dimensionnés pour pouvoir recevoir le type de données le plus grand. Historiquement, cette taille est celle du mot de l'architecture étudiée, bien que, pour des besoins particuliers, de nouveaux registres aient progressivement été ajoutés pour pouvoir gérer les nouveaux types de données.

### Variables du processeur de transfert mémoire

Lorsque le processeur effectue des transferts entre la mémoire et ses propres registres, la quantité de données à transmettre est habituellement celle d'un mot. Dans les architectures mémoire simples, le mot est transféré jusqu'à la mémoire via le bus mémoire, qui a généralement une largeur d'un mot, ou d'un demi-mot. Dans les architectures qui gèrent une mémoire cache, les transferts de la taille d'un mot sont ceux entre le processeur et le premier niveau de cache ; aux autres niveaux dans la hiérarchie de mémoire, ce sont des transferts plus volumineux (d'une taille d'un multiple d'un mot) qui sont utilisés.

### Unité d'adressage

Pour une architecture donnée, les adresses successives désignent des unités de mémoire successives ; cette unité est l'unité d'adressage. Pour la plupart des ordinateurs, elle a la taille d'un « char », c'est-à-dire un octet, ou un mot. Quelques architectures ont une unité d'adressage de la taille d'un bit. Si cette unité est un mot, alors une quantité de mémoire plus importante peut être adressée en utilisant une adresse d'une taille arbitraire à la contrepartie d'une complexité accrue pour l'adressage d'un unique byte. En corollaire, si l'unité d'adressage est un byte, les « chars » peuvent être adressés directement (par exemple durant les entrées/sorties mémoire).

### Instructions

Une instruction en langage machine est normalement de la taille d'un mot, comme dans les architectures RISC, ou de la taille d'un de ses multiples. C'est un choix naturel dans la mesure où les instructions et les données partagent la même mémoire dans le système. Dans l'architecture Harvard, les tailles des mots des instructions et des données ne sont pas reliées, dans la mesure où les données sont stockées dans des mémoires différentes ; par exemple, le processeur au sein du commutateur téléphonique 1ESS a des jeux d'instruction sur 37 bits, et des emplacements mémoire basés sur des mots de 23 bits.

## Évolution de la taille des mots à travers les années

key : b : bits, d : "digit" décimal, w : taille du mot (word) dans l'architecture, n : taille des variables$^,$ :
| Année | Computer architecture | Taille du mot w | Taille des Entiers | Taille des Virgule flottante | Taille des Instructions | Adresse unitaire resolution | Taille du caractère |
| 1837 | Babbage Machine analytique | 50 d | w | — | Cinq cartes différentes ont été utilisées pour différents usages, la taille exacte des cartes n'est pas connue | w | — |
| 1941 | Zuse Z3 | 22 b | — | w | 8 b | w | — |
| 1942 | ABC | 50 b | w | — | — | — | — |
| 1944 | Harvard Mark I | 23 d | w | — | 24 b | — | — |
| 1946 (1948) {1953} | ENIAC (w/ Panel #16) {w/ Panel #26} | 10 d | w, 2w (w) {w} | — | — (2d, 4d, 6d, 8d) {2d, 4d, 6d, 8d} | — — {w} | — |
| 1951 | UNIVAC I | 12 d | w | — | ½w | w | 1 d |
| 1952 | IAS machine | 40 b | w | — | ½w | w | 5 b |
| 1952 | Fast Universal Digital Computer M-2 | 34 b | w? | w | 34 b = 4 b d'opcode plus 3× 10 b d'addresse | 10 b | — |
| 1952 | IBM 701 | 36 b | ½w, w | — | ½w | ½w, w | 6 b |
| 1952 | UNIVAC 60 | n d | 1d, ... 10d | — | — | — | 2d, 3d |
| 1953 | IBM 702 | n d | 0d, ... 511d | — | 5d | d | 1 d |
| 1953 | UNIVAC 120 | n d | 1d, ... 10d | — | — | — | 2d, 3d |
| 1954 (1955) | IBM 650 (w/IBM 653) | 10 d | w | — (w) | w | w | 2 d |
| 1954 | IBM 704 | 36 b | w | w | w | w | 6 b |
| 1954 | IBM 705 | n d | 0d, ... 255d | — | 5d | d | 1 d |
| 1954 | IBM NORC | 16 d | w | w, 2w | w | w | — |
| 1956 | IBM 305 | n d | 1d, ... 100d | — | 10d | d | 1 d |
| 1957 | Autonetics Recomp I | 40 b | w, 79 b, 8d, 15d | — | ½w | ½w, w | 5 b |
| 1958 | UNIVAC II | 12 d | w | — | ½w | w | 1 d |
| 1958 | SAGE | 32 b | ½w | — | w | w | 6 b |
| 1958 | Autonetics Recomp II | 40 b | w, 79 b, 8d, 15d | 2w | ½w | ½w, w | 5 b |
| 1958 | Setun | 6 trit (~9.5 b) | jusqu'à 6 trits | | jusqu'à 3 trits | | 4 trits$^?$ |
| 1959 | IBM 1401 | n d | 1d, ... | — | d, 2d, 4d, 5d, 7d, 8d | d | 1 d |
| 1959 (TBD) | IBM 1620 | n d | 2d, ... | — (4d, ... 102d) | 12d | d | 2 d |
| 1960 | LARC | 12 d | w, 2w | w, 2w | w | w | 2 d |
| 1960 | CDC 1604 | 48 b | w | w | ½w | w | 6 b |
| 1960 | IBM 1410 | n d | 1d, ... | — | d, 2d, 6d, 7d, 11d, 12d | d | 1 d |
| 1960 | IBM 7070 | 10 d | w | w | w | w, d | 2 d |
| 1960 | PDP-1 | 18 b | w | — | w | w | 6 b |
| 1960 | Elliott 803 | 39 b + 1 parity | | | | | |
| 1961 | IBM 7030 (Stretch) | 64 b | 1b, ... 64b, 1d, ... 16d | w | ½w, w | b, ½w, w | 1 b, ... 8 b |
| 1961 | IBM 7080 | n d | 0d, ... 255d | — | 5d | d | 1 d |
| 1962 | GE-6xx | 36 b | w, 2 w | w, 2 w, 80 b | w | w | 6 b, 9 b |
| 1962 | UNIVAC III | 25 b | w, 2w, 3w, 4w, 6d, 12d | — | w | w | 6 b |
| 1962 | Autonetics D-17B Calculateur de guidage du Minuteman I | 27 b | 11 b, 24 b | — | 24 b | w | — |
| 1962 | UNIVAC 1107 | 36 b | ⅙ w, ⅓w, ½w, w | w | w | w | 6 b |
| 1962 | IBM 7010 | n d | 1d, ... | — | d, 2d, 6d, 7d, 11d, 12d | d | 1 d |
| 1962 | IBM 7094 | 36 b | w | w, 2w | w | w | 6 b |
| 1963/1966 | PDP-6/PDP-10 | 36 b | w | w, 2 w | w | w | 6 b, 9 b (typical) |
| 1963 | Gemini Guidance Computer | 39 b | 26 b | — | 13 b | 13 b, 26 b | — |
| 1963 (1966) | Apollo Guidance Computer | 15 b | w | — | w, 2w | w | — |
| 1963 | Saturn Launch Vehicle Digital Computer | 26 b | w | — | 13 b | w | — |
| 1964 | CDC 6600 | 60 b | w | w | ¼w, ½w | w | 6 b |
| 1964 | Autonetics D-37C Calculateur de guidage du Minuteman II | 27 b | 11 b, 24 b | — | 24 b | w | 4 b, 5 b |
| 1965 | IBM 360 | 32 b | ½w, w, 1d, ... 16d | w, 2w | ½w, w, 1½w | 8 b | 8 b |
| 1965 | UNIVAC 1108 | 36 b | ⅙ w, ¼w, ⅓w, ½w, w, 2w | w, 2w | w | w | 6 b, 9 b |
| 1965 | PDP-8 | 12 b | w | — | w | w | 8 b |
| 1970 | PDP-11 | 16 b | w | 2w, 4w | w, 2w, 3w | 8 b | 8 b |
| 1971 | Intel 4004 | 4 b | w, d | — | 2w, 4w | w | — |
| 1972 | Intel 8008 | 8 b | w, 2d | — | w, 2w, 3w | w | 8 b |
| 1972 | Calcomp 900 | 9 b | w | — | w, 2w | w | 8 b |
| 1974 | Intel 8080 | 8 b | w, 2w, 2d | — | w, 2w, 3w | w | 8 b |
| 1975 | ILLIAC IV | 64 b | w | w, ½w | w | w | — |
| 1975 | Motorola 6800 | 8 b | w, 2d | — | w, 2w, 3w | w | 8 b |
| 1975 | MOS Tech. 6501 MOS Tech. 6502 | 8 b | w, 2d | — | w, 2w, 3w | w | 8 b |
| 1976 | Cray-1 | 64 b | 24 b, w | w | ¼w, ½w | w | 8 b |
| 1976 | Zilog Z80 | 8 b | w, 2w, 2d | — | w, 2w, 3w, 4w, 5w | w | 8 b |
| 1978 (1980) | 16-bit x86 (Intel 8086) (avec virgule flottante : Intel 8087) | 16 b | ½w, w, 2d | — (2w, 4w, 5w, 17d) | ½w, w, ... 7w | 8 b | 8 b |
| 1978 | VAX | 32 b | ¼w, ½w, w, 1d, ... 31d, 1b, ... 32b | w, 2w | ¼w, ... 14¼w | 8 b | 8 b |
| 1979 (1984) | Famille Motorola 68000 (avec virgule flottante) | 32 b | ¼w, ½w, w, 2d | — (w, 2w, 2½w) | ½w, w, ... 7½w | 8 b | 8 b |
| 1985 | IA-32 (Intel 80386) (avec virgule flottante) | 32 b | ¼w, ½w, w, 2d | — (w, 2w, 2½w, 17d) | ¼w, ½w, w, ... 3¾w | 8 b | 8 b |
| 1985 | ARMv1 | 32 b | ¼w, w | — | w | 8 b | 8 b |
| 1985 | MIPS | 32 b | ¼w, ½w, w | w, 2w | w | 8 b | 8 b |
| 1991 | Cray C90 | 64 b | 32 b, w | w | ¼w, ½w, 48b | w | 8 b |
| 1992 | Alpha | 64 b | 8b, ¼w, ½w, w | w, 2w | ½w | 8 b | 8 b |
| 1992 | PowerPC | 32 b | ¼w, ½w, w | w, 2w | w | 8 b | 8 b |
| 1996 | ARMv4 (avec Thumb) | 32 b | ¼w, ½w, w | — | w (½w, w) | 8 b | 8 b |
| 2001 | IA-64 | 64 b | 8 b, ¼w, ½w, w | ½w, w | 41 b | 8 b | 8 b |
| 2001 | ARMv6 (avec VFP) | 32 b | ¼w, ½w, w | — (w, 2w) | ½w, w | 8 b | 8 b |
| 2003 | x86-64 | 64 b | 8b, ¼w, ½w, w | ½w, w, 1¼w, 17d | 8b, ¼w, ½w, w, ... 1⅞w | 8 b | 8 b |
| 2013 | ARMv8-A | 64 b | 8b, ¼w, ½w, w | ½w, w | ½w | 8 b | 8 b |
| key : b : bits, d : "digit" décimal, w : taille du mot (word) dans l'architecture, n : taille des variables$^,$ ||||||||