De ce que j’ai trouvé jusqu’à présent, il est clair que les programmes compilés pour une architecture 64 bits utilisent deux fois plus de RAM pour les pointeurs que leurs alternatives 32 bits – https://superuser.com/questions/56540/32-bit-vs- Systèmes 64 bits .
Est-ce que cela signifie que le code compilé pour 64 bits utilise en moyenne deux fois plus de RAM que la version 32 bits?
J’en doute quelque peu, mais je me demande quel est le véritable coût. Je suppose que les petits types, tels que short
, byte
et char
ont la même taille dans une architecture 64 bits? Je ne suis pas vraiment sûr de l’ byte
. Étant donné que de nombreuses applications fonctionnent avec des chaînes de grande taille (comme les navigateurs Web, etc.), qui consistent principalement en des tableaux de caractères dans la plupart des implémentations, la surcharge peut ne pas être si importante.
Donc, même si les types numériques comme int
et long
sont plus gros sur 64 bits, cela aurait-il un effet significatif sur l’utilisation de la mémoire vive ou non?
Cela dépend du style de programmation (et de la langue, mais vous faites référence à C).
double
ou int32_t
, la consommation de RAM ne monte pas. int
ou long
, cela dépend de l’architecture; il peut y avoir des différences entre Linux et Windows. Vous voyez ici les alternatives que vous avez. En bref, Windows utilise LLP64, ce qui signifie que long long
et pointeurs sont 64 bits, tandis que Linux utilise LP64, où 64 bits sont également long
. Les autres architectures peuvent aussi faire des int
et même short
64 bits short
, mais elles sont assez rares. float
et double
doivent restr les mêmes dans tous les cas. Vous voyez donc que cela dépend fortement de l’utilisation des types de données.
Il y a quelques raisons pour que la consommation de mémoire augmente. Toutefois, la surcharge de 64b vs 32b dépend d’une application à l’autre.
La principale raison est d’ utiliser beaucoup de pointeurs dans votre code . Toutefois, un tableau alloué dynamicment dans un code compilé pour 64 bits et exécuté sur un système d’exploitation 64 bits aurait la même taille que le tableau alloué sur un système 32 bits. Seule l’adresse du tableau sera plus grande, la taille du contenu sera la même ( sauf si la taille du type a été modifiée , mais cela ne devrait pas se produire et devrait être bien documenté).
Une autre augmentation de l’empreinte serait due à l’ alignement de la mémoire . En mode 64 bits, l’alignement doit prendre en compte une adresse 64 bits, ce qui devrait entraîner une légère surcharge.
La taille du code augmentera probablement. Sur certaines architectures, l’ISA 64 bits pourrait être légèrement plus grande. De plus, vous devez maintenant passer des appels aux adresses 64 bits.
Lorsque vous exécutez des registres 64 bits sont plus gros (64 bits), si vous utilisez de nombreux types numériques, le compilateur peut aussi bien les placer dans des registres, ce qui ne signifie pas nécessairement que votre empreinte RAM augmentera. L’utilisation de variables doubles produit probablement une augmentation de l’empreinte mémoire si elles ne sont pas stockées dans des registres 64b.
Lorsque vous utilisez des langages compilés JIT tels que Java, .NET, il est probable que l’augmentation de l’encombrement du code 64b soit plus importante car l’environnement d’exécution génèrera une surcharge supplémentaire par l’utilisation du pointeur, des structures de contrôle masquées, etc.
Cependant, il n’y a pas de chiffre magique décrivant la surcharge de mémoire de 64 bits. Cela doit être mesuré d’une application à une autre. D’après ce que j’ai vu, je n’ai jamais eu plus de 20% d’augmentation de l’empreinte pour une application fonctionnant en 64 bits, contre 32 bits. Cependant, c’est uniquement basé sur les applications que j’ai rencontrées et j’utilise principalement C et C ++.
Je pense qu’il y a peut-être une autre raison pour laquelle les variables doivent être stockées en mémoire sur une limite de 64 bits à une adresse … xxxxx000 pour être lues en une seule fois, si ce n’est pas le cas à la fois.