Convertir des o en Gio

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.

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.

Dans ce sens, l'opération est une division, et par un nombre entier : 1 073 741 824 de ces unités entrent dans un gibioctet sans reste. Le seul inconvénient, c'est que les résultats tombent en fractions — un tiers, un douzième — au lieu des chiffres ronds que donne le sens inverse.

Rien ne se perd pour autant : la division est exacte. Si votre résultat refuse de tenir en place en décimal — 0,0833… et compagnie —, c'est la fraction qui transparaît, pas une erreur qui s'installe.

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.

Un logiciel émet une taille en octets par principe : le chiffre n’a pas de préfixe à interpréter, pas d’arrondi à défaire, pas de locale dedans, et un export JSON, un en-tête Content-Length et une ligne de log peuvent s’y comparer sans se mettre d’accord au préalable sur ce que veut dire un G. C’est précisément ce qui rend le résultat illisible : 17 179 869 184 ne dit rien tant qu’il n’a pas été divisé.

La division à utiliser est 1 073 741 824 quand le système qui a produit le chiffre raisonne en binaire, ce qui est le cas de la mémoire, du cache de pages, de l’espace occupé sur un système de fichiers et de presque tous les compteurs de système d’exploitation. Ce chiffre tombe sur 16 Gio exactement. Diviser par un milliard à la place donne 17,18 et masque le fait que la valeur était une puissance de deux propre, qui est souvent l’information la plus utile qu’elle contient.

Avant toute division, comptez les chiffres. Dix chiffres vous met entre 0,93 et 9,3 Gio, onze entre 9,3 et 93, douze entre 93 et 931, et treize chiffres vous pose autour d’un tébioctet. Ce seul coup d’œil répond à la plupart des questions que pose un compteur d’octets — est-ce un cache de l’ordre du mébioctet ou du gibioctet, est-ce qu’une ligne de journal annonçant un transfert est plausible — sans la moindre arithmétique.

L’habitude paie surtout sur les sorties qui mélangent les échelles. Une API qui rend douze compteurs d’octets en a certains dans les millions et d’autres dans les milliards, et l’œil trie par longueur plus vite qu’il ne trie par valeur. Convertir seulement ceux qui finissent par importer est considérablement plus rapide que de tout convertir, et la détection précoce des outliers se fait au passage.

Certains chiffres méritent d’être reconnus d’un coup d’œil parce qu’ils s’annoncent eux-mêmes. 1 073 741 824 est un gibioctet, 2 147 483 648 en sont deux, 4 294 967 296 quatre, 8 589 934 592 huit, 17 179 869 184 seize. Quand l’une de ces valeurs apparaît dans une sortie, c’est presque toujours une capacité ou une limite, parce qu’une mesure réelle ne tombe pas exactement sur une puissance de deux.

L’inverse est également utile. Un compteur d’octets qui finit par une longue suite de zéros — 1 000 000 000, 50 000 000 000 — a été tapé par une personne ou dérivé d’une valeur décimale, et il ne correspond à rien de ce que fait le matériel spontanément. Le repérer dans un export de configuration explique souvent pourquoi une limite tombe un cran en dessous de la borne d’allocation qu’elle était censée épouser.

Les langages qui stockent tous leurs nombres en flottants double précision représentent les entiers exactement jusqu’à 9 007 199 254 740 991, soit 2⁵³ moins un, ou environ 8 Pio. En dessous de ce plafond, un compteur d’octets peut être porté, comparé et additionné sans surprise. Au-dessus, les valeurs s’arrondissent en silence, et deux tailles distinctes peuvent comparer comme égales sans qu’aucune erreur ne soit levée.

La plupart des systèmes n’y arriveront jamais, et ceux qui y arrivent s’y mesurent plutôt en agrégat qu’à l’unité — un total sur un parc, un compteur de transfert à vie, une somme sur une grande table. Les parades sont de garder les compteurs en entiers 64 bits ou en chaînes de caractères à la frontière d’une sérialisation, et de faire l’agrégation là où vit le type large plutôt qu’après que le nombre est passé par une couche qui élargit tout en flottant.

La plupart des utilitaires ont un mode qui supprime leur formatage lisible, et il vaut la peine d’être utilisé dès que la sortie va ailleurs que sur un écran. Les outils d’espace disque acceptent une taille de bloc de un, les requêtes de métadonnées de fichier renvoient la longueur exacte, et les API de stockage objet retournent une longueur de contenu en octets par principe. Toutes ces sources sont sans perte, ce qu’un 1,4 Gio formaté n’est pas.

La perte n’est pas rattrapable après coup. Un chiffre affiché en 1,4 Gio peut être n’importe quoi entre 1 449 551 462 et 1 556 925 644 octets, un écart de plus de 100 Mo, et aucune multiplication ne resserre l’incertitude. Les pipelines qui raclent une sortie formatée et reconvertissent en octets construisent cette indétermination dans chaque calcul aval, et la dérive ne devient visible que lorsque deux tels pipelines sont comparés.

La règle qui évite la plupart des discussions consiste à afficher dans l’unité que compte le système mesuré. La mémoire, le cache de pages, l’espace occupé sur un volume et les pools de tampons sont en binaire, donc un graphique qui les représente s’exprime en Gio. Les totaux de stockage objet, les volumes d’égress et tout ce qui apparaît sur une facture sont en décimal, donc en Go. Convertir l’un dans l’autre sur le chemin de l’écran ajoute une étape où le lecteur peut perdre le fil de ce qu’il regarde.

Quelle que soit l’unité choisie, l’étiquette de l’axe doit dire laquelle. Un graphique de mémoire étiqueté Go alors qu’il trace une division par 2³⁰ reproduit la même erreur que Windows pratique, à un endroit où quelqu’un finira par la comparer à un chiffre décimal venu d’une facture. Une lettre de plus sur l’axe supprime toute la classe de confusion.

Deux outils peuvent rapporter des compteurs d’octets exacts et diverger quand même, parce qu’ils comptent des choses différentes. La longueur d’un fichier n’est pas l’espace qu’il occupe, une taille stockée n’est pas une taille transférée dès que la compression est dans la chaîne, et la taille d’une image de conteneur sur disque n’est pas le nombre d’octets tirés sur le réseau. Convertir chacune en gibioctets les rend présentables comme comparables sans les rendre comparables pour de bon.

La discipline qui aide consiste à noter ce qu’un compteur mesure à côté du nombre lui-même. Une métrique nommée pour son unité mais pas pour son sujet — bytes, size, total — finira par être sommée avec une autre qui voulait dire autre chose. Nommer la mesure dans l’étiquette ne coûte rien et empêche une classe de tableaux de bord dont les chiffres sont individuellement corrects et collectivement dépourvus de sens.

La vérification la moins coûteuse consiste à refaire l’opération à l’envers. Prenez la figure en gibioctets, multipliez par 1 073 741 824 et comparez à la chaîne de chiffres d’origine. Si le résultat est à environ sept pour cent près, le diviseur était un milliard plutôt que 2³⁰ ;s’il est à un facteur 1 024 près, un préfixe a été sauté quelque part. Les deux erreurs ont l’air plausible sur un tableau de bord et aucune ne survit à la multiplication.

Là où une conversion est embarquée dans du code plutôt que faite à la main, la même vérification a sa place dans un test avec une paire connue : 5 368 709 120 octets font 5 Gio, et toute implémentation qui produit 5,37 a utilisé le diviseur décimal. Une assertion de cette forme attrape l’erreur pour de bon et coûte une ligne.