Informatique 64 bits - 64-bit computing

Dans l'architecture informatique , les entiers 64 bits , les adresses mémoire ou d'autres unités de données sont ceux qui ont une largeur de 64 bits (8 octets ). En outre, les architectures d' unité centrale de traitement (CPU) et d' unité arithmétique et logique (ALU) 64 bits sont basées sur des registres de processeur , des bus d'adresse ou des bus de données de cette taille. Les micro -ordinateurs 64 bits sont des ordinateurs dans lesquels les microprocesseurs 64 bits sont la norme. Du point de vue logiciel, l'informatique 64 bits signifie l'utilisation de code machine avec des adresses de mémoire virtuelle 64 bits . Cependant, tous les jeux d'instructions 64 bits ne prennent pas en charge les adresses de mémoire virtuelle 64 bits complètes ; x86-64 et ARMv8 , par exemple, ne prennent en charge que 48 bits d'adresse virtuelle, les 16 bits restants de l'adresse virtuelle devant être tous des 0 ou des 1, et plusieurs jeux d'instructions de 64 bits prennent en charge moins de 64 bits de mémoire physique adresse.

Le terme 64 bits décrit une génération d'ordinateurs dans laquelle les processeurs 64 bits sont la norme. 64 bits est une taille de mot qui définit certaines classes d'architecture informatique, de bus, de mémoire et de processeurs et, par extension, les logiciels qui s'exécutent dessus. Les processeurs 64 bits sont utilisés dans les superordinateurs depuis les années 1970 ( Cray-1 , 1975) et dans les postes de travail et serveurs basés sur des ordinateurs à jeu d'instructions réduit (RISC) depuis le début des années 1990, notamment les MIPS R4000 , R8000 et R10000 , l' équipement numérique. Corporation (DEC) Alpha , les microprocesseurs Sun Microsystems UltraSPARC et les microprocesseurs IBM RS64 et POWER3 et ultérieurs POWER . En 2003, les processeurs 64 bits ont été introduits sur le marché des ordinateurs personnels grand public (anciennement 32 bits ) sous la forme de processeurs x86-64 et du PowerPC G5 , et ont été introduits en 2012 dans l' architecture ARM ciblant les smartphones et les tablettes , d'abord vendu le 20 septembre 2013 dans l' iPhone 5S alimenté par le système ARMv8-A Apple A7 sur puce (SoC).

Un registre de 64 bits peut contenir n'importe laquelle des 2 64 valeurs différentes (plus de 18 quintillions ou 1,8 × 10 19 ). La plage de valeurs entières pouvant être stockées sur 64 bits dépend de la représentation entière utilisée. Avec les deux représentations les plus courantes, la plage va de 0 à 18 446 744 073 709 551 615 (2 64 − 1) pour la représentation sous forme de nombre binaire ( non signé ) et de − 9 223 372 036 854 775 808 (−2 63 ) à 9 223 372 036 854 775 807 (2 63 − 1) pour la représentation en complément à deux . Ainsi, un processeur avec des adresses mémoire de 64 bits peut accéder directement à 2 64 octets (16 exbioctets ou EiB) de mémoire adressable par octet .

Sans autre qualification, une architecture informatique 64 bits possède généralement des registres de processeur d' entiers et d'adressage d' une largeur de 64 bits, permettant une prise en charge directe des types de données et des adresses 64 bits. Cependant, un processeur peut avoir des bus de données externes ou des bus d'adresses avec des tailles différentes des registres, voire plus grandes (le Pentium 32 bits avait un bus de données 64 bits, par exemple).

Le terme peut également faire référence à la taille des types de données de bas niveau, tels que les nombres arithmétiques à virgule flottante 64 bits .

Implications architecturales

Les registres du processeur sont généralement divisés en plusieurs groupes : entier , virgule flottante , simple-instruction-multiple-data ( SIMD ), contrôle et souvent des registres spéciaux pour l'arithmétique d'adresse qui peuvent avoir diverses utilisations et noms tels que adresse , index ou base registres . Cependant, dans les conceptions modernes, ces fonctions sont souvent exécutées par des registres d' entiers à usage plus général . Dans la plupart des processeurs, seuls les registres d'entiers ou d'adresses peuvent être utilisés pour adresser les données en mémoire ; les autres types de registres ne le peuvent pas. La taille de ces registres limite donc normalement la quantité de mémoire directement adressable, même s'il existe des registres, tels que des registres à virgule flottante, qui sont plus larges.

La plupart des processeurs 32 bits et 64 bits hautes performances (quelques exceptions notables sont les processeurs d'architecture ARM plus anciens ou intégrés (ARM) et d' architecture MIPS 32 bits (MIPS)) ont intégré du matériel à virgule flottante, qui est souvent, mais pas toujours, basé sur des unités de données 64 bits. Par exemple, bien que l' architecture x86 / x87 dispose d'instructions capables de charger et de stocker des valeurs à virgule flottante 64 bits (et 32 ​​bits) en mémoire, le format de données et de registres à virgule flottante interne a une largeur de 80 bits, tandis que le format à usage général les registres ont une largeur de 32 bits. En revanche, la famille Alpha 64 bits utilise un format de données et de registres à virgule flottante 64 bits et des registres d'entiers 64 bits.

Histoire

