Aller au contenu

Mot (architecture informatique)

Un article de Wikipédia, l'encyclopédie libre.
(Redirigé depuis Mot (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[1]. Elle est souvent utilisée pour classer les microprocesseurs (32 bits, 64 bitsetc.). 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[2] comme suit :

  • donnée de 8 bits : « octet », parfois abusivement « byte » ;
  • donnée de 16 bits : « word » ou « mot », parfois « seizet »[3] voire « doublet » ;
  • donnée de 32 bits : « dword » ou « double mot », parfois (rarement) « trente-deuzet »[3] ;
  • 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[4] (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

[modifier | modifier le code]

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

[modifier | modifier le code]

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

[modifier | modifier le code]

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.

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.

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

[modifier | modifier le code]

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[4]. 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

[modifier | modifier le code]

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[5]. 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

[modifier | modifier le code]

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

[modifier | modifier le code]
key : b : bits, d : "digit" décimal, w : taille du mot (word) dans l'architecture, n : taille des variables[6],[7]
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[8])
{w/ Panel #26[9]}
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 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[6],[7]

Notes et références

[modifier | modifier le code]
  1. Jon Erickson, Techniques de hacking, 2008 (2012 pour l'éd. française) (ISBN 2744066966), « 0x200- Programmation », p. 31
  2. La version française de la norme ISO/CEI 10646
  3. a et b Terme utilisé notamment dans la version française de la norme ISO/CEI 10646.
  4. a et b Alain Cazes et Joëlle Delacroix, Architecture des machines et des systèmes informatiques, Paris, Dunod, (réimpr. 2005, 2008, 2011, 2015 (5e)) (ISBN 978-2-10-072705-6), « 1. Structure générale et fonctionnement d’un ordinateur », p. 31
  5. Dennis M. Ritchie et Brian W. Kernighan, Le langage C, Paris, Masson, [détail des éditions] (ISBN 2-225-80068-5, lire en ligne), p. 260, 261.
  6. a et b Gerrit A. Blaauw et Frederick P. Brooks, Computer Architecture : Concepts and Evolution, Addison-Wesley, (ISBN 0-201-10557-8)
  7. a et b Anthony Ralston et Edwin D. Reilly, Encyclopedia of Computer Science Third Edition, Van Nostrand Reinhold, , 1558 p. (ISBN 0-442-27679-6)
  8. (en) Computer History : Eniac coding, ARL (lire en ligne)
  9. (en) Computer History : Eniac coding, ARL (lire en ligne), chap. 8

Articles connexes

[modifier | modifier le code]