Pourquoi toutes les tailles de type de données sont-elles toujours une puissance de 2?
Prenons deux exemples: P>
short int 12
10 Réponses :
La raison pour laquelle les types de bâtiments sont ces tailles est simplement que c'est ce que les CPU soutiennent de manière nativement, c'est-à-dire le plus rapide et le plus facile. Aucune autre raison.
Comme pour les structures, vous pouvez avoir des variables là-bas qui ont (presque) n'importe quel nombre de bits, mais vous voudrez généralement rester avec des types d'intégrale, sauf décision vraiment urgente de faire autrement.
Vous voulez également généralement regrouper des types de taille identiques et commencer une structure avec les plus gros types (généralement des pointeurs).
qui évitera un rembourrage inutile et cela veillera à ne pas avoir d'accès à des pénalités d'accès que certains Les processeurs exposent avec des champs mal alignés (certains processeurs peuvent même déclencher une exception sur l'accès non aligné, mais dans ce cas, le compilateur ajouterait du remplissage pour l'éviter, de toute façon).
Ce que Certains Les CPU soutiennent de manière nativement, vous voulez dire.
Si Certains signifie 99,9% de tous les systèmes existants et 100% de tous les systèmes que vous êtes susceptibles de rencontrer, sauf si vous êtes un collectionneur, alors oui, certains. :-) Les architectures avec des entiers de 24 ou 36 bits ou des caractères 7 bits ne sont tout simplement pas courants, vous devrez admettre.
Non, ce n'est pas ce que certains moyens. Ce n'est pas non plus précis. En enterant votre tête dans le sable et prétendre que des architectures alternatives n'existent pas est une énorme erreur. En supposant que les détails de la mise en œuvre, comme celui-ci ne s'agit pas de la manière dont vous devenez un meilleur programmeur, ce qui devrait toujours être l'objectif. Il y a une grande différence entre "pas courante dans mon expérience" et "99,9% de tous les systèmes existants".
@Cody: Je vais devoir être en désaccord avec vous là-bas. La grande majorité des programmeurs de cette planète ne rencontrent jamais et ne rencontreront jamais une architecture non-pot, et de grandes quantités de code qui suppose que Pot ont été écrites et continueront d'être écrites dans un avenir prévisible. Étant donné que les tailles de données de pot sont omniprésentes dans des appareils mobiles de bureau, serveur et grand public, ce n'est guère une hypothèse déraisonnable. Bien sûr, il est bon de savoir que d'autres architectures existent, mais cela ne fait pas mal d'assumer le pot. Cela aide parfois à la performance.
@Marcelo: Alors que j'accepte que cela puisse parfois être utile pour cibler le code à votre architecture spécifique pour des raisons de performance, mon point était un peu plus général. Je discute simplement d'ignorer la présence d'architectures alternatives et de les rejeter comme rare au point de savoir-faire est une mauvaise idée. surtout à une question générale comme celle-ci. Je ne sais pas que la plupart des programmeurs manquent d'expérience avec de tels systèmes (je manque moi-même une telle expérience), mais je vois cela comme un danger potentiel, et non quelque chose à encourager.
@Cody: En fait, c'est le point plus large que je suis en désaccord avec. Les programmeurs traitent avec potentiel dangers tout le temps. Une grande partie du code de base de données que je travaille avec implicitement suppose que nous n'aurons jamais 10 millions de lignes dans notre table "Clients". Quelle hypothèse est plus susceptible d'être violée: a) nous n'aurons jamais 10 millions de clients, ou b) notre code ne sera jamais exécuté sur une architecture non-pot? Je penserai à traiter avec (a) lorsque nous atteignons un million de clients, alors que je doute que je donnerai jamais (b) une seconde pensée. Est-ce vraiment une énorme erreur?
Voir, personne (y compris moi) doute que les systèmes avec des entiers NPOT existent. Et pendant que je suis d'accord que faire des hypothèses telles que la taille de la taille de (vide *) == 4 ne sont pas bien et que jamais été, la réponse "parce que c'est ce que les CPU mâchent bien" est une réponse entièrement adaquate pour une personne qui à toutes les apparences est dans le processus d'apprendre que les bases de la programmation sont soulevées de la raison de quelque chose qui semble être "standard" pour aucune raison apparente. En discutant de la question de savoir si certains principaux dans les années 1960 avaient des mots de 6 bits et des adresses 36 bits sont plus susceptibles d'ajouter plus de confusion, d'être honnête.
(Limited par MAX LEN) Comme une analogie: il s'agit comme si quelqu'un a demandé pourquoi les téléviseurs (signal HDTV et DVD et National) sont venus en 720 (p / i) et 1080 (p / i) résolutions, pourquoi de tels nombres impairs, Pourquoi pas quelque chose d'autre, peut-être 1000. Si vous leur dites »car 720 est 1,5 fois 480, ce qui était ce que vous aviez ce que vous aviez dans une télévision, et 1080 est 1,5 fois 720" puis les gens diront "AHA, bien sûr, ça a du sens ". Si vous dites «Eh bien, vous savez, il y a aussi un PAL avec 625 lignes aussi, il existe également des téléviseurs en noir et blanc ...», alors cela est certainement correct, mais cela fait-il que quelqu'un comprend pourquoi il y a 1080P?
C'est un détail de mise en œuvre, et ce n'est pas toujours le cas. Certaines architectures exotiques ont des types de données non power-de-deux. Par exemple, Les mots 36 bits étaient communs à une étape.
Les pouvoirs de deux sont presque universels de nos jours sont qu'il simplifie généralement les implémentations matérielles internes. Comme exemple hypothétique (je ne fais pas de matériel, je dois donc avouer que c'est la plupart des devinatus), la partie d'un opcode qui indique à quel point l'un de ses arguments est peut-être stocké comme indice de puissance de deux Le nombre d'octets dans l'argument, donc deux bits suffisent pour exprimer lequel de 8, 16, 32 ou 64 bits l'argument est et le circuit nécessaire pour convertir cela dans les signaux de verrouillage appropriés serait assez simple.
Ces deux bits de l'opcode pourraient également facilement spécifier 12, 24, 36 ou 48 bits. C'est le choix d'avoir une unité minimale de 8 bits qui fait tout ce que la taille est de ces jours-ci.
Un mot 36 bits est toujours une puissance de 2 (mais pas une puissance de 256 (pas un nombre entier de octets )). ( est dans ce contexte signifie peut représenter cette gamme de valeurs entières )
Eh bien, ce sont des pouvoirs de 2 parce qu'ils sont des multiples de 8, et cela vient (simplifier un peu) du fait que l'unité d'allocation atomique en mémoire est généralement un octet, qui ( Les plus grandes tailles de données sont effectuées avec plusieurs octets à la fois.
Donc, vous pourriez avoir 8,16,24,32 ... tailles de données. Puis, pour la vitesse d'accès à la mémoire, seuls les puissances de 2 sont utilisées comme multiplicateur de taille minimale (8) , vous obtenez donc des tailles de données le long de ces lignes:
J'ai déclaré que je simplifiez, car ce n'était clairement pas le cas des DSP. Je ne comprends pas pourquoi -1, cependant.
Je n'ai pas bownviche, mais, étant donné que la première moitié de la première phrase est fausse (24 n'est pas une puissance de deux), je ne pense pas qu'un bowvote est tout ce dur.
Et qui a dit que 24 était une puissance de deux? J'ai dit que 24 est un multiple de 8.
Le -1 était de moi, pour avoir déclaré "... un octet, qui est fabriqué par 8 bits.", Qui est incorrecte et trompeuse. Si vous réparez cela, je vais supprimer le -1.
@Paul R: Comme je vous ai déjà répondu précédemment commentaire, j'ai déclaré que je simplifiais la question de la simplicité de la simplicité car elle me semblait que Vivek parlait de l'affaire latimée X86. Quoi qu'il en soit, j'imagine que ce n'est pas assez clair, je vais donc ajouter une note.
8 bits est la taille la plus courante pour un octet (mais pas la taille , des exemples d'octets de 9 bits et d'autres tailles d'octets ne sont pas difficiles à trouver). Les types de données plus importants sont presque toujours des multiples de la taille des octets, par conséquent, ils seront généralement 16, 32, 64, 128 bits sur des systèmes avec des octets de 8 bits, mais pas toujours des pouvoirs de 2, par exemple. 24 bits sont courants pour les DSP, et il y a des types de points flottants de 80 bits et 96 bits.
La taille du char, court, int, long etc. diffère en fonction de la plate-forme. Les architectures 32 bits ont tendance à avoir du char = 8, courte = 16, int = 32, long = 32. Les architectures 64 bits ont tendance à avoir char = 8, courte = 16, int = 32, long = 64.
De nombreux DSP n'ont pas de pouvoir de 2 types. Par exemple, Motorola DSP56K (un peu daté maintenant) a des mots 24 bits. Un compilateur pour cette architecture (à partir de tâches) a char = 8, courte = 16, int = 24, long = 48. Pour que les choses confusent, ils ont fait l'alignement de char = 24, courte = 24, int = 24, long = 48. En effet, il n'a pas d'octet d'octet: l'unité minimale accessible est de 24 bits. Cela dispose de la propriété passionnante (gênante) d'impliquer de nombreux lieux de division / modulo 3 lorsque vous devez vraiment accéder à un octet de 8 bits dans un tableau de données emballées.
Vous ne trouverez que non-Power-of-2 dans des noyaux spéciaux, où la taille est adaptée à un motif d'utilisation spécial, à un avantage de la performance et / ou de la puissance. Dans le cas de 56k, c'était parce qu'il y avait une unité multipliée qui pourrait charger deux quantités de 24 bits et les ajouter à un résultat de 48 bits en un seul cycle sur 3 bus simultanément. Toute la plate-forme a été conçue autour de lui.
La raison fondamentale Les architectures les plus générales utilisent des puissances de-2 sont dus à la normalisation de l'octet (8 bits d'octets) en tant que type de taille minimale (en dehors des drapeaux). Il n'y a aucune raison pour laquelle il n'aurait pas pu être 9 bit, et comme indiqué ailleurs 24 et 36 bits étaient courants. Cela imprègnerait le reste de la conception: si X86 était de 9 bits d'octets, nous aurions 36 lignes de cache d'octet, 4608 pages d'octet et 569kb suffiraient à tout le monde :) Nous n'aurions probablement pas «grignotant» cependant, comme Vous ne pouvez pas diviser un octet de 9 bits en deux.
Ceci est presque impossible à faire maintenant, cependant. Tout va bien avoir un système conçu comme celui-ci depuis le début, mais inter-opérant avec des données générées par 8 systèmes d'octets bits serait un cauchemar. Il est déjà assez difficile d'analyser les données 8 bits dans un DSP 24 bits.
Le choix de 24 bits était bien sûr due à être destiné à être un processeur audio. En fait, les accumulateurs de 56k sont 56 bits de large (d'où le nom). Donc, ce n'est même pas un multiple trivial de 8 bits comme type! La justification: vous pouvez multiplier deux numéros de 24 bits pour obtenir 48 bits de réponse, puis la somme 256 d'entre elles avant de répondre à une vérification des débordements. Conception intelligente, et tout a été conçu autour de lui.
Edité ma réponse à inclure qu'il n'y a pas de raison fondamentale qu'il doit être des pouvoirs de-2. Bien que je suis content que ce soit!
La taille des types d'intégration standard est définie comme multiples de 8 bits, car un octet code> est 8 bits (avec quelques exceptions extrêmement rares) et le bus de données de la CPU est normalement multiple. de 8 bits de large.
Si vous avez vraiment besoin d'entiers 12 bits, vous pouvez utiliser champs de bits code> dans les structures (ou les syndicats) comme ceci: p> struct mystruct
{
short int twelveBitInt : 12;
short int threeBitInt : 3;
short int bitFlag : 1;
};
Ils ne sont pas nécessairement. Sur certaines machines et compilateurs, tailleof (double double) == 12 (96 bits).
Il n'est pas nécessaire que tous les types de données utilisent la puissance de 2 comme nombre de bits représentent. Par exemple, Long Double Utilise 80 bits (bien que sa mise en œuvre dépend de la quantité de bits allouer).
Un avantage que vous gagnez avec la puissance de 2 est, des types de données plus importants peuvent être représentés comme des plus petits. Par exemple, 4 caractères (8 bits chacun) peuvent constituer un int (32 bits). En fait, certains compilateurs utilisés pour simuler 64 bits en utilisant deux nombres 32 bits.
La plupart des temps de votre ordinateur tentent de conserver tous les formats de données dans un multiple total (2, 3, 4 ...) ou une pièce entière (1/2, 1/3, 1/4 ...) de la taille de la machine. Cela le fait pour que chaque fois qu'il charge n mots de données, il charge un nombre d'éléments d'informations entier pour vous. De cette façon, il n'est pas nécessaire de recombiner les pièces plus tard.
Vous pouvez le voir dans le X86 par exemple:
Un caractère est 1/4 de 32 bits
Un court est 1/2 des 32 bits
Un int / long est un ensemble de 32 bits
Un long long est 2x 32 bits
Un flotteur est un 32 bits de 32 bits
Un double est deux fois 32 bits
Un double doublé peut être trois ou quatre fois 32 bits, en fonction de vos paramètres de compilateur. En effet, pour les machines 32 bits, il s'agit de trois mots de machine natif (donc pas de frais généraux) pour charger 96 bits. Sur des machines de 64 bits, il s'agit de 1,5 mot de machine natale, de sorte que 128 bits seraient plus efficaces (pas de recombinaison). Le contenu de données réel d'un long double sur X86 est de 80 bits, de sorte que ces deux sont déjà rembourrés.
Un dernier côté, l'ordinateur ne charge pas toujours dans sa taille de données native. Il prend d'abord une ligne de cache, puis se lit à partir de celui des mots de la machine natif. La ligne de cache est plus grande, généralement environ 64 ou 128 octets. Il est très utile d'avoir un peu de données significatifs à cela et de ne pas être bloqué sur le bord car vous devriez charger deux lignes de cache entières pour la lire alors. C'est pourquoi la plupart des structures informatiques sont une puissance de deux personnes; Il conviendra à n'importe quelle puissance de stockage de deux tailles de moitié, complètement, double ou plus - vous êtes garanti de ne jamais vous retrouver sur une limite.
Il y a quelques cas où des types d'intégrale doivent être une puissance exacte de deux. Si les types exacts de largeur dans En pratique, beaucoup de code hérité aurait déjà rompu sur n'importe quelle machine qui n'a pas pris en charge les types exactement 8, 16, 32 et 64 bits de large. Par exemple, tout programme qui lit ou écrit ASCII ou essaie de se connecter à un réseau se casserait.
Certains ordinateurs centraux et minicomitateurs historiquement importants avaient des tailles de mots indigènes qui étaient des multiples de 3, et non des pouvoirs de deux, en particulier du PDP-6 déc. PDP-6, PDP-8 et PDP-10.
C'était la principale raison que la base de la base 8 était populaire en informatique: puisque chaque chiffre octal représentait trois bits, un motif de 9, 12 à 18 ou 36 bits pourrait être représenté plus proprement par des chiffres octales que décimales. ou hexagonal. Par exemple, lors de l'utilisation de la base-64 pour emballer des caractères dans six bits au lieu de huit, chaque caractère emballé a pris deux chiffres octals.
Les deux legs les plus visibles de ces architectures sont aujourd'hui que, par défaut, des évasions de caractères tels que int16_t ou uint32_t , leurs largeurs doivent être exactement cette taille, avec Pas de rembourrage. Math de point flottant qui se déclare suivre les forces standard IEEE float et double pour être pouvoirs de deux (bien que Long double souvent n'est pas) . Il existe en outre des types char16_t et char32_t dans la bibliothèque standard maintenant ou intégré à C ++, défini comme types exacts de largeur. Les exigences relatives à la prise en charge de l'UTF-8 en vigueur signifient que char et non signé Char doit être exactement de 8 bits large.
'\ 123' sont interprétées comme octal plutôt que décimales dans C, et que les autorisations / masques de fichiers UNIX sont représentés comme trois ou quatre chiffres octals.
Je pense qu'il existe un système où
char_bit == 9 et unint est de 36 bits.Et il y a beaucoup de DSP où la taille du mot est de 24 bits.
Lorsque vous y pensez, il est logique de faire des choses un pouvoir de deux, car tout est binaire, ce qui est base deux. Donc (la plupart) tout est (généralement) une puissance avec base deux.
La taille du type de données, l'alignement, la taille de la pageFile et plus sont toutes plus faciles à mettre en œuvre lorsque vous pouvez simplement les manipuler à l'aide d'opérations faciles à bit / bitShift / bitmask. pas besoin de multiplication / divisions qui sont trop chers et que personne ne veut produire du matériel lent
Tous sont tous des pouvoirs de 2. taille en bits et La taille en octets peut être des non-pouvoirs de 2