De nombreux jeux d' instructions informatiques sont conçus de manière à ce qu'un seul registre entier puisse stocker l' adresse mémoire à n'importe quel emplacement de la mémoire physique ou virtuelle de l'ordinateur . Par conséquent, le nombre total d'adresses en mémoire est souvent déterminé par la largeur de ces registres. L' IBM System/360 des années 1960 était un des premiers ordinateurs 32 bits ; il avait des registres entiers de 32 bits, bien qu'il n'utilise que les 24 bits de poids faible d'un mot pour les adresses, ce qui donne un espace d'adressage de 16  Mio ( 16 × 1024 2 octets ). Les supermini -ordinateurs 32 bits , tels que le DEC VAX , sont devenus courants dans les années 1970, et les microprocesseurs 32 bits, tels que la famille Motorola 68000 et les membres 32 bits de la famille x86 à partir de l' Intel 80386 , sont apparus au milieu des années 70. années 1980, faisant de 32 bits un consensus de facto en tant que taille de registre pratique.

Un registre d'adresses de 32 bits signifiait que 2 32 adresses, ou 4  Gio de mémoire vive (RAM), pouvaient être référencées. Lorsque ces architectures ont été conçues, 4 Gio de mémoire dépassaient tellement les quantités typiques (4 MiB) dans les installations, que cela était considéré comme une marge suffisante pour l'adressage. 4,29 milliards d'adresses étaient considérées comme une taille appropriée pour une autre raison importante : 4,29 milliards d'entiers suffisent pour attribuer des références uniques à la plupart des entités dans des applications telles que les bases de données .

Certaines architectures de superordinateurs des années 1970 et 1980, telles que le Cray-1 , utilisaient des registres jusqu'à 64 bits de large et prenaient en charge l'arithmétique des entiers 64 bits, bien qu'elles ne prennent pas en charge l'adressage 64 bits. Au milieu des années 80, le développement d' Intel i860 a commencé à aboutir à une version (trop tard pour Windows NT) 1989 ; le i860 avait des registres d'entiers 32 bits et un adressage 32 bits, ce n'était donc pas un processeur entièrement 64 bits, bien que son unité graphique prenne en charge l'arithmétique d'entiers 64 bits. Cependant, le 32 bits est resté la norme jusqu'au début des années 1990, lorsque les réductions continuelles du coût de la mémoire ont conduit à des installations avec des quantités de RAM approchant les 4 Gio, et l'utilisation d'espaces de mémoire virtuelle dépassant le plafond de 4 Gio est devenue souhaitable pour gérer certains types de problèmes. En réponse, MIPS et DEC ont développé des architectures de microprocesseurs 64 bits, initialement pour les postes de travail et les serveurs haut de gamme . Au milieu des années 1990, HAL Computer Systems , Sun Microsystems , IBM , Silicon Graphics et Hewlett Packard avaient développé des architectures 64 bits pour leurs systèmes de postes de travail et de serveurs. Une exception notable à cette tendance était les mainframes d'IBM, qui utilisaient alors des données de 32 bits et des tailles d'adresse de 31 bits ; les mainframes IBM n'incluaient pas de processeurs 64 bits jusqu'en 2000. Au cours des années 1990, plusieurs microprocesseurs 64 bits à faible coût ont été utilisés dans l'électronique grand public et les applications embarquées. Notamment, la Nintendo 64 et la PlayStation 2 avaient des microprocesseurs 64 bits avant leur introduction dans les ordinateurs personnels. Les imprimantes haut de gamme, les équipements réseau et les ordinateurs industriels utilisaient également des microprocesseurs 64 bits, tels que les Quantum Effect Devices R5000 . L'informatique 64 bits a commencé à se répandre sur le bureau de l'ordinateur personnel à partir de 2003, lorsque certains modèles des gammes Macintosh d' Apple sont passés aux processeurs PowerPC 970 (appelés G5 par Apple), et Advanced Micro Devices (AMD) a sorti son premier 64-bit. processeur x86-64 bits .

Chronologie des données 64 bits

1961
IBM fournit le supercalculateur IBM 7030 Stretch , qui utilise des mots de données de 64 bits et des mots d'instruction de 32 ou 64 bits.
1974
Control Data Corporation lance le supercalculateur vectoriel CDC Star-100 , qui utilise une architecture de mots de 64 bits (les systèmes CDC antérieurs étaient basés sur une architecture de 60 bits).
International Computers Limited lance la série ICL 2900 avec des entiers en complément à deux 32 bits, 64 bits et 128 bits ; virgule flottante 64 bits et 128 bits ; Décimal condensé 32 bits, 64 bits et 128 bits et un registre accumulateur 128 bits. L'architecture a survécu grâce à une succession de machines ICL et Fujitsu. Le dernier en date est le Fujitsu Supernova, qui émule l'environnement d'origine sur des processeurs Intel 64 bits.
1976
Cray Research livre le premier supercalculateur Cray-1 , qui est basé sur une architecture de mots de 64 bits et constituera la base des futurs supercalculateurs vectoriels Cray.
1983
Elxsi lance le minisupercalculateur parallèle Elxsi 6400 . L'architecture Elxsi a des registres de données de 64 bits mais un espace d'adressage de 32 bits.
1989
Intel présente le processeur d' ordinateur à jeu d'instructions réduit (RISC) Intel i860 . Commercialisé sous le nom de "microprocesseur 64 bits", il avait essentiellement une architecture 32 bits, améliorée avec une unité graphique 3D capable d'opérations entières 64 bits.
1993
Atari présente la console de jeu vidéo Atari Jaguar , qui inclut des chemins de données de 64 bits dans son architecture.

