Quand sont les structures de la réponse?

Je suis en train de faire un raytracer projet de loisirs, et à l'origine j'ai été en utilisant les structures pour mon Vecteur et Ray objets, et j'ai pensé à un raytracer est la situation parfaite pour les utiliser: vous créer des millions d'entre eux, ils ne vivent pas plus longtemps que d'une seule méthode, ils sont légers. Cependant, en changeant simplement 'struct' à 'classe' sur le Vecteur et Ray, j'ai eu un gain de performance significatif.

Ce qui donne? Ils sont tous les deux petits (3 flotteurs pour les Vecteurs 2 Vecteurs pour les Rayons), de ne pas avoir copié autour de trop. Je ne les transmettre à des méthodes si nécessaire bien sûr, mais c'est inévitable. Alors, quelles sont les erreurs les plus communes que tuer des performances lors de l'utilisation de structures? J'ai lu cette article MSDN qui dit la chose suivante:

Lorsque vous exécutez cet exemple, vous verrez que la structure de la boucle est un ordre de grandeur plus rapide. Cependant, il est important de se méfier de l'utilisation de ValueTypes lorsque vous les traiter comme des objets. Cela ajoute plus de boxing et unboxing surcharge de votre programme, et peut finir par vous coûter plus que ce qu'il aurait fait si vous aviez coincé avec des objets! Pour le voir en action, modifiez le code ci-dessus pour utiliser un tableau de foos et des bars. Vous verrez que la performance est plus ou moins égale.

Il est cependant assez ancien (2001) et de l'ensemble "les mettre dans un tableau les causes boxing/unboxing" m'a frappé comme étrange. Est-ce vrai? Cependant, je n'ai pré-calculer la primaire de rayons et de les mettre dans un tableau, j'ai pris sur cet article et calculé la primaire ray quand j'en avais besoin et jamais ajouté à un tableau, mais ça n'a rien changé: les classes, il était encore 1,5 x plus rapide.

Je suis en cours d'exécution .NET 3.5 SP1 qui, je crois, correction d'un problème où struct méthodes n'étaient pas toujours en-alignés, donc ça ne peut pas être non plus.

Donc en gros: des conseils, des choses à considérer et comment l'éviter?

EDIT: Comme l'a suggéré dans certaines réponses, j'ai mis en place un projet de test où j'ai essayé en passant des structures comme la réf. Les méthodes pour l'ajout de deux Vecteurs:

public static VectorStruct Add(VectorStruct v1, VectorStruct v2)
{
  return new VectorStruct(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);
}

public static VectorStruct Add(ref VectorStruct v1, ref VectorStruct v2)
{
  return new VectorStruct(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);
}

public static void Add(ref VectorStruct v1, ref VectorStruct v2, out VectorStruct v3)
{
  v3 = new VectorStruct(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);
}

Pour chaque j'ai eu une variation de la suite de méthode de référence:

VectorStruct StructTest()
{
  Stopwatch sw = new Stopwatch();
  sw.Start();
  var v2 = new VectorStruct(0, 0, 0);
  for (int i = 0; i < 100000000; i++)
  {
    var v0 = new VectorStruct(i, i, i);
    var v1 = new VectorStruct(i, i, i);
    v2 = VectorStruct.Add(ref v0, ref v1);
  }
  sw.Stop();
  Console.WriteLine(sw.Elapsed.ToString());
  return v2; //To make sure v2 doesn't get optimized away because it's unused. 
}

Tous semblent effectuer à peu près identiques. Est-il possible qu'ils soient optimisés par le JIT à ce qui est le meilleur moyen de passer cette structure?

