Convertir des Mio en o

Un mébioctet vaut 1 024 kibioctets, soit 1 048 576 octets. Les outils Linux et les chiffres de mémoire désignent presque toujours cela, même quand ils écrivent « Mo ».

Un octet vaut huit bits — c’est d’ailleurs ce que le mot dit, là où l’anglais *byte* ne dit rien de la taille. Elle n’a pas toujours été fixée : les premiers ordinateurs employaient six, sept ou neuf bits. Huit s’est imposé parce qu’un caractère y tient et que le nombre se coupe proprement en deux.

Dans ce sens, l'opération est une multiplication, et par un nombre entier : un mébioctet fait 1 048 576 octets, exactement, et 1 048 576 est la définition, pas une mesure tombée juste.

C'est donc une des rares conversions qui valent le coup de tête, et le résultat se vérifie : divisez en sens inverse et vous devez retomber exactement sur le nombre de départ, sans reste à justifier.

Un MiB vaut 1 024 fois l'unité du dessous ; un MB, 1 000. Sur cette page, c'est l'écart entre 1048576 B et 1000000 B — 4,9 % — 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 4,9 %. Un disque vendu en MB contient exactement ce qui est annoncé ; Windows divise ensuite par 1 024 au lieu de 1 000, garde le nom décimal, et affiche 1000000 B là où la boîte annonçait 1048576 B. 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.

La plupart des conversions de taille existent pour qu’une personne puisse se représenter une quantité. Celle-ci existe en général pour qu’une machine puisse en appliquer une. Une limite de téléversement, une taille de tas, une allocation de tampon, une frontière de bloc dans un transfert en parties — chacune de ces valeurs est un entier que quelque chose compare, et une valeur arrondie pour être jolie est une valeur qui échoue à la limite plutôt qu’au milieu où on l’aurait remarqué.

Le chiffre utile ici est donc 1 048 576 et ses multiples, et pas une approximation. Dix Mio font 10 485 760 octets ; 64 Mio font 67 108 864 ; 512 Mio font 536 870 912. Chacun de ces nombres a été tapé dans un fichier de configuration cette semaine, et chacun est à un chiffre d’une valeur qui est tranquillement 4,86 % différente.

Une part surprenante des logiciels accepte une taille avec une lettre à la fin et traite cette lettre comme 1 024. Les suffixes k et m de nginx sont binaires. Les options de tas de la JVM -Xms512m et -Xmx2g sont binaires. Le upload_max_filesize = 8M de PHP est binaire. Aucun de ces exemples n’écrit le i, et aucun ne le dit sur la ligne que vous êtes en train d’éditer.

Le dd de GNU est le cas instructif parce qu’il accepte les deux conventions et les distingue par la longueur : bs=1M fait 1 048 576 octets et bs=1MB en fait 1 000 000. C’est une conception défendable et un piège fiable, parce que les deux orthographes ressemblent à des variantes typographiques l’une de l’autre. En copiant une taille de bloc d’un script à l’autre, copier le suffixe exactement ou le remplacer par le compte d’octets.

Les quantités de ressources Kubernetes acceptent explicitement les deux bases, de sorte que memory: 512Mi fait 536 870 912 octets et memory: 512M en fait 512 000 000. Les deux sont valides, les deux passent la validation du schéma, et la différence tient à une seule lettre dans un fichier qui sera appliqué sans que personne ne le relise. Sur une limite mémoire, la plus petite valeur est celle qui fait terminer un conteneur sous une charge que la plus grande lui aurait permis de traverser.

L’écart s’élargit en montant d’échelle, là où il fait de vrais dégâts. Au pas du méga il est de 4,86 % ; au giga il est de 7,37 %, de sorte que 4Gi et 4G diffèrent d’environ 295 mégaoctets. Une limite fixée à partir d’une lecture de surveillance en Gio et tapée en G est sous-dimensionnée de cette marge dès le premier déploiement, et le symptôme est un redémarrage intermittent plutôt qu’une erreur que quelqu’un remonte jusqu’au manifeste.