Chronologie des adresses 64 bits

1991
MIPS Computer Systems produit le premier microprocesseur 64 bits, le R4000 , qui implémente l' architecture MIPS III , la troisième révision de son architecture MIPS . Le CPU est utilisé dans les stations de travail graphiques SGI à partir de l' IRIS Crimson . Kendall Square Research propose son premier supercalculateur KSR1, basé sur une architecture de processeur RISC 64 bits propriétaire exécutant OSF/1 .
1992
Digital Equipment Corporation (DEC) présente l' architecture Alpha 64 bits pure qui est née du projet PRISM .
1994
Intel annonce des plans pour l'architecture IA-64 64 bits (développée conjointement avec Hewlett-Packard ) comme successeur de ses processeurs IA-32 32 bits. Une date de lancement de 1998 à 1999 était visée.
1995
Sun lance un processeur SPARC 64 bits , l' UltraSPARC . HAL Computer Systems, propriété de Fujitsu, lance des stations de travail basées sur un processeur 64 bits, le SPARC64 de première génération conçu indépendamment par HAL . IBM lance les microprocesseurs A10 et A30, les premiers processeurs PowerPC AS 64 bits. IBM publie également une mise à niveau du système AS/400 64 bits , qui peut convertir le système d'exploitation, la base de données et les applications.
1996
Nintendo présente la console de jeux vidéo Nintendo 64 , construite autour d'une variante à faible coût du MIPS R4000. HP lance la première implémentation de son architecture PA-RISC 2.0 64 bits , le PA-8000 .
1998
IBM lance la gamme POWER3 de processeurs PowerPC/ POWER 64 bits complets .
1999
Intel publie le jeu d'instructions pour l'architecture IA-64. AMD divulgue publiquement son ensemble d'extensions 64 bits à IA-32, appelé x86-64 (plus tard appelé AMD64).
2000
IBM livre son premier mainframe z/Architecture 64 bits , le zSeries z900. z/Architecture est une version 64 bits de l'architecture ESA/390 32 bits , descendante de l'architecture System/360 32 bits .
2001
Intel livre sa gamme de processeurs IA-64, après des retards répétés de mise sur le marché. Désormais sous la marque Itanium et ciblant les serveurs haut de gamme, les ventes ne répondent pas aux attentes.
2003
AMD présente ses gammes de processeurs Opteron et Athlon 64 , basées sur son architecture AMD64 qui est la première architecture de processeur 64 bits basée sur x86. Apple livre également le processeur PowerPC 970 64 bits "G5" produit par IBM. Intel maintient que ses puces Itanium resteraient ses seuls processeurs 64 bits.
2004
Intel, réagissant au succès commercial d'AMD, admet avoir développé un clone des extensions AMD64 nommé IA-32e (renommé plus tard EM64T, puis à nouveau renommé en Intel 64). Intel livre des versions mises à jour de ses familles de processeurs Xeon et Pentium 4 prenant en charge le nouveau jeu d'instructions 64 bits.
VIA Technologies annonce le processeur Isaiah 64 bits.
2006
Sony, IBM et Toshiba commencent à fabriquer le processeur Cell 64 bits pour une utilisation dans la PlayStation 3 , les serveurs, les postes de travail et autres appareils. Intel a lancé Core 2 Duo en tant que premier processeur x86-64 grand public pour sa gamme de mobiles, de bureau et de stations de travail. Les gammes de processeurs d'extension 64 bits précédentes n'étaient pas largement disponibles sur le marché de détail (la plupart des Pentium 4/D 64 bits étaient OEM), les Pentium 4, Pentium D et Celeron 64 bits n'étaient pas en production de masse avant la fin de 2006 en raison à un problème de faible rendement (la plupart des plaquettes à bon rendement étaient destinées au serveur et à l'ordinateur central, tandis que le grand public reste toujours en ligne de processeurs 130 nm 32 bits jusqu'en 2006) et est rapidement devenu bas de gamme après le lancement du Core 2. AMD a sorti son premier processeur mobile 64 bits et fabriqué en 90 nm.
2011
ARM Holdings annonce ARMv8-A, la première version 64 bits de l' architecture ARM .
2012
ARM Holdings a annoncé ses cœurs Cortex-A53 et Cortex-A57, leurs premiers cœurs basés sur leur architecture 64 bits, le 30 octobre 2012.
2013
Apple annonce l' iPhone 5S , avec le premier processeur 64 bits au monde dans un smartphone, qui utilise leur système sur puce basé sur A7 ARMv8-A.
2014
Google annonce la tablette Nexus 9 , le premier appareil Android à fonctionner sur la puce Tegra K1 64 bits.

Chronologie du système d'exploitation 64 bits