EDIT2: je dois notons au passage que l'utilisation de structures dans mon projet de test est environ 50% plus rapide que l'utilisation d'une classe. Pourquoi est-ce différent pour mon raytracer je ne sais pas.

  • Bonne chance avec le projet, d'un lancer de rayons est quelque chose que je vais attaquer bientôt.
  • Voir aussi stackoverflow.com/questions/521298/when-to-use-struct-in-c/... (surtout ma réponse là 🙂 )
  • La création d'un raytracer est un beaucoup de plaisir. Je trouve cela fascinant, vous pouvez créer une image à partir de rien de plus qu'un tas de chars et relativement simple vecteur de mathématiques.
  • Je ne pense pas que l'article dit que le fait de mettre les structures dans un tableau des causes de la boxe. Elle a averti que l'utilisation dans des endroits où les objets sont attendus cause de boxe; par exemple, si vous passez à une méthode attend un argument de type object.
  • double possible de Quand utiliser struct en C#?
InformationsquelleAutor JulianR | 2009-02-28
  1. 6

    Fondamentalement, ne pas les faire trop gros, et de les transmettre autour de par réf quand vous le pouvez. J'ai découvert ce exactement de la même manière... En changeant mon Vecteur et Ray classes de structures.

    Avec plus de mémoire étant passé autour, il est lié à provoquer cache raclée.

    • Je pensais que les types de valeur ont été en boîte lorsque vous passent par-ref?
    • Non, pas du tout. Il transmet simplement un pointeur, je crois. Pour les petites méthodes, par exemple, plus simple et ray-interesection tests, le coût de déréférencement du pointeur est moins que le coût de la copie de la mémoire.
    • Intéressant, en passant par la réf de tuer tous mes jolies surcharge d'opérateur et le code élégant. Je vais essayer de l'indice de référence de l'.
    • Le passage par référence? Le point d'avoir une structure est qu'elle est tellement petite qu'il est plus efficace de le copier que d'avoir la surcharge d'une référence...
    • De mon expérience, les passant en ref a ralentir les choses.
    • Necromancing ce que j'ai grandi un peu plus expérimenté depuis que j'ai posé cette. Dans une réécriture de lancer de rayons, en passant tous struct par référence était en effet beaucoup plus rapide. Mais ouais, il a vraiment faire de mon code très laid. Petit mathématique bordée d'états transformé en 5 bordée de blocs de Vector3.Ajouter/Soustraire/Multiplier/etc et j'ai dû recourir à un grand nombre de champs publics parce qu'une propriété ne peut pas être transmis par ref (sens, c'est une méthode, après tout). Il est vraiment rapide maintenant si, en temps réel des flux d'images en scènes.
    • Dans de nombreux cas, la "bonne" façon de déplacer des informations autour de est de passer par les structures réf. Si on peut éviter de la transmettre ou de la copie de leurs structures, en valeur, dans tous les cas où l'on n'a pas besoin d'avoir une copie indépendante, de grandes structures qui peuvent tout aussi bien que les petits. Le seul problème avec cette approche est que, dans certains contextes, le système va insister sur la défensive copies de structures (par exemple, lors de l'appel d'un membre de la méthode sur un struct dans un readonly emplacement de stockage). Les Classes peuvent avoir des avantages dans certains contextes, mais lorsque ces avantages ne sont pas nécessaires, les structures passés par référence à gagner.
    • Les structures sont emballés lorsqu'ils sont stockés en tant que stand-alone tas d'objets qui doivent continuer à exister en dehors du contexte du code ou de l'objet, qui est de les utiliser. Chaque stand-alone tas d'objet doit avoir le type d'informations stockées avec elle, car il peut n'être rien d'autre qui identifie son type. En revanche, si l'on a par exemple une variable de type Rectangle, le code qui utilise cette variable sais que c'est un Rectangle; de même, si une classe a un champ de ce type, le code qui utilise ce champ de savoir de quel type il est. Le passage d'un struct comme List<int>.Enumerator de code...
    • ...qui s'attend à une IEnumerator<int> va boîte, parce que le code qui est à l'aide de l'agent recenseur ne serait pas autrement avons aucun moyen de savoir que la chose qu'il a été donné était un List<int>.Enumerator. Si, au contraire, on devait écrire une méthode comme void UseEnumerator<T>(ref T theEnumerator) where T:IEnumerator<int> et l'a appelé avec un List<int>.Enumerator, le système permettrait de générer une version spéciale de UseEnumerator<List<int>.Enumerator(), qui pouvait savoir que son paramètre est de type exact; étant donné que le code serait de connaître le type exact, pas de boxe serait nécessaire.

    InformationsquelleAutor TraumaPony
  2. 26

    Un tableau de struct serait une seule et unique structure contiguë en mémoire, bien que les éléments d'un tableau d'objets (instances de types de référence) doivent être adressés individuellement par un pointeur (c'est à dire une référence à un objet sur les déchets collectés sur le tas). Donc si vous vous adressez à de grandes collections d'éléments à la fois, des structs vous donnera un gain de performance, car ils ont besoin de moins de indirections. En outre, les structures ne peuvent pas être héritée, ce qui pourrait permettre au compilateur de faire des optimisations supplémentaires (mais ce n'est qu'une possibilité et dépend du compilateur).

    Cependant, les structures très différentes d'attribution de la sémantique et aussi ne peut pas être héritée. Par conséquent, je l'habitude d'éviter les structs, sauf pour des raisons de performances en cas de besoin.

    struct

    Un tableau de valeurs v codée par un struct (valeur type) ressemble à ceci en mémoire:

    vvvv

    classe

    Un tableau de valeurs v codée par une classe (type de référence) ressembler à ceci:

    pppp

    ..v..v...v. v..

    où p est la ce des pointeurs ou des références, qui pointent vers les valeurs réelles v sur le tas. Les points indiquent d'autres objets qui peuvent être intercalés sur le tas. Dans le cas de types de référence, vous devez référence v via la p correspondante, dans le cas de types de valeur, vous pouvez obtenir la valeur directement via son décalage dans le tableau.

    • Aussi, d'ailleurs superflu d'indirection, linéaire de la traversée de vvvv est cache-friendly, tandis que les linéaires de la traversée de ..v..v...v. v.. ne l'est pas. Le matériel moderne n'mémoire reqeuests de 64 octets morceaux. Même si vous souhaitez charger des 8 octets de certains emplacement de mémoire de 64 octets serait transféré et mis en cache au niveau du PROCESSEUR - c'est à dire qu'il serait seulement 8/64=0.125 charge utile.
    • Avez-vous une source pour les tableaux de structures de travail comme vous le décrivez? (Je sais qu'ils sont des types de valeur, mais peut-être le tableau stocke les références à ces types de valeur?)
    InformationsquelleAutor ILoveFortran
  3. 11

    Dans les recommandations pour l'utilisation d'un struct il dit qu'il ne devrait pas être de plus de 16 octets. Votre Vecteur est de 12 octets, ce qui est proche de la limite. Le Rayon a deux Vecteurs, le mettant au 24 octets, ce qui est clairement au-dessus de la limite recommandée.

    Quand une structure est importante, plus de 16 octets, il ne peut plus être copiées de manière efficace avec un seul ensemble d'instructions, au lieu d'une boucle est utilisée. Donc, par passage de cette "magie" de la limite, vous êtes vraiment faire beaucoup plus de travail quand vous passez une struct que lorsque vous passez une référence à un objet. C'est pourquoi le code est plus rapide avec des classes eventhough il n'y a plus de surcharge lors de l'attribution des objets.

    Le Vecteur peut encore être un struct, mais le Rayon est tout simplement trop grand pour une struct.

    • Je vois, ne connaissait pas les 16 octets limite a été une dure limite, la pensée de cela plus comme une ligne directrice. Cependant, le plus drôle, c'est que le fait d'avoir mon Rayon struct ne ralentit pas l'application vers le bas beaucoup, même si à tous, tout en faisant de mon Vecteur d'une structure ne de la ralentir de 50%.
    • Ayant Vecteur en tant que classe et Ray comme un struct fera Ray contient deux références. Qui va travailler sizewise, mais vous pouvez obtenir quelques surprenant sémantique effets. Deux structures est ce qui met le Ray struct-dessus de la limite de taille.
    • Struct la manipulation est optimisé pour le cas où les structures de 16 octets ou moins, le rendement de 17 octets struct sera donc beaucoup plus grave que celle de 16 octets struct. D'autre part, si l'on évite de passer par les structures de la valeur (passer par ref au lieu de cela chaque fois que possible) même un 100 octets struct peut faire mieux que de 100 octets de classe.
    • Ainsi, le passage d'une structure par renvoi d'effectuer à peu près la même que la transmission d'une classe par valeur. Si vous avez réellement utilisation les données dans le scruct de classe, la classe exécuter légèrement meilleure en raison de la supplémentaire d'indirection que le passage par référence ajoute. En outre, si vous devez passer la structure par référence partout, vous êtes obligé d'écrire assez laid code.
    • L'indirection existe que l'on soit à l'aide d'une classe ou d'une structure. Si l'on a une instance de la classe pour chaque élément, les performances seront presque identiques, sauf pour le temps nécessaire pour créer les objets de la classe, et le supplément de 12 à 24 octets requis pour la classe de référence et l'objet de frais généraux. La principale différence est que si je dis someProc(ref myStruct);, la procédure sera capable de muter myStruct seulement jusqu'à ce qu'il retourne. En revanche, si une mutable objet de classe est jamais exposée à un code externe, il n'y a aucun moyen de savoir quand ce code risquent de provoquer un changement.
    InformationsquelleAutor Guffa
  4. 9

    Rien écrit au sujet de la boxing/unboxing avant .NET, les génériques peuvent être prises avec quelque chose d'un grain de sel. Générique types de collection ont supprimé la nécessité d'boxing et unboxing de types de valeur, ce qui rend l'utilisation des structures dans ces situations le plus précieux.

    Que pour vos ralentissement, nous aurions probablement besoin de voir un peu de code.

    • Pensé que quelque chose comme ça, mais je n'ai pas de tableaux d'un certain type toujours été "générique"? Ou était en int[] objet[] en interne .NET 1.0? Comme pour le code source: je ne peux pas publier la totalité du code source ici, mais je vais voir si je peux creuser quelque chose de pertinent.
    • Oui, les tableaux ont toujours été (un peu) générique.
    • Les tableaux sont "fortement typé".
    InformationsquelleAutor Erik Forbes
  5. 6

    Je pense que la clé réside dans ces deux états à partir de votre poste:

    vous créer des millions d'entre eux

    et

    Je ne les transmettre à des méthodes lorsqu'il fallait, bien sûr,

    Maintenant, à moins que votre structure est inférieure ou égale à 4 octets la taille (ou 8 octets si vous êtes sur un système 64-bit) vous copiez beaucoup plus sur chaque appel de méthode, et puis si vous avez tout simplement passé à un objet de référence.

    • C'est encore plus rapide que la quantité massive de la collecte des ordures qui allait se produire...
    • Apparemment pas 🙂
    • Il ne fait aucun GC si? Si j'ai rendu une très grande image, l'utilisation de la mémoire de mon processus ne cesse de grimper indéfiniment, peut-être parce que, même à l'aide de 3 GO, j'ai encore beaucoup de mémoire et peut-être dans ce cas, le GC plutôt attend jusqu'à ce que je me suis fait monopolisant le CPU.
    • Eh bien, il devrait être GCing. Au moins, c'était le problème avec mon raytracer.
    • Lièvre: Nice
    • Je suis d'accord avec TraumaPony. J'ai eu le même problème avec un moteur de rendu 3d que j'ai écrit. Quand les choses sont utilisés et détruit en un instant, les structures vraiment faire les choses de façon plus rapide. Aussi, si vous découvrez XNA par exemple, presque tout ce que j'ai utilisé était un struct.
    • C'est vrai que si vous n'êtes pas passer ces structures à d'autres méthodes.
    • Essayer de passer ces structures par le ref et de voir ce qui se passe.
    • Profil de l'application avec un .NET Memory Profiler
    • Si l'on est de créer des millions de différentes instances, une structure offrira de meilleures performances qu'un immuable de la classe. Presque toujours. Le seul moment où les classes peuvent gagner est si la plupart des références de point d'instances qui peuvent être partagées avec d'autres références. Avoir un million de références qui se réfèrent tous à l'un des trois immuable des instances de classe est susceptible de mieux que d'avoir un million de structures qui tous "arriver" à occuper l'un des trois combinaisons de champs, mais si les millions de références serait tout point à la différence des instances de classe, rien n'est gagné par l'utilisation d'une catégorie plutôt qu'une struct.

    InformationsquelleAutor Andrew Hare
  6. 6

    La première chose que je veux le regarder pour se assurer que vous avez explicitement mise en œuvre d'égal à Égal et GetHashCode. Sinon, cela signifie que l'exécution de la mise en œuvre de chacun de ces fait du très coûteuses opérations de comparer deux struct instances (en interne, il utilise la réflexion pour déterminer chacun des champs privés et ensuite checkes pour l'égalité, ce qui provoque un important montant de l'allocation).

    En général, cependant, la meilleure chose que vous pouvez faire est d'exécuter votre code en vertu d'un générateur de profils et de voir où les parties lentes sont. Il peut être une expérience révélatrice.

    • J'ai essayé les remplacements, même si je n'ai pas utiliser n'importe quel Vecteur de Rayon ou de comparaisons, mais il n'a eu aucun effet. Bonne astuce mais, je ferai en sorte de remplacer d'égal à Égal et GetHashCode à partir de maintenant 🙂
    InformationsquelleAutor
  7. 4

    Avez-vous présenté la demande? Le profilage est la seule sûr moyen de voir où le rendement réel problème. Il y a des opérations qui sont généralement mieux/pire sur les structures, mais à moins que vous profil vous venais de deviner ce que le problème est.

    InformationsquelleAutor JaredPar
  8. 2

    Tandis que la fonctionnalité est similaire, les structures sont généralement plus efficace que de classes.
    Vous devez définir une structure, plutôt que d'une classe, si le type se comme un type de valeur qu'un type de référence.

    Plus précisément, les types de structure doit répondre à tous ces critères:

    • Logiquement représente une valeur unique
    • A une instance de taille de moins de 16 octets
    • Ne seront pas modifiés après la création
    • Ne soient pas jetés dans un type de référence
    • Je suis en désaccord avec Eric Lippert la haine d'mutable des structures. Pour être sûr, certaines limitations dans la conception de .filet de faire mutable structs moins aimables qu'ils ne le seraient autrement, mais les tableaux de mutables les structures sont souvent le bon moyen pour stocker des choses. Sur une machine 64 bits, un tableau d'un million de 8 octets structs 8 mo de RAM; un tableau d'un million d'instances d'une classe à 8 octets de champs de prendre 40 méga-octets. Même si une structure de 40 octets de données (sur le 16 octets seuil recommandé), il serait toujours couper l'utilisation de la mémoire par 50%.
    InformationsquelleAutor Gineer
  9. 0

    - Je utiliser les structures de coeur pour le paramètre d'objets, de retour de plusieurs éléments d'information à partir d'une fonction, et... rien d'autre. Ne sais pas si elle est "bonne" ou "mauvaise", mais qu'est ce que je fais.

    InformationsquelleAutor Instance Hunter
  10. 0

    Mes propres ray-traceur utilise également struct Vecteurs (mais pas de Rayons) et la modification d'un Vecteur de classe ne semble pas avoir d'impact sur les performances. Je suis actuellement à l'aide de trois doubles pour le vecteur de sorte qu'il pourrait être plus grand qu'il ne devrait l'être. Une chose à noter, cependant, et cela peut être évident, mais ce n'était pas pour moi, et qui consiste à exécuter le programme en dehors de visual studio. Même si vous choisissez de la version optimisée de construire, vous pouvez obtenir un énorme boost de vitesse si vous lancez l'exe en dehors de VS. Toute analyse comparative vous ne devriez prendre cela en considération.

    • Par curiosité, est votre type de vecteur transparente ou opaque? Exposés-structures sur le terrain, souvent plus performants que opaques. Écrit myVec.x = expr1; myVec.y = expr2; myVec.z = expr3; est apte à prendre la même quantité de temps que juste mise en place des paramètres pour un appel de constructeur. L'appel lui-même, et le temps passé dans le constructeur, représenterait pur gaspillage de frais généraux. De même, tandis que il ya des moments où la Gigue peut optimiser une propriété en lecture de myPoint.x qui lit simplement un champ de stockage _x, il existe de nombreux cas où la Gigue ne sera pas.
    • Ce que je comprends, certaines versions 32 bits de .net (au moins 2.0 et 3.x) ont été beaucoup mieux à l'optimisation des propriétés de la classe d'accès que struct l'accès à la propriété, donc passer de l'opaque structures pourraient ne pas avoir été beaucoup plus rapide que de classes, même si le rendement de la transparence des structures permettrait de souffler que de classes ou opaque des structures.
    • Mes vecteurs sont en lecture seule, le programme d'installation par le constructeur. J'ai fait beaucoup de tests de différentes implémentations et ne pouvait pas trouver quelque chose de plus rapide que cela, mais je ne me souviens pas si je l'ai testé avec la transparence des structures. Dans .NET 4 je pense que c'était, ils ont fait quelques optimisations pour les structures et l'in-lining qui ont contribué à certaines des questions que vous mentionnez. Aussi, depuis la rédaction de ma réponse, j'ai changé les rayons de structures pour un ~10% d'augmentation des performances.
    • Je serais curieux de savoir quel genre de performance que vous obtenez si vous changez d'opaque des structures à la transparence des structures. L'analyse comparative que j'ai fait suggère que, parfois, les différences sont minimes, mais parfois ils peuvent être très grandes.
    InformationsquelleAutor Morten Christiansen
  11. -1

    Si les structures sont de petite taille, et pas trop d'exister à la fois, il convient de les placer sur la pile (aussi longtemps qu'une variable locale et non pas un membre d'une classe) et non pas sur le tas, cela signifie que la GC n'a pas besoin d'être invoquée et allocation/libération de mémoire devrait être quasi instantanée.

    Lors du passage d'une structure en tant que paramètre à la fonction, la structure est copié, ce qui ne signifie pas seulement plusieurs allocations/deallocations (à partir de la pile, qui est presque instantané, mais il a encore les frais généraux), mais au-dessus de la tête du transfert des données entre les 2 exemplaires. Si vous passez par référence, ce n'est pas un problème tant que vous êtes seulement de leur dire où lire les données à partir, plutôt que de copier.

    Je ne suis pas sûr à 100%, mais je soupçonne que le retour des tableaux via un paramètre peut également vous donner un boost de vitesse, comme la mémoire sur la pile est réservé et n'a pas besoin d'être copié en tant que la pile est "déroulé" à la fin des appels de fonction.

    • J'entends souvent dire que les structures en direct sur la pile, pas sur les déchets ramassés en tas, ce n'est pas tout à fait correct. Ils ne vivent pas seuls, mais ils peuvent certainement vivre sur le tas dans le cadre d'une autre référence de type object.
    • Lors du passage d'une structure par copier pas de crédits supplémentaires sont nécessaires - le montant correspondant est réservé sur la pile avant l'appel. La copie doit encore arriver, si, c'est ce qui rend le passage des structures plus cher, pas la répartition.
    • J'ai dit qu'il DOIT être placé sur on, sous l'hypothèse qu'ils sont des variables locales (comme l'a été détaillé dans la question). Aussi, la mémoire n'a pas besoin d'être effectivement allouée à partir de la pile ainsi, c'est en fait un non-problème, mais il y a encore une légère surcharge.
    InformationsquelleAutor Grant Peters
  12. -5

    Vous pouvez également faire des structs en Nullable objets. Classes personnalisées ne seront pas en mesure de créé

    comme

    Nullable<MyCustomClass> xxx = new Nullable<MyCustomClass>

    où avec une struct est nullable

    Nullable<MyCustomStruct> xxx = new Nullable<MyCustomStruct>

    Mais vous sera (évidemment) de perdre tout votre héritage caractéristiques

    • Cette juste encapsule la structure dans une classe, donc l'invocation de la GC. Vous êtes mieux de simplement changer votre structure à une classe, que cela aurait le même effet et est sans doute un peu moins à confusion
    InformationsquelleAutor BozoJoe