Convertir des Gio en Mo

Un gibioctet vaut 1 073 741 824 octets, environ 7 % de plus qu’un gigaoctet. Windows mesure en gibioctets tout en les étiquetant « Go », et c’est là tout le mystère de l’espace disque qui s’évapore.

Un mégaoctet vaut un million d’octets. Les fabricants de stockage ont toujours compté en décimal, et c’est pourquoi leurs chiffres paraissent plus grands que ce qu’affiche l’ordinateur.

Le facteur vaut 1073,741824, et à peu près personne ne le trimballe. Arrondi à 1070, il s'écarte de 0,35 % — invisible sur de petits nombres, et devenu une unité entière vers 1 000 GiB.

C'est ce chiffre-là qu'il faut connaître avant d'arrondir : pas l'erreur elle-même, mais l'endroit où elle cesse d'être négligeable. En dessous, le facteur court est le bon choix ; au-dessus, servez-vous du champ ci-dessus, qui n'arrondit qu'au moment d'afficher.

Un GiB vaut 1 024 fois l'unité du dessous ; un GB, 1 000. Sur cette page, c'est l'écart entre 1073,7418 MB et 1000 MB — 7,4 % — et il grandit à chaque palier : négligeable sur une photo, visible sur un disque dur.

Le mystère de l'espace disque manquant tient tout entier là-dedans, et sur cette page il vaut 7,4 %. Un disque vendu en GB contient exactement ce qui est annoncé ; Windows divise ensuite par 1 024 au lieu de 1 000, garde le nom décimal, et affiche 1000 MB là où la boîte annonçait 1073,7418 MB. macOS compte ces tailles en unités décimales depuis 10.6, d'où le même disque qui paraît de deux tailles sur deux machines — rien n'a disparu et personne n'arrondit : les mêmes octets portent deux noms.

Toute autre quantité dans cette catégorie est binaire par convention et aurait pu en principe aller dans l’autre sens. La mémoire ne le pouvait pas. Une puce est sélectionnée par des lignes d’adresse, et n lignes atteignent exactement 2 à la puissance n emplacements — dix lignes donnent 1 024, vingt donnent 1 048 576, trente donnent 1 073 741 824. Il n’y a aucun câblage qui atteigne un nombre décimal rond d’emplacements, donc la capacité de mémoire est une puissance de deux par construction plutôt que par le choix de quiconque.

C’est pourquoi un module vendu comme 16 Go contient 17 179 869 184 octets et personne n’y voit d’objection. L’étiquette est un préfixe décimal appliqué à une quantité binaire, exactement la pratique qui provoque des disputes au sujet des disques durs, et ici elle n’en provoque aucune — parce que l’alternative serait de vendre 16 Go de mémoire contenant 16 000 000 000 d’octets, ce qui ne peut pas être construit. Pour la mémoire, la lecture binaire est la seule qui décrive une pièce réelle.

L’arithmétique est une multiplication par 1 073,741824  : 8 Gio font 8 589,93 Mo, 16 Gio font 17 179,87 Mo, 64 Gio font 68 719,48 Mo. Ce sont les chiffres décimaux exacts et ils ne sont presque jamais ce qu’un champ d’allocation veut, parce qu’un champ qui demande de la mémoire en Mo demande d’habitude des mebioctets et attend 8 192, 16 384 et 65 536.

Ainsi la première question n’est pas comment convertir mais quelle unité la boîte entend. L’argument mémoire de QEMU est en mebioctets  ; la plupart des interfaces de virtualisation étiquetées Mo se comportent de la même manière, parce qu’elles allouent au final des pages. Le suffixe m de la JVM est aussi binaire. Là où l’une d’elles est vraiment décimale, entrer le chiffre binaire rond donne au processus 4,6 pour cent de mémoire en moins que prévu, ce qui sur un tas accordé ou un pool de tampons de base de données suffit à changer le comportement sans produire d’erreur nulle part.

Allouer un nombre binaire rond et demander à l’invité ce qu’il a reçu. Entrer 4 096 dans le champ, démarrer la machine, et lire la mémoire qu’elle rapporte  : un invité qui affiche exactement 4 Gio confirme que le champ est en mebioctets, et un qui affiche 3,81 Gio confirme qu’il est en mégaoctets décimaux. Le test prend une minute et la réponse tient pour cet outil définitivement.