1985
Cray lance UNICOS , la première implémentation 64 bits du système d' exploitation Unix .
1993
DEC lance le système d'exploitation de type Unix DEC OSF/1 AXP 64 bits (renommé plus tard Tru64 UNIX) pour ses systèmes basés sur l' architecture Alpha .
1994
La prise en charge du processeur R8000 est ajoutée par Silicon Graphics au système d'exploitation IRIX dans la version 6.0.
1995
DEC publie OpenVMS 7.0, la première version 64 bits complète d'OpenVMS pour Alpha. Sortie de la première distribution Linux 64 bits pour l'architecture Alpha.
1996
La prise en charge des processeurs R4x00 en mode 64 bits est ajoutée par Silicon Graphics au système d'exploitation IRIX dans la version 6.2.
1998
Sun lance Solaris 7, avec une prise en charge complète d' UltraSPARC 64 bits .
2000
IBM lance z/OS , un système d'exploitation 64 bits issu de MVS , pour les nouveaux mainframes zSeries 64 bits ; Linux 64 bits sur les systèmes z suit la version CPU presque immédiatement.
2001
Linux devient le premier noyau de système d'exploitation à prendre entièrement en charge x86-64 (sur un simulateur, car aucun processeur x86-64 n'avait encore été publié).
2001
Microsoft publie Windows XP 64-Bit Edition pour l' architecture IA-64 d' Itanium ; il pourrait exécuter des applications 32 bits via une couche d'exécution.
2003
Apple lance son système d'exploitation Mac OS X 10.3 "Panther" qui ajoute la prise en charge de l'arithmétique d'entiers 64 bits native sur les processeurs PowerPC 970 . Plusieurs distributions Linux prennent en charge AMD64 . Versions de FreeBSD avec prise en charge d'AMD64.
2005
Le 4 janvier, Microsoft abandonne Windows XP Édition 64 bits, car aucun PC avec processeurs IA-64 n'était disponible depuis septembre précédent, et annonce qu'il développe des versions x86-64 de Windows pour le remplacer. Le 31 janvier, Sun lance Solaris 10 avec la prise en charge des processeurs AMD64 et EM64T. Le 29 avril, Apple lance Mac OS X 10.4 "Tiger" qui offre une prise en charge limitée des applications de ligne de commande 64 bits sur les machines équipées de processeurs PowerPC 970 ; les versions ultérieures pour les Mac à processeur Intel prenaient en charge les applications de ligne de commande 64 bits sur les Mac dotés de processeurs EM64T. Le 30 avril, Microsoft publie Windows XP Professional x64 Edition et Windows Server 2003 x64 Edition pour les processeurs AMD64 et EM64T.
2006
Microsoft publie Windows Vista , y compris une version 64 bits pour les processeurs AMD64/EM64T qui conserve la compatibilité 32 bits. Dans la version 64 bits, toutes les applications et composants Windows sont en 64 bits, bien que beaucoup aient également leurs versions 32 bits incluses pour la compatibilité avec les plug-ins .
2007
Apple lance Mac OS X 10.5 "Leopard", qui prend entièrement en charge les applications 64 bits sur les machines équipées de processeurs PowerPC 970 ou EM64T.
2009
Microsoft lance Windows 7 qui, comme Windows Vista, inclut une version 64 bits complète pour les processeurs AMD64/Intel 64 ; la plupart des nouveaux ordinateurs sont chargés par défaut avec une version 64 bits. Microsoft publie également Windows Server 2008 R2 , qui est le premier système d'exploitation de serveur 64 bits uniquement. Apple publie Mac OS X 10.6 , "Snow Leopard", qui est livré avec un noyau 64 bits pour les processeurs AMD64/Intel64, bien que seuls certains modèles récents d'ordinateurs Apple exécutent le noyau 64 bits par défaut. La plupart des applications fournies avec Mac OS X 10.6 sont désormais également en 64 bits.
2011
Apple publie Mac OS X 10.7 , "Lion", qui exécute le noyau 64 bits par défaut sur les machines prises en charge. Les machines plus anciennes qui ne peuvent pas exécuter le noyau 64 bits exécutent le noyau 32 bits, mais, comme avec les versions précédentes, peuvent toujours exécuter des applications 64 bits ; Lion ne prend pas en charge les machines équipées de processeurs 32 bits. Presque toutes les applications fournies avec Mac OS X 10.7 sont désormais également en 64 bits, y compris iTunes.
2012
Microsoft publie Windows 8 qui prend en charge UEFI Class 3 ( UEFI sans CSM) et Secure Boot .
2013
Apple lance iOS 7 qui, sur les machines équipées de processeurs AArch64, dispose d'un noyau 64 bits prenant en charge les applications 64 bits.
2014
Google lance Android Lollipop , la première version du système d' exploitation Android prenant en charge les processeurs 64 bits.
2017
Apple publie iOS 11 , prenant en charge uniquement les machines équipées de processeurs AArch64. Il possède un noyau 64 bits qui ne prend en charge que les applications 64 bits. Les applications 32 bits ne sont plus compatibles.
2019
Apple publie macOS 10.15 "Catalina", abandonnant la prise en charge des applications Intel 32 bits.
2021
Google lance Android 12 , abandonnant la prise en charge des applications 32 bits. Microsoft publie Windows 11 , sans publier une version 32 bits du système d'exploitation.

Limites des processeurs

En principe, un microprocesseur 64 bits peut adresser 16 EiB ( 16 × 1024 6 = 2 64 = 18 446 744 073 709 551 616 octets , soit environ 18,4 exaoctets) de mémoire. Cependant, tous les jeux d'instructions et tous les processeurs implémentant ces jeux d'instructions ne prennent pas en charge un espace d'adressage virtuel ou physique complet de 64 bits.