Dans le code, l’expression bat le littéral. 1024 * 1024 et 1 << 20 énoncent tous deux ce qu’est la valeur et permettent à un relecteur de la vérifier sans compter les zéros, alors que 1048576 à côté de 10485760 dans une table de configuration est un diff que personne n’attrape. Les langages qui ont des séparateurs de chiffres aident — 1_048_576 — mais la multiplication en dit plus, parce qu’elle porte la base avec le nombre.

L’autre moitié de la discipline est le nommage. Un champ appelé maxBytes ne peut pas recevoir par erreur une valeur en mébioctets ; un champ appelé maxSize le peut, et le fera. Quand une valeur franchit une frontière — un formulaire, une variable d’environnement, une API — l’unité doit faire partie du nom, parce que c’est le seul endroit où l’appelant la lira de manière fiable.

Le nombre qui arrive à cette conversion vient en général de quelque chose qui mesure en binaire par défaut. free rapporte en kibioctets sauf instruction contraire. /proc/meminfo imprime kB et pense KiB. top et ps affichent la taille de l’ensemble résident en KiB. Les moteurs de conteneurs rapportent limites et usage en octets, et les tableaux de bord au-dessus affichent en Mio.

C’est commode : multiplier cette lecture par 1 048 576 ramène au chiffre exact en octets que le noyau détenait, sans rien perdre d’autre que les chiffres que l’affichage a lâchés. C’est seulement quand un chiffre en mégaoctets décimaux issu d’une fiche technique, d’un contrat ou d’une page marketing entre dans le même champ que les deux conventions se télescopent, et ce chiffre-là doit être converti délibérément plutôt que d’être tapé avec un M après.

Un chiffre net en Mio est un chiffre sans grâce en octets, et il n’y a pas d’arrangement des deux bases où les deux soient présentables. 700 Mio font 734 003 200 octets. 250 Mio font 262 144 000. 1,5 Mio fait 1 572 864. Aucun de ces nombres n’a l’air d’avoir été choisi, et tous sont exacts.

L’exemple classique est le disque compact : un disque de données de quatre-vingts minutes contient 360 000 secteurs de 2 048 octets, ce qui fait 737 280 000 octets, ou 703,125 Mio. Le disque a été appelé un disque de 700 Mo pendant trente ans, le chiffre n’est ni 700 Mo décimaux ni 700 Mio binaires, et c’est un bon rappel qu’une capacité familière est souvent une étiquette arrondie plutôt qu’une unité.

Un mébioctet fait exactement 256 pages mémoire de 4 096 octets, 2 048 secteurs de disque de 512 octets, ou 256 blocs de système de fichiers sur un volume ext4 par défaut. Chaque frontière en dessous d’un chiffre en Mio tombe sur un nombre entier, ce qui explique pourquoi les tailles de tampon, les anneaux, les régions mmap et les décalages de partition sont spécifiés en unités binaires plutôt que décimales.

Un mégaoctet décimal ne se divise proprement dans aucun de ces éléments. 1 000 000 d’octets font 244,14 pages et 1 953,125 secteurs, de sorte qu’un tampon de cette taille chevauche une frontière de page à un bout et gâte une partie d’un bloc à l’autre. L’unité binaire n’est pas seulement traditionnelle ici — c’est celle qui correspond à ce qu’on alloue, et c’est pourquoi cette conversion est celle qu’il vaut la peine d’avoir exacte.

Une limite exprimée en mébioctets mérite trois fixtures plutôt qu’une, et leurs tailles sortent directement de cette conversion. Pour un plafond à 10 Mio, les octets intéressants sont 10 485 759, 10 485 760 et 10 485 761 : un en dessous, exactement à, un au-dessus. Savoir si la frontière elle-même doit passer dépend de ce que la vérification est — une comparaison ou un test strict — et c’est précisément la question qu’un test à la frontière tranche et qu’un test à 5 Mio ne tranche pas.

Ces fixtures gagnent à être produites par compte d’octets plutôt que par unité, pour la même raison que la constante. Un fichier créé avec un argument de taille dans une unité amicale hérite de la base qu’utilisait l’outil qui l’a créé, de sorte qu’une fixture censée être à un octet au-dessus d’une limite peut atterrir à quatre pour cent en dessous. Créer le fichier avec une longueur en octets explicite, affirmer sa longueur dans le test, et la fixture devient une preuve plutôt qu’une hypothèse.