Convertir des Gio en o

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 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 gibioctet fait 1 073 741 824 octets, exactement, et 1 073 741 824 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 GiB vaut 1 024 fois l'unité du dessous ; un GB, 1 000. Sur cette page, c'est l'écart entre 1073741824 B et 1000000000 B — 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 1000000000 B là où la boîte annonçait 1073741824 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.

Beaucoup de paramètres prennent un nombre et aucune unité, et la documentation dit octets. Une taille de partie de stockage objet, une limite de corps de requête dans un cadriciel applicatif, une taille de tampon dans une configuration de base de données, un quota dans un appel d’API  : tous veulent un entier, et l’entier pour un gibioctet est 1 073 741 824. Multiplier par le chiffre en gibioctets et la réponse est exacte, parce que les deux unités sont des comptes définis et que rien n’est approximé.

La raison d’aller chercher l’unité binaire plutôt qu’un nombre décimal rond est que le système autour est presque certainement déjà binaire. Les pages mémoire, les tailles de bloc, les allocations de tampon et les plages d’adresses sont des puissances de deux, et une limite de 1 000 000 000 d’octets se tient maladroitement entre deux d’entre elles. Une limite de 1 073 741 824 s’aligne avec l’allocateur en dessous, ce qui explique pourquoi les outils qui vous laissent écrire un suffixe l’étendent de cette façon.

La convention à travers l’outillage opérationnel est qu’un k, m ou g nu signifie 1 024, 1 048 576 ou 1 073 741 824. Les drapeaux de tas de la JVM fonctionnent ainsi, donc -Xmx4g réserve 4 294 967 296 octets. Les limites de mémoire et de stockage Docker fonctionnent ainsi. Les directives de ressources systemd aussi, et les valeurs de taille dans nginx. Aucun de ceux-ci ne l’annonce dans la valeur elle-même  ; la lettre ressemble à un préfixe SI et se comporte comme un préfixe binaire.

Les coreutils GNU vont un cran plus loin et acceptent les deux orthographes, avec une règle facile à énoncer et facile à oublier  : une seule lettre est binaire et une forme à deux lettres se terminant en B est décimale. dd bs=1G copie par blocs de 1 073 741 824 octets et dd bs=1GB copie par blocs de 1 000 000 000. Les deux commandes se ressemblent presque dans un historique de shell et diffèrent de sept pour cent dans chaque bloc qu’elles déplacent.

Les quantités de ressources dans Kubernetes portent la distinction dans leur syntaxe. Un suffixe Gi est binaire, donc 1Gi est 1 073 741 824 octets  ; un suffixe G sans i est décimal, donc 1G est 1 000 000 000. La même chose tient à chaque échelle — Ki contre k, Mi contre M, Ti contre T — et le manifeste dit précisément ce qu’il dit sans convention d’outil à aller chercher.

Cette clarté a un tranchant vif. Une limite de mémoire écrite 4G plutôt que 4Gi est 294 967 296 octets plus petite, ce qui fait une différence d’environ sept pour cent et entièrement invisible à la relecture. Là où une charge de travail est proche de son plafond, cette seule lettre manquante est la différence entre un pod qui tourne et un pod qui est tué pour avoir dépassé sa limite à un moment chargé.

Une poignée de comptes d’octets reviennent à répétition dans les messages d’erreur et les champs de limite, et les connaître évite une conversion. 1 048 576 est un mebioctet, 1 073 741 824 est un gibioctet, 2 147 483 648 est deux d’entre eux, et 4 294 967 296 est 2³² — la taille exacte d’un espace d’adressage 32 bits, et le plafond qu’un processus 32 bits ne peut pas dépasser quelle que soit la mémoire de la machine.

Un de moins que ces chiffres compte autant que les chiffres eux-mêmes. 2 147 483 647 est le plus grand entier signé 32 bits, et tout compte d’octets porté dans l’un s’arrête là. Un fichier qui se téléverse à 1,9 Gio et échoue à 2,1 rencontre d’habitude cette frontière plutôt qu’une limite configurée, et aucune relance de la limite configurée ne la déplacera.