L' architecture x86-64 (à partir de 2016) autorise 48 bits pour la mémoire virtuelle et, pour un processeur donné, jusqu'à 52 bits pour la mémoire physique. Ces limites autorisent des tailles de mémoire de 256  Tio ( 256 × 1024 4 octets ) et 4  PiB ( 4 × 1024 5 octets ), respectivement. Un PC ne peut actuellement pas contenir 4  pebioctets de mémoire (en raison de la taille physique des puces de mémoire), mais AMD envisageait de gros serveurs, des clusters de mémoire partagée et d'autres utilisations de l'espace d'adressage physique qui pourraient s'en approcher dans un avenir prévisible. Ainsi, l'adresse physique de 52 bits offre une grande marge d'extension tout en n'entraînant pas le coût de la mise en œuvre d'adresses physiques complètes de 64 bits. De même, l'espace d'adressage virtuel de 48 bits a été conçu pour fournir 65 536 (2 16 ) fois la limite de 32 bits de 4 Gio ( 4 × 1024 3 octets ), permettant une extension ultérieure et n'entraînant aucune surcharge de traduction de 64 bits complets. adresses.

Le Power ISA v3.0 autorise 64 bits pour une adresse effective, mappée sur une adresse segmentée avec entre 65 et 78 bits autorisés, pour la mémoire virtuelle, et, pour un processeur donné, jusqu'à 60 bits pour la mémoire physique.

L' architecture Oracle SPARC 2015 autorise 64 bits pour la mémoire virtuelle et, pour un processeur donné, entre 40 et 56 bits pour la mémoire physique.

L' architecture du système de mémoire virtuelle ARM AArch64 autorise 48 bits pour la mémoire virtuelle et, pour un processeur donné, de 32 à 48 bits pour la mémoire physique.

La spécification DEC Alpha nécessite un minimum de 43 bits d'espace d'adressage de mémoire virtuelle (8 Tio) pour être pris en charge, et le matériel doit vérifier et intercepter si les bits non pris en charge restants sont à zéro (pour prendre en charge la compatibilité sur les futurs processeurs). Alpha 21064 prenait en charge 43 bits d'espace d'adressage de mémoire virtuelle (8 TiB) et 34 bits d'espace d'adressage de mémoire physique (16 Gio). Alpha 21164 prenait en charge 43 bits d'espace d'adressage de mémoire virtuelle (8 TiB) et 40 bits d'espace d'adressage de mémoire physique (1 TiB). Alpha 21264 prenait en charge 43 ou 48 bits d'espace d'adressage de mémoire virtuelle configurables par l'utilisateur (8 TiB ou 256 TiB) et 44 bits d'espace d'adressage de mémoire physique (16 TiB).


applications 64 bits

32 bits contre 64 bits

Le passage d'une architecture 32 bits à une architecture 64 bits est une modification fondamentale, car la plupart des systèmes d'exploitation doivent être considérablement modifiés pour tirer parti de la nouvelle architecture, car ce logiciel doit gérer le matériel d'adressage mémoire réel. D'autres logiciels doivent également être portés pour utiliser les nouvelles capacités ; un logiciel 32 bits plus ancien peut être pris en charge soit parce que le jeu d'instructions 64 bits est un sur-ensemble du jeu d'instructions 32 bits, de sorte que les processeurs qui prennent en charge le jeu d'instructions 64 bits peuvent également exécuter du code pour l'instruction 32 bits ensemble, ou via une émulation logicielle , ou par la mise en œuvre réelle d'un cœur de processeur 32 bits dans le processeur 64 bits, comme avec certains processeurs Itanium d'Intel, qui comprenaient un cœur de processeur IA-32 pour exécuter des applications x86 32 bits . Les systèmes d'exploitation de ces architectures 64 bits prennent généralement en charge les applications 32 bits et 64 bits.

Une exception significative à ceci est l' AS/400 , pour lequel le logiciel est compilé dans une architecture de jeu d'instructions virtuelles (ISA) appelée Technology Independent Machine Interface (TIMI) ; Le code TIMI est ensuite traduit en code machine natif par un logiciel de bas niveau avant d'être exécuté. Le logiciel de traduction est tout ce qui doit être réécrit pour déplacer le système d'exploitation complet et tous les logiciels vers une nouvelle plate-forme, comme lorsque IBM a transféré le jeu d'instructions natif pour AS/400 de l'ancien IMPI 32/48 bits au nouveau PowerPC 64 bits. -AS , nom de code Amazon . Le jeu d'instructions IMPI était assez différent même du PowerPC 32 bits, donc cette transition était encore plus importante que le déplacement d'un jeu d'instructions donné de 32 à 64 bits.

Sur du matériel 64 bits avec architecture x86-64 (AMD64), la plupart des systèmes d'exploitation et applications 32 bits peuvent s'exécuter sans problème de compatibilité. Alors que l'espace d'adressage plus important des architectures 64 bits facilite le travail avec de grands ensembles de données dans des applications telles que la vidéo numérique , le calcul scientifique et les grandes bases de données , il y a eu un débat considérable pour savoir si eux ou leurs modes de compatibilité 32 bits seront plus rapides que des systèmes 32 bits à prix comparable pour d'autres tâches.

Un programme Java compilé peut s'exécuter sur une machine virtuelle Java 32 ou 64 bits sans aucune modification. Les longueurs et la précision de tous les types intégrés, tels que char, short, int, long, float, et double, et les types pouvant être utilisés comme indices de tableau, sont spécifiés par la norme et ne dépendent pas de l'architecture sous-jacente. Les programmes Java qui s'exécutent sur une machine virtuelle Java 64 bits ont accès à un plus grand espace d'adressage.