Cela vaut la peine d’être fait une fois par plateforme plutôt que de raisonner depuis la documentation, parce que la documentation sur ce point est fréquemment écrite par quelqu’un qui n’a pas considéré la question. Le comportement observé fait autorité et l’étiquette non, ce qui est le même principe que lire le compte d’octets d’un disque plutôt que sa ligne de résumé.

La chaîne qui va d’un chiffre en Gio d’un hôte à l’allocation d’un processus passe d’habitude par trois unités et au moins une soustraction. L’hôte rapporte en Gio. Il faut laisser quelque chose pour le système d’exploitation, le cache de pages et tout autre processus. Le reste va dans un champ en Mo ou en Mio, et à l’intérieur du processus cela devient un tas avec ses propres surcoûts par-dessus le nombre qu’on lui a donné.

La voie fiable est de faire chaque étape en octets et de convertir une fois à la fin, dans l’unité que le champ s’avère vouloir. Le faire en unités mêlées invite à une soustraction entre un chiffre décimal et un chiffre binaire, ce qui produit un nombre qui n’est ni l’un ni l’autre, et le résultat est une allocation décalée de quelques pour cent dans une direction que personne n’a enregistrée.

Un hyperviseur laissera en général promettre aux invités plus de mémoire au total que l’hôte n’en a physiquement, en supposant raisonnablement qu’ils n’utiliseront pas tous leur maximum à la fois. Cela signifie qu’une allocation qui est tranquillement 5 pour cent plus petite que prévu n’échoue pas à la configuration, n’échoue pas au démarrage, et n’échoue pas sous charge ordinaire. Elle échoue sous la pression spécifique que le dimensionnement était censé couvrir.

Quand elle échoue, le symptôme pointe loin de la cause. Un invité qui swappe, un tas qui passe son temps à collecter, un cache avec un taux de succès pire que ce que le modèle avait prédit — tous ressemblent à des problèmes d’accord, et le chiffre de dimensionnement dans la configuration a l’air correct parce que c’est le nombre que quelqu’un pensait entrer. Vérifier ce que l’invité a réellement reçu est l’étape qui le trouve.

La mémoire installée et la mémoire disponible sont des nombres différents pour des raisons qui n’ont rien à voir avec les unités. Le micrologiciel réserve des régions, et sur une machine avec un graphique intégré un bloc est taillé pour l’affichage, donc un système avec 16 Gio installés peut rapporter sensiblement moins comme utilisable. C’est une vraie soustraction de mémoire réelle plutôt qu’un réétiquetage, et cela vaut la peine d’être séparé de la conversion pour qu’aucun des deux ne soit blâmé pour l’autre.

Les deux se distinguent par la taille et la forme de l’écart. Une différence d’unité est toujours le même pourcentage — 4,9 ou 7,4, selon combien de paliers elle traverse — alors qu’une réservation matérielle est une quantité fixe qui ne se met pas à l’échelle avec le total. Si le manque reste constant quand on change la configuration, c’est réservé  ; s’il reste une fraction constante, c’est de l’arithmétique. Ce test unique sépare une question matérielle d’une question d’unités en une minute environ, et cela vaut la peine de l’appliquer avant que l’une ou l’autre ne soit examinée plus loin.

Rien n’interdit d’allouer 4 000 Mo de mémoire, et cela fonctionnera. Cela ne se divisera pas non plus exactement par la taille de page, la taille de page géante et la plupart des structures en dessous, donc chaque couche arrondit légèrement et le nombre qu’on pose n’est jamais tout à fait le nombre en vigueur. Un chiffre de 4 096 Mio passe à travers toutes sans changement, ce qui rend chaque mesure ultérieure plus facile à réconcilier.

Il y a aussi un bénéfice de documentation. Une configuration pleine de puissances de deux s’auto-décrit  : un relecteur voit 8 192 et sait que c’est 8 Gio sans arithmétique, alors que 8 590 doit être cherché et se tape facilement en quelque chose de plausible. Sur des systèmes où les chiffres de mémoire sont lus bien plus souvent qu’ils ne sont posés, cette lisibilité vaut plus que la différence de capacité négligeable entre les deux choix. Cela rend aussi une revue utile  : un relecteur qui voit au premier coup d’œil que chaque allocation sur un hôte est une puissance de deux peut les additionner et comparer le total à la mémoire installée sans faire de conversion du tout.