Les échecs bruyants sont le cas favorable. Un conteneur qui dépasse sa limite de mémoire est tué avec un statut reconnaissable  ; un téléversement au-dessus d’une limite de taille de corps est rejeté avec un code de statut qui nomme le problème. Les deux pointent vers le paramètre qui les a causés, et la correction est une seule édition une fois que le compte d’octets a été correctement dégagé.

Les échecs silencieux coûtent plus. Un tas dimensionné sept pour cent au-dessus de ce que le conteneur autorise n’échoue pas au démarrage — il échoue des semaines plus tard, sous charge, quand le processus essaie enfin d’utiliser la mémoire qu’on lui a dit avoir. Une limite de cache posée dans la mauvaise unité n’erreur pas du tout  ; elle évince plus souvent que prévu, et le seul symptôme est un taux de succès légèrement plus bas que ce que la conception avait prédit.

Une ligne de configuration lisant 8 589 934 592 ne dit rien au relecteur sur l’intention. La même valeur écrite 8 1024 1024 * 1024 là où le format permet une expression, ou annotée d’un commentaire disant huit gibioctets, est vérifiable au premier coup d’œil. Chaque grande constante d’octets dans un dépôt est un nombre que quelqu’un devra éventuellement vérifier, et celles qui portent leur propre dérivation sont celles qui survivent intactes à un refactoring.

Là où la syntaxe permet un suffixe, le préférer aux chiffres étendus. Presque toute faute de frappe dans 1Gi est une erreur de syntaxe, et celle qui ne l’est pas — sauter le i — coûte sept pour cent  ; une faute de frappe dans 1 073 741 824 est une configuration qui marche avec une limite dix fois trop grande ou trop petite. Cette asymétrie est tout l’argument en faveur des suffixes, et c’est pourquoi les outils qui les ont adoptés reviennent rarement en arrière.

La séquence continue par facteurs de 1 024  : un tebioctet est 2⁴⁰, soit 1 099 511 627 776 octets, et un pebioctet est 2⁵⁰, soit 1 125 899 906 842 624. Tous deux apparaissent dans des limites plutôt que dans des mesures — tailles maximales d’objet, tailles maximales de fichier, plafonds d’espace d’adressage — parce que ce sont les endroits où quelqu’un a dû choisir une puissance de deux et l’écrire.

Le plafond qui compte le plus en pratique se tient au-dessus de tous. Un compte d’octets non signé 64 bits atteint 16 Eio, ce qu’aucun système actuel n’approche, donc les comptes d’octets en code moderne ne débordent pas. Ce qu’ils font plutôt est perdre en précision quand ils passent par une couche qui stocke les nombres en virgule flottante, et cela arrive autour de 8 Pio — bien en dessous de la limite du type et bien au-dessus de tout ce qu’une seule valeur de configuration détiendra jamais.

Quoi qu’on ait écrit, relire la valeur effective depuis le système plutôt que de se fier au fichier. Les moteurs de conteneurs exposent le plafond de mémoire qu’ils ont appliqué, la JVM imprimera ses réglages de tas résolus sur demande, et la plupart des serveurs rapportent leur configuration analysée. Le nombre qui revient est en octets, et le comparer à 1 073 741 824 fois le chiffre visé est un contrôle de deux secondes qui attrape chaque erreur d’unité d’un coup.

Cela compte le plus là où deux couches imposent chacune une limite dans une unité différente. Une limite de processus écrite en gibioctets à l’intérieur d’un conteneur dont la limite a été écrite en gigaoctets décimaux laisse un écart de sept pour cent que personne n’a planifié, et la plus petite des deux gagne silencieusement. Relire les deux en octets les met à la même échelle et rend l’ordonnancement évident.