La vitesse n'est pas le seul facteur à prendre en compte pour comparer les processeurs 32 bits et 64 bits. Des applications telles que le multitâche, les tests de résistance et le clustering - pour le calcul haute performance (HPC) - peuvent être plus adaptées à une architecture 64 bits lorsqu'elles sont déployées de manière appropriée. Pour cette raison, les clusters 64 bits ont été largement déployés dans les grandes organisations, telles qu'IBM, HP et Microsoft.

Sommaire:

  • Un processeur 64 bits fonctionne mieux avec un logiciel 64 bits.
  • Un processeur 64 bits peut avoir une compatibilité descendante , lui permettant d'exécuter un logiciel d'application 32 bits pour la version 32 bits de son jeu d'instructions, et peut également prendre en charge l'exécution de systèmes d'exploitation 32 bits pour la version 32 bits de son jeu d'instructions .
  • Un processeur 32 bits est incompatible avec un logiciel 64 bits.

Avantages et inconvénients

Une idée fausse courante est que les architectures 64 bits ne sont pas meilleures que les architectures 32 bits à moins que l'ordinateur ne dispose de plus de 4 Gio de mémoire vive . Ce n'est pas tout à fait vrai :

  • Certains systèmes d'exploitation et certaines configurations matérielles limitent l'espace mémoire physique à 3 Gio sur les systèmes IA-32 , car une grande partie de la région 3 à 4 Gio est réservée à l'adressage matériel ; voir barrière 3 Gio ; Les architectures 64 bits peuvent adresser bien plus de 4 Gio. Cependant, les processeurs IA-32 à partir du Pentium Pro autorisent un espace d'adressage de mémoire physique de 36 bits , en utilisant l' extension d'adresse physique (PAE), qui donne une plage d'adresses physiques de 64 Gio, dont jusqu'à 62 Gio peuvent être utilisés par la mémoire principale ; les systèmes d'exploitation qui prennent en charge PAE peuvent ne pas être limités à 4 Gio de mémoire physique, même sur les processeurs IA-32. Cependant, les pilotes et autres logiciels en mode noyau, plus particulièrement les versions plus anciennes, peuvent être incompatibles avec PAE ; cela a été cité comme la raison pour laquelle les versions 32 bits de Microsoft Windows sont limitées à 4 Gio de RAM physique (bien que la validité de cette explication ait été contestée).
  • Certains systèmes d'exploitation réservent des portions d' espace d'adressage de processus pour l'utilisation du système d'exploitation, réduisant ainsi l'espace d'adressage total disponible pour le mappage de la mémoire pour les programmes utilisateur. Par exemple, Windows 32 bits réserve 1 ou 2 Gio (selon les paramètres) de l'espace d'adressage total pour le noyau, ce qui ne laisse que 3 ou 2 Gio (respectivement) de l'espace d'adressage disponible pour le mode utilisateur. Cette limite est beaucoup plus élevée sur les systèmes d'exploitation 64 bits.
  • Les fichiers mappés en mémoire deviennent de plus en plus difficiles à implémenter dans les architectures 32 bits, car les fichiers de plus de 4 Gio deviennent plus courants ; des fichiers aussi volumineux ne peuvent pas être facilement mappés en mémoire sur des architectures 32 bits, car seule une partie du fichier peut être mappée dans l'espace d'adressage à la fois, et pour accéder à un tel fichier par mappage de mémoire, les parties mappées doivent être échangées dans et hors de l'espace d'adressage selon les besoins. C'est un problème, car le mappage de la mémoire, s'il est correctement implémenté par le système d'exploitation, est l'une des méthodes disque à mémoire les plus efficaces.
  • Certains programmes 64 bits, tels que les encodeurs, les décodeurs et les logiciels de cryptage, peuvent grandement bénéficier des registres 64 bits, tandis que les performances d'autres programmes, tels que les programmes orientés graphiques 3D, restent inchangées lors du passage d'un 32 bits à un Environnement 64 bits.
  • Certaines architectures 64 bits, telles que x86-64 , prennent en charge des registres plus généraux que leurs homologues 32 bits (bien que cela ne soit pas spécifiquement dû à la longueur du mot). Cela conduit à une augmentation significative de la vitesse pour les boucles serrées puisque le processeur n'a pas à récupérer les données du cache ou de la mémoire principale si les données peuvent tenir dans les registres disponibles.
Exemple en C :
int a, b, c, d, e;
for (a = 0; a < 100; a++)
{
    b = a;
    c = b;
    d = c;
    e = d;
}
Si un processeur ne peut conserver que deux ou trois valeurs ou variables dans les registres, il lui faudrait déplacer certaines valeurs entre la mémoire et les registres pour pouvoir également traiter les variables d et e ; c'est un processus qui prend de nombreux cycles CPU. Un processeur qui peut contenir toutes les valeurs et variables dans les registres peut les parcourir sans avoir besoin de déplacer les données entre les registres et la mémoire pour chaque itération. Ce comportement peut facilement être comparé à la mémoire virtuelle, bien que tous les effets dépendent du compilateur.

