essayer std :: tr1 :: tableau code> sur un mac, je reçois 16 alignement d'octets. sizeof( ARRAY< T, N> ) = sizeof( T )*N
4 Réponses :
Il ressemble à quelles petites données que vous avez données comme elles attribuent la mémoire à la puissance la plus proche de deux. Connaissant très peu de détails de l'architecture de la CPU, je pourrais deviner que l'allocation de la puissance de deux tailles est plus rapide que non pavée, du moins pour de petites quantités. Peut-être devriez-vous voir ce qui se passe lorsque vous essayez d'allouer quelque chose de beaucoup plus grand?
Y a-t-il une raison pour laquelle vous avez absolument besoin d'écrémer ces octets supplémentaires du haut?
>> "Y a-t-il une raison pour laquelle vous avez absolument besoin d'écrémer ces octets supplémentaires de haut?" Je fais habituellement mon propre modèle
Je viens d'essayer de l'utiliser dans une autre classe, et assurez-vous que les composants individuels obtiennent également un alignement individuel et un rembourrage. Bien sûr, c'est le comportement attendu avec attribut (__ aligné ) dans l'en-tête de la bibliothèque.
Depuis la publication, les virages, je reçois ce que je veux échanger le paramètre IDE à partir de la valeur par défaut.
sizeof(array<T,N>)==sizeof(T)*N
"J'espère que l'un est simplement obsolète et que ce comportement est ce que je vais aller sur d'autres plates-formes?" Non ce n'est pas. Les compilateurs ont la latitude pour aligner la plupart des objets de manière flexible. Ils pourraient même avoir un alignement différent entre le débogage et la libération. Je ne sais pas pourquoi vous avez besoin de telles exigences d'alignement spécifiques.
C'est pour les données de sommet de rendu 3D - définitivement un cas critique taille . Le problème est l'alignement supplémentaire demandé délibérément dans l'en-tête TR1, sur la valeur par défaut du compilateur supérieur. J'assume que le compilateur par défaut serait le plus souvent la structure de données la plus compacte, avec une alignement par type à sa propre taille. Je peux piquer les données dans des octets de mémoire brutes par octet si nécessaire, j'ai mon propre modèle, mais s'il y a quelque chose dans la STL qui fait le même travail que je peux simplifier ma source, le rendre facilement compréhensible par d'autres et plus susceptibles de Interopérer avec d'autres bibliothèques, qui est une victoire.
Pour les tampons de données de sommet, il est presque toujours préférable de les gérer comme mémoire brute. Pas seulement parce que vous serez en contrôle, mais parce que vous voulez ce contrôle. Avec ce contrôle, vous pouvez jouer des tours comme en utilisant des positions à 3 étages avec des couleurs de 4 octets, toutes emballées dans 16 octets-Per-Vertex. Ou l'utilisation de celle combinée avec des normales au format 10/10 / 10 bits et des coordonnées de texture situées dans un short de 16 bits, pour un total de 24 octets par sommet.
J'ai fait toutes les tours de mémoire brutes, puis créé des modèles pour les rendre plus lisibles. Automatisez les conversions vers et à partir de formats emballés et des calculs de configuration intermédiaires étendus comme des flotteurs complets. J'ai créé une classe de points fixe peut instancier en 8bits pour les couleurs ou 16 pour les sommets; et une classe de flotteur «demi». Comme le nombre de permutations augmente, la polyvalence des modèles est la bienvenue. Les transactions brutes et les fonctions d'assistant deviennent malades pour nommer. Où la vitesse n'a pas d'importance, j'aime la source la plus compacte :)
Je pourrais faire quelque chose de complètement axé sur les données, en esquivant complètement le problème de la classe, mais il est agréable d'avoir la représentation C ++ la plus naturelle à tout moment, je souhaite manipuler les données de sommet dans la langue (formats de traduction, décompression, génération de mailles de procédure ..)
Les mandats standard que les éléments "sont stockés contiguës, ce qui signifie que si A est un tableau, il obéit l'identité et a [n] == & a [0] + n pour tous 0 <= n Autant que je sache, il n'y a aucune garantie que Tailleof (STD :: Array) == Tailleof (T) * N, mais l'instruction de contiguïté affirme que les valeurs sont stockées comme dans un tableau C normal.
Si vous n'avez qu'un seul éventail de valeurs qui doivent être contiguës, vous pouvez utiliser Tailleof (T) * STD :: Array :: Taille () As Taille et STD :: Array :: Données () Comme adresse de départ de la Array.
Je suppose que je peux me prévenir avec une statique_assert à ce sujet pour la portabilité.
std :: Array n'est pas Un tableau, mais une structure qui contient un tableau. C'est la structure qui est rembourrée, pas la matrice. Les compilateurs sont autorisés à ajouter du remplissage à la fin d'une structure chaque fois qu'ils le souhaitent.
Oui, il est intégré dans la langue:
t a [n]; static_asserat (taille de (a) == taille de (t) * n); .Qu'est-ce que STDLIB utilisez-vous cela résulte de ce rembourrage aussi étrange?
haha ok bien sûr. Ce que je voulais dire est une collection emballée avec des méthodes supplémentaires, par exemple Convient pour accrocher dans la plage basée sur ou pour prendre des opérateurs d'affectation / conversion par éléments. Cela vient de Mac OSX 10.7, cible = 64 bits Intel, LLVM 3.0. Leur mise en œuvre de STD :: TR1 :: Array déclare Attribute (__ aligné ), ce qui est probablement pourquoi :( bien sûr on veut aligné pour le faire, il ne s'agit que de défaut
@cenauroian_slug: Non, tout est et doit être aligné par défaut. La question est de savoir pourquoi / si cette classe particulière a un alignement plus strict que nécessaire
-Leséry si ma dernière ligne semblait imprécise..ians, je comprends que la plupart des types préfèrent que la plupart des CPU aient leur posséder alignement, c'est donc défaut, je m'y attends. Mais l'attribut ( aligné ) signifie que la sélection de certains «extra» au-delà la valeur par défaut (la motivation étant généralement destinée à la large charge / magasins SIMD ou aux lignes de cache) .. définitivement inattendu comportement.
@cenaurian_slug Ouais, ici: gcc.gnu.org/onlinedocs/gcc-7.1.0/gcc/... Lorsque vous laissez le facteur d'alignement dans une spécification d'attribut aligné, le compilateur définit automatiquement l'alignement du type à la Un plus grand alignement qui est jamais utilisé pour tout type de données sur la machine cible que vous compilez. Cela peut souvent faire fonctionner des opérations de copie plus efficaces, car le compilateur peut utiliser quelles que soient les instructions copient les plus gros morceaux de la mémoire lors de la réalisation de copies vers ou à partir de variables qui ont des types que vous avez alignés de cette manière
@cenauroian_slug fwiw, à partir de maintenant,
libstdc ++ est pas pasattribut (aligné) surstd :: Array .