Je cherche à faire un changement lourd sur les modèles dans l'un de mes projets OpenGL, principalement pour le plaisir et l'expérience d'apprentissage. Je prévois de regarder la taille de l'exécutable avec soin comme je le fais, de voir à quel point le gonfleur notoire se produit. Actuellement, la taille de ma version de la version est d'environ 580 kb lorsque je favorise la vitesse et 440 Ko lorsque je privilégie la taille.
Oui, c'est un projet minuscule et, même si mon exécutable gonfle 10 x sa taille, il va toujours être de 5 Mo, ce qui semble à peine grandement grand par les normes d'aujourd'hui ... ou est-ce? Cela m'amène à ma question. La vitesse est-elle proportionnelle à la taille ou y a-t-il des sauts et des plateaux à certains seuils, seuils que je devrais visant à rester en dessous? (Et si oui, quels sont les seuils spécifiquement?)
10 Réponses :
La vitesse est basée sur de nombreux facteurs. C'est pourquoi il est bon d'avoir une conception de programme sensible qui suit de bonnes principes d'architecture.
Mais la taille réelle de votre exécutable a peu à voir avec ses performances, si l'application est conçue correctement . Les améliorations de performance que vous obtenez en profilant votre application et la fixation des pièces lentes ne feront qu'aucun affecter une partie petite (10% ou moins) de votre code.
À un moment donné (à moins que le programme ne soit parallèle embarrassant, ou que les sections critiques de votre code de votre code soient assez grandes), seul un minuscule bit de code s'exécute dans le processeur de toute façon.
Ceci est particulièrement vrai du cache L1. En principe, un grand programme exécutera plus lentement qu'un petit, mais dans la pratique, le code critique de la performance devrait rester dans le cache L1 si vous conservez vos sections critiques de performance.
N'oubliez pas que une boucle à haute performance serrée ne doit que se charger dans le cache L1 une fois , la première fois par une boucle.
Je n'ai pas remarqué une grosse corrélation entre la taille de mes projets OpenGL et de mes performances, mais je n'ai jamais vraiment pris un projet énorme non plus. L'écriture du code efficace est ce qui est plus important. Qu'essayez-vous de faire? Quelle est l'importance du gain supplémentaire de la performance de votre application? Concentrez-vous sur l'écriture d'un bon code et vous devriez aller bien. Essayez les modèles comme une expérience d'apprentissage à coup sûr, faites des commits réguliers afin que vous puissiez toujours revenir en arrière.
En pratique, l'exécution globale dépend généralement des algorithmes que vous utilisez.
En cas de taille exécutable, vous trouverez une vitesse pour avoir une relation avec la taille du cache d'instructions CPU et la longueur d'une ligne de cache donnée. Lorsque vous sortez d'un niveau de cache dans le prochain cache inférieur, vous remarquerez une plus grande latence. Cependant, il s'agit du travail du compilateur d'optimiser et d'organiser le code afin que vous exécuterez généralement linéairement (si possible).
Vous ne devez pas régler à des CPU spécifiques, à moins que vous n'êtes pas attendu à votre logiciel ne fonctionne que sur une machine. Pour une vitesse maximale dans le cas général, une bonne conception, une bonne sélection d'algorithmes et un bon réglage du compilateur feront plus que la taille exécutable.
BLOAT est plus lié à la quantité de votre programme en même temps que la taille de l'exécutable.
Un exemple simple et direct à cela est: dites que j'ai un programme qui renvoie les 1 000 000 premiers prix. Je peux calculer qu'avec une fonction, ou je ne peux que le disque dur qui liste comme une chaîne et imprimer cette chaîne. Ce dernier programme est beaucoup plus grand, mais prend beaucoup moins de ressources pour produire cette liste.
«Ballonné» signifie simplement que cela enlève beaucoup de ressources d'autres programmes, car il oblige trop de processus et de threads en mémoire. Généralement, votre système d'exploitation distribue simplement ces processus, cela peut également signifier qu'il "calcule tout le temps", donc un très petit programme qui prendrait des jours pour calculer une très grande liste de nombres premiers est en vigueur d'un "BLOQUE" car il calcule tout le temps.
-1. Le code de code concerne la taille de code, pas sur le temps de la CPU ou le nombre de threads exécutant.
sur la plupart des processeurs modernes, la localité sera plus important que la taille. Si vous pouvez conserver tout le code exécutant actuellement et une bonne partie des données de votre cache L1, vous allez voir de grandes victoires. Si vous sautez tout autour, vous pouvez forcer le code ou les données du cache, puis le besoin à nouveau de nouveau après.
"Conception orientée Données" aide à la fois avec le code et la localité de données, dans mon expérience. Vous pouvez être intéressé par le pièges de glissières de programmation orientées objet (PDF) ( reflété ici (pdf) ), qui fait un Bon travail de montrer comment s'attaquer à des choses de manière à ce que vous obtenez de bonnes données et de la localité de code.
(Incidemment, cette taille de cache et la localité est l'une des raisons pour lesquelles "Optimiser la taille" peut surperformer "Optimiser la vitesse" dans certains cas.)
Le lien est cassé, redirige vers le rdwest.playstation.com et je n'ai pas pu trouver l'article dans les articles section.
@Garan merci pour le commentaire; J'ai ajouté un lien de miroir pour l'instant.
La taille de votre exécutable n'a pas d'importance. C'est la taille du code "actif", le code qui est réellement exécuté fréquemment par l'application, qui compte. C'est beaucoup plus difficile à quantifier, malheureusement. Pour une approximation simple, vous pouvez profiler votre application, prendre les procédures qui représentent 90% de l'heure d'exécution et additionnent leurs tailles de code.
La plupart des processeurs modernes disposent de caches d'instructions de 64 Ko ou de 128 Ko. Il aide donc à garder le code actif sous cette taille. Le seuil suivant serait la taille de L2, qui peut être quelques mégaoctets.
exécutable "BLOAT" a moins d'incidence sur la performance que les deux facteurs suivants (qui sont liés, mais pas les mêmes)
La quantité de code que votre programme doit fonctionner pour effectuer une unité de travail, par exemple, une trame d'un cadre, affectera le taux de frappe de cache d'instructions et le taux de frappe de la page. Toutefois, si 90% des travaux sont effectués dans une petite fonction qui convient parfaitement à I-cache, la taille du programme dans son ensemble ne tiendra compte que des 10% d'autres.
De même avec les données, si votre programme doit toucher 100 Mo de données chaque image, cela va fonctionner beaucoup pire qu'un programme avec un ensemble de travail qui convient à la cache L1, L2 ou L3.
Donc, ce n'est pas vraiment la taille de l'exécutable, mais combien de choses "choses" sont utilisées à la fois.
Il est également important de considérer que la localité de ces ensembles de travail; Les petits ensembles de travail distribués de loin et large peuvent être plus lents qu'un gigantesque morceau de "chose" qui peut être traité dans un seul coup.
C'est mon humble opinion que, en gros, "glaçons de modèle" est le bogeyman de C ++; C'est-à-dire que c'est une histoire racontée d'effrayer les enfants, mais je n'ai jamais vu de preuves qu'il existe vraiment sur une échelle notable (au-delà du gonflement spécifique au compilateur, bien sûr). Les personnes affirmeront qu'il existe une base de code unique générée pour tout ensemble de paramètres de modèle, mais ils ne parviennent souvent pas à mentionner que sans modèles, vous feriez de toute façon une duplication de code (à la main ou avec des macros).
Cela dit, les modèles peuvent être hors de contrôle d'une autre manière; Par exemple, des techniques de métaprogramming peuvent des temps de compilation de ballon. Mais je pense que les avantages l'emportent vraiment sur les coûts.
Si vous êtes sur un système Unix, vous pouvez exécuter votre programme dans l'outil Cachegrind de Valgrind pour mesurer directement l'effet de la taille et de la localité de l'exécutable sur votre programme d'exécution de votre programme, plutôt que de devoir essayer de travailler en arrière à partir des numéros d'exécution. Cachegrind vous donne également beaucoup d'informations sur la localité de données.
Invocation ressemble à quelque chose comme Il y a aussi une belle interface graphique QT pour la Suite Valgrind appelée Kcachegrind . Valgrind --Tool = Cachegrind ./Your_program arguments . .
Dans mon expérience, le code de code et de l'exécution de l'exécution vont de pair à la main et il s'agit de la manière dont le logiciel est conçu, en particulier, la manière dont la structure de données est conçue.
Si on suit l'approche que chaque concept mental devient une classe, si l'on suit le modèle de style de notification dans lequel il suffit de définir une propriété ou d'ajouter un élément à une collection, peut entraîner un effet d'ondulation caché des actions prophangant dans une Grand réseau de structures de données non normalisées afin d'essayer de le garder cohérent, le résultat sera un code source important et une mauvaise performance.
D'autre part, si l'on essaie de minimiser la structure de données et de le conserver normalisé (autant que possible), si dans une mesure raisonnable, une incohérence dans la structure de données peut être tolérée et réparée sur une base couplée de manière lâche, et si la génération de code peut être utilisée de manière à ce que le programme ne traite pas d'informations au moment de l'exécution qui change presque jamais changé et aurait pu être traitée avant la compilation, le code source sera plus petit, facilement développé et efficace.
voici Un petit exemple où une conception raisonnablement conçue Le programme, à travers une série d'étapes, a été réduit de la taille d'un facteur de quatre, et fait plus rapidement d'un facteur de 40, en éliminant la structure de données et en utilisant la génération de code.