Le principal inconvénient des architectures 64 bits est que, par rapport aux architectures 32 bits, les mêmes données occupent plus d'espace en mémoire (en raison de pointeurs plus longs et éventuellement d'autres types, et du remplissage d'alignement). Cela augmente les besoins en mémoire d'un processus donné et peut avoir des implications pour une utilisation efficace du cache du processeur. Le maintien d'un modèle 32 bits partiel est un moyen de gérer cela et est en général raisonnablement efficace. Par exemple, le système d' exploitation z/OS adopte cette approche, exigeant que le code du programme réside dans des espaces d'adressage de 31 bits (le bit de poids fort n'est pas utilisé dans le calcul d'adresse sur la plate-forme matérielle sous-jacente) tandis que les objets de données peuvent éventuellement résider dans 64- régions de bits. Toutes ces applications ne nécessitent pas un grand espace d'adressage ou ne manipulent pas des éléments de données 64 bits, de sorte que ces applications ne bénéficient pas de ces fonctionnalités.

Disponibilité du logiciel

Les systèmes 64 bits basés sur x86 manquent parfois d'équivalents de logiciels écrits pour les architectures 32 bits. Le problème le plus grave dans Microsoft Windows est l'incompatibilité des pilotes de périphérique pour le matériel obsolète. La plupart des logiciels d'application 32 bits peuvent fonctionner sur un système d'exploitation 64 bits dans un mode de compatibilité , également appelé mode d' émulation , par exemple, la technologie Microsoft WoW64 pour IA-64 et AMD64. L'environnement de pilote en mode natif Windows 64 bits s'exécute sur NTDLL.DLL 64 bits , qui ne peut pas appeler le code du sous-système Win32 32 bits (souvent des périphériques dont la fonction matérielle réelle est émulée dans un logiciel en mode utilisateur, comme Winprinters). Étant donné que les pilotes 64 bits pour la plupart des périphériques n'étaient pas disponibles jusqu'au début de 2007 (Vista x64), l'utilisation d'une version 64 bits de Windows était considérée comme un défi. Cependant, la tendance s'est depuis déplacée vers l'informatique 64 bits, d'autant plus que les prix de la mémoire ont chuté et que l'utilisation de plus de 4 Gio de RAM a augmenté. La plupart des fabricants ont commencé à fournir des pilotes 32 bits et 64 bits pour les nouveaux périphériques, de sorte que l'indisponibilité des pilotes 64 bits a cessé d'être un problème. Les pilotes 64 bits n'étaient pas fournis pour de nombreux appareils plus anciens, qui ne pouvaient donc pas être utilisés dans les systèmes 64 bits.

La compatibilité des pilotes était moins un problème avec les pilotes open source, car les pilotes 32 bits pouvaient être modifiés pour une utilisation 64 bits. La prise en charge du matériel fabriqué avant le début de 2007 était problématique pour les plates-formes open source, en raison du nombre relativement faible d'utilisateurs.

Les versions 64 bits de Windows ne peuvent pas exécuter de logiciels 16 bits . Cependant, la plupart des applications 32 bits fonctionneront bien. Les utilisateurs 64 bits sont obligés d'installer une machine virtuelle d'un système d'exploitation 16 ou 32 bits pour exécuter des applications 16 bits.

Mac OS X 10.4 "Tiger" et Mac OS X 10.5 "Leopard" n'avaient qu'un noyau 32 bits, mais ils peuvent exécuter du code en mode utilisateur 64 bits sur des processeurs 64 bits. Mac OS X 10.6 "Snow Leopard" avait à la fois des noyaux 32 et 64 bits et, sur la plupart des Mac, utilisait le noyau 32 bits même sur des processeurs 64 bits. Cela a permis à ces Mac de prendre en charge les processus 64 bits tout en prenant en charge les pilotes de périphérique 32 bits ; mais pas les pilotes 64 bits et les avantages de performances qui peuvent en découler. Mac OS X 10.7 "Lion" fonctionnait avec un noyau 64 bits sur davantage de Mac, et OS X 10.8 "Mountain Lion" et les versions ultérieures de macOS n'ont qu'un noyau 64 bits. Sur les systèmes dotés de processeurs 64 bits, les noyaux macOS 32 et 64 bits peuvent exécuter du code en mode utilisateur 32 bits, et toutes les versions de macOS incluent des versions 32 bits de bibliothèques que les applications 32 bits utiliseraient, donc 32 Le logiciel en mode utilisateur -bit pour macOS s'exécutera sur ces systèmes.

Linux et la plupart des autres systèmes d' exploitation de type Unix, ainsi que les chaînes d' outils C et C++ pour eux, prennent en charge les processeurs 64 bits depuis de nombreuses années. De nombreuses applications et bibliothèques pour ces plates-formes sont des logiciels open source , écrits en C et C++, de sorte que si elles sont sécurisées en 64 bits, elles peuvent être compilées en versions 64 bits. Ce modèle de distribution basé sur la source, en mettant l'accent sur des versions fréquentes, rend la disponibilité des logiciels d'application pour ces systèmes d'exploitation moins problématique.

Modèles de données 64 bits

Dans les programmes 32 bits, les pointeurs et les types de données tels que les entiers ont généralement la même longueur. Ce n'est pas nécessairement vrai sur les machines 64 bits. Le mélange de types de données dans des langages de programmation tels que C et ses descendants tels que C++ et Objective-C peut donc fonctionner sur des implémentations 32 bits mais pas sur des implémentations 64 bits.

