Cookies de statistiques et de publicité
Nous utilisons des cookies de statistiques et de publicité, tous deux destinés à Google. Si vous refusez, rien ne change visiblement pour vous.Aller à la page de confidentialité
1 GB = 976562,5 KiB
Saisissez une valeur et la conversion de gigaoctet en kibioctet suit pendant que vous tapez. Le facteur vaut exactement 976562,5 : c’est ce que représente 1 Go en Kio. Le calcul se fait sur votre propre appareil ; une fois la page chargée, elle n’interroge plus aucun serveur.
64 Go is 62500000 Kio
— un téléphone d’entrée de gamme.
1000 Go is 976600000 Kio
— un disque vendu pour un téraoctet.
0,0005243 Go is 512 Kio
— un demi-mébioctet.
0,000004096 Go is 4 Kio
— une page de mémoire sur la plupart des systèmes.
| Go | Kio |
|---|---|
| 1 | 976562,5 |
| 2 | 1953125 |
| 5 | 4882812,5 |
| 10 | 9765625 |
| 50 | 48828125 |
| 100 | 97656250 |
| 500 | 488281250 |
| 1000 | 976562500 |
Convertir des Go en Kio
Un gigaoctet vaut un milliard d’octets, au sens décimal qu’emploient les fabricants de disques, les forfaits mobiles et les tailles de vidéo.
Un kibioctet vaut exactement 1 024 octets. Le nom a été introduit en 1998 pour que « kilooctet » puisse de nouveau valoir 1 000 — l’habitude n’a jamais tout à fait cédé.
Le facteur vaut 976562,5, et à peu près personne ne le trimballe. Arrondi à 980000, il s'écarte de 0,35 % — invisible sur de petits nombres, et devenu une unité entière vers 1 000 GB.
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 KiB vaut 1 024 fois l'unité du dessous ; un kB, 1 000. Sur cette page, c'est l'écart entre 0 GB et 0 GB — 2,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 2,4 %. Un disque vendu en kB contient exactement ce qui est annoncé ; Windows divise ensuite par 1 024 au lieu de 1 000, garde le nom décimal, et affiche 0 GB là où la boîte annonçait 0 GB. 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 gigaoctet vaut 1 000 000 000 d’octets et un kibioctet en vaut 1 024, donc le ratio est 976 562,5 exactement. Le demi n’est pas un artefact d’arrondi et ne disparaît pas avec plus de précision : un gigaoctet décimal n’est pas un nombre entier de kibioctets, parce que 10 à la neuvième n’a pas de facteur 1 024. Chaque chiffre impair de gigaoctet converti en blocs tombe sur un demi.
Cela importe partout où l’outil récepteur veut un entier, ce qui est la plupart. Arrondir au-dessus donne à l’utilisateur légèrement plus que promis, arrondir en dessous légèrement moins, et la troncature — ce que fait une division entière naïve — fait silencieusement la deuxième. Pour un quota, c’est une différence de 512 octets et personne ne le remarque ; pour une assertion dans un test, c’est la différence entre passer et ne pas passer.
Le df GNU sans argument imprime des blocs de 1 Kio. du -k fait de même. quota, repquota et setquota comptent en unités de 1 Kio. vmstat rapporte la mémoire en blocs de 1 024 octets. Ces interfaces ont été conçues quand un disque se mesurait en mégaoctets et qu’un compte de blocs tenait confortablement dans une colonne, et elles n’ont pas changé parce que chaque script qui les analyse se briserait.
Le résultat est qu’un volume moderne est décrit par un nombre à neuf chiffres. Un système de fichiers de 2 To fait 1 953 125 000 blocs. C’est illisible par conception et précis par accident, et c’est la raison pour laquelle cette conversion est faite bien plus souvent par des scripts que par des gens — ce qui en retour explique pourquoi obtenir la constante exacte une fois, dans une variable nommée, vaut plus que de la mémoriser.
Un quota est presque toujours convenu en gigaoctets décimaux, parce que c’est l’unité dans laquelle l’accord a été écrit : cinquante gigaoctets par utilisateur, cinq cents par projet. setquota veut des blocs. La multiplication est 976 562,5 par gigaoctet, donc cinquante gigaoctets font 48 828 125 blocs et cinq cents 488 281 250 — tous deux entiers, parce que le demi double en un entier à chaque chiffre pair.
Les limites souple et dure ont alors besoin du même traitement et reçoivent en général des valeurs différentes. Une limite souple dérivée d’un chiffre rond de gigaoctets et une limite dure posée en ajoutant « dix pour cent » au compte de blocs sont deux conversions avec deux décisions d’arrondi, et l’écart entre elles cesse d’être les dix pour cent que quiconque avait en tête. Convertir une fois, puis calculer les deux limites à partir du chiffre en blocs.
La comptabilité de quota fonctionne en unités de 1 Kio presque universellement. Le système de fichiers en dessous alloue en blocs de 4 Kio par défaut sur ext4 et la plupart des volumes modernes. Ce sont deux quantités différentes et un utilisateur consomme la seconde tout en étant facturé dans la première, donc l’usage de quota est rapporté comme quatre fois le compte de blocs pour chaque fichier qui occupe une seule unité d’allocation.
Pour un répertoire personnel de documents ordinaires l’effet est de quelques pour cent. Pour un répertoire de nombreux petits fichiers c’est le terme dominant : mille fichiers de 1 ko font un mégaoctet de contenu et environ quatre mégaoctets de quota. Quand quelqu’un soutient qu’il est sous sa limite et que l’outil est en désaccord, c’est la première chose à vérifier, et cela n’a rien à voir avec la question décimal contre binaire.
Les coreutils GNU lisent la variable d’environnement BLOCK_SIZE, et DF_BLOCK_SIZE et DU_BLOCK_SIZE la surchargent par outil. Poser POSIXLY_CORRECT change le bloc par défaut de 1 024 octets à 512, divisant par deux chaque chiffre que les outils impriment. Tout cela est documenté, rien de cela n’est visible dans la sortie, et tout cela voyage avec un profil shell plutôt qu’avec une commande.
La conséquence pratique est qu’un compte de blocs collé dans un ticket n’est pas auto-descriptif. Deux administrateurs lançant le même df sur le même hôte peuvent produire des chiffres qui diffèrent d’un facteur deux, et la discussion qui s’ensuit concerne le système de fichiers plutôt que l’environnement. Passer un --block-size explicite quand un nombre va ailleurs que sur son propre écran supprime toute la classe de problème.
Les comptes de blocs qui valent la peine d’être reconnus sont les ronds. 1 Go fait 976 563 blocs arrondi, 10 Go font 9 765 625, 100 Go font 97 656 250, 1 To fait 976 562 500. Les premiers chiffres sont les mêmes à chaque échelle — 9765625 — ce qui fait de la magnitude la seule chose à lire, et c’est un compte de chiffres plutôt qu’une valeur.
Cela rend aussi une erreur courante facile à repérer. Un chiffre commençant par 1048 ou 1073 est une conversion binaire-à-binaire faite avec la mauvaise paire d’unités : 1 048 576 blocs est un gibioctet, pas un gigaoctet. Si un compte de blocs commence par un 9, les unités ont changé de système comme prévu ; s’il commence par un 1, quelqu’un a divisé par la mauvaise chose.
Une capacité exprimée en gigaoctets décimaux a presque toujours pris naissance hors de la machine : une étiquette de disque, un palier de service, un contrat, un bon de commande. C’est le nombre que quelqu’un a acheté. Le compte de blocs est le nombre que la machine applique, et entre les deux se tiennent le surcoût de système de fichiers et les blocs réservés qu’aucune des deux parties n’a mentionnés.
Ainsi un quota de exactement 976 562 500 blocs sur un volume « 1 To » ne sera pas atteignable, parce que le volume ne présente pas un téraoctet complet d’espace utilisable une fois ses propres structures allouées. Poser des quotas par utilisateur dont la somme atteint la capacité nominale est la manière classique de sursouscrire un système de fichiers sans en avoir l’intention, et c’est un problème de conversion d’unité seulement en ce que les unités sont ce qui l’a fait paraître correct.
Avant les blocs de 1 Kio il y avait ceux de 512 octets, et ils n’ont pas disparu. POSIX spécifie 512 comme unité pour la sortie de df et du, ce qui explique pourquoi poser POSIXLY_CORRECT divise par deux chaque chiffre que ces outils impriment. tar compte en enregistrements de 512 octets. La géométrie de disque a utilisé des secteurs de 512 octets pendant des décennies, et les disques qui sont passés à des secteurs physiques de 4 096 octets présentent encore des secteurs logiques de 512 pour la compatibilité. ls -s rapporte les blocs alloués, historiquement en unités de 1 024 sur les systèmes GNU et de 512 ailleurs.
Le résultat pratique est qu’un compte de blocs n’a pas de sens sans sa taille de bloc, et la taille de bloc est une propriété de l’outil, de la plateforme et de l’environnement plutôt que du système de fichiers. Un chiffre de 1 953 125 000 est un volume de 2 To en blocs de 1 Kio et un volume de 1 To en blocs de 512, et rien dans le nombre ne distingue les deux. Noter l’unité à côté d’un compte de blocs n’est pas de la pédanterie ici ; c’est la seule chose qui rende le nombre interprétable.
1 Go vaut 976562,5 Kio. La valeur est exacte et non arrondie : la correspondance de gigaoctet en kibioctet est fixée par définition.
Non. Le calcul se fait dans votre navigateur. Vous pouvez couper la connexion et continuer à calculer — c’est d’ailleurs la façon la plus simple de le vérifier.
Parce que deux unités différentes portent le même nom. Les fabricants comptent 1 Go = 1 000 000 000 octets ; Windows affiche des gibioctets, soit 1 073 741 824 octets, tout en les appelant « Go ». Le même disque paraît ainsi environ sept pour cent plus petit. Rien n’a disparu.
Un Kio vaut 0,000001024 Go. C’est le même rapport lu à l’envers : un résultat obtenu sur une page et repassé par l’autre doit revenir à son point de départ.
Ce que cette page affirme sur unités d’information se vérifie : voici les documents qui le fixent.
Le facteur figure dans la page sous forme de constante, et le calcul tient en quatre opérations. Rien n’est donc envoyé et rien n’est attendu : ce que vous saisissez ne quitte jamais le navigateur, faute de requête dans laquelle voyager.