Dans de nombreux environnements de programmation pour le C et les langages dérivés du C sur des machines 64 bits, les intvariables ont toujours une largeur de 32 bits, mais les entiers longs et les pointeurs ont une largeur de 64 bits. Ceux-ci sont décrits comme ayant un modèle de données LP64 , qui est une abréviation de "Long, Pointer, 64". D'autres modèles sont le modèle de données ILP64 dans lequel les trois types de données ont une largeur de 64 bits, et même le modèle SILP64les entiers courts ont également une largeur de 64 bits. Cependant, dans la plupart des cas, les modifications requises sont relativement mineures et simples, et de nombreux programmes bien écrits peuvent simplement être recompilés pour le nouvel environnement sans aucun changement. Une autre alternative est le modèle LLP64 , qui maintient la compatibilité avec le code 32 bits en laissant les deux et en 32 bits. LL fait référence au type d' entier long long , qui est d'au moins 64 bits sur toutes les plates-formes, y compris les environnements 32 bits. intlong

Il existe également des systèmes avec des processeurs 64 bits utilisant un modèle de données ILP32 , avec l'ajout d'entiers longs longs 64 bits ; ceci est également utilisé sur de nombreuses plates-formes avec des processeurs 32 bits. Ce modèle réduit la taille du code et la taille des structures de données contenant des pointeurs, au prix d'un espace d'adressage beaucoup plus petit, un bon choix pour certains systèmes embarqués. Pour les jeux d'instructions tels que x86 et ARM dans lesquels la version 64 bits du jeu d'instructions comporte plus de registres que la version 32 bits, elle permet d'accéder aux registres supplémentaires sans pénalité d'espace. Il est courant dans les machines RISC 64 bits, exploré en x86 en tant que x32 ABI , et a récemment été utilisé dans les Apple Watch Series 4 et 5.

Modèles de données 64 bits
Modèle de données Entier court) entier entier long) longue longue pointeurs,
size_t
Exemples de systèmes d'exploitation
ILP32 16 32 32 64 32 ABI x32 et arm64ilp32 sur les systèmes Linux ; MIPS N32 ABI.
LLP64 16 32 32 64 64 Microsoft Windows (x86-64 et IA-64) utilisant Visual C++ ; et MinGW
LP64 16 32 64 64 64 La plupart des systèmes Unix et similaires , par exemple Solaris , Linux , BSD , macOS . Windows lors de l'utilisation de Cygwin ; z/OS
ILP64 16 64 64 64 64 Port HAL Computer Systems de Solaris vers le SPARC64
SILP64 64 64 64 64 64 UNICOS classiques (versus UNICOS/mp, etc.)

De nombreuses plates-formes 64 bits utilisent aujourd'hui un modèle LP64 (notamment Solaris, AIX , HP-UX , Linux, macOS, BSD et IBM z/OS). Microsoft Windows utilise un modèle LLP64 . L'inconvénient du modèle LP64 est que le stockage d'un longdans un intpeut être tronqué. D'un autre côté, convertir un pointeur en un long"fonctionnera" dans LP64. Dans le modèle LLP64, l'inverse est vrai. Ce ne sont pas des problèmes qui affectent le code entièrement conforme aux normes, mais le code est souvent écrit avec des hypothèses implicites sur la largeur des types de données. Le code C devrait préférer ( u) à la intptr_tconversion de longpointeurs en objets entiers.

Un modèle de programmation est un choix fait pour s'adapter à un compilateur donné, et plusieurs peuvent coexister sur le même système d'exploitation. Cependant, le modèle de programmation choisi comme modèle principal pour l' interface de programmation d'application (API) du système d'exploitation domine généralement.

Une autre considération est le modèle de données utilisé pour les pilotes de périphériques . Les pilotes constituent la majorité du code du système d'exploitation dans la plupart des systèmes d'exploitation modernes (bien que beaucoup puissent ne pas être chargés lorsque le système d'exploitation est en cours d'exécution). De nombreux pilotes utilisent massivement des pointeurs pour manipuler les données et, dans certains cas, doivent charger des pointeurs d'une certaine taille dans le matériel qu'ils prennent en charge pour l'accès direct à la mémoire (DMA). Par exemple, un pilote pour un périphérique PCI 32 bits demandant au périphérique de DMA des données dans les zones supérieures de la mémoire d'une machine 64 bits n'a pas pu satisfaire les demandes du système d'exploitation pour charger des données du périphérique vers la mémoire au-dessus de la barrière de 4 gibioctets. , car les pointeurs de ces adresses ne rentraient pas dans les registres DMA du périphérique. Ce problème est résolu en demandant au système d'exploitation de prendre en compte les restrictions de mémoire du périphérique lors de la génération de requêtes aux pilotes pour DMA, ou en utilisant une unité de gestion de mémoire d'entrée-sortie (IOMMU).

Architectures 64 bits actuelles

Depuis mai 2018, les architectures 64 bits pour lesquelles des processeurs sont fabriqués comprennent :

  • IBM z/Architecture , une version 64 bits de l' architecture ESA/390 , utilisée dans les mainframes eServer zSeries et System z d' IBM :
  • Architecture IA-64 de HP–Intel :
  • MIPS Technologies de MIPS64 architecture
  • ARM Holdings de AArch64 l' architecture
  • Architecture d' Elbrouz :
  • Architecture NEC SX
  • RISC-V
  • La plupart des architectures de 64 bits dérivées de la même architecture de 32 bits peuvent exécuter du code écrit pour les versions 32 bits en natif, sans pénaliser les performances. Ce type de support est communément appelé support bi-arche ou plus généralement support multi-arche .

    Voir également

    Les références

    Liens externes