L'orientation d'objet affecte-t-elle vraiment les performances d'algorithme?
L'orientation de l'objet m'a beaucoup aidé à mettre en œuvre de nombreux algorithmes. Cependant, les langues orientées objet vous guident parfois dans une approche "directe" et je doute si cette approche est toujours une bonne chose.
OO est vraiment utile pour coder des algorithmes rapidement et facilement. Mais cela pourrait-il OOP être désavantagé pour le logiciel basé sur la performance, quelle vitesse le programme exécute-t-il?
Par exemple, stocker des nœuds de graphique dans une structure de données semble "simple" en premier lieu, mais si Node Les objets contiennent de nombreux attributs et méthodes, cela pourrait-il conduire à un algorithme lent?
En d'autres termes, de nombreuses références entre de nombreux objets différents ou de nombreuses méthodes de nombreuses classes, entraînent-elles une implémentation "lourde"?
L'orientation de l'objet peut empêcher certaines optimisations algorithmiques, en raison de l'encapsulation. Deux algorithmes peuvent fonctionner particulièrement bien ensemble, mais s'ils sont cachés derrière OO _ interfaces, la possibilité d'utiliser leur synergie est perdue.
Regardez les bibliothèques numériques. Beaucoup d'entre eux (non seulement celles écrites dans les années 60 ou 70) ne sont PAS POOP. Il y a une raison pour que les algorithmes numériques fonctionnent mieux comme un ensemble de découplé modules que comme OO hiérarchies avec interfaces et encapsulation.
Qu'est-ce qui détermine la performance?
Les principes fondamentaux: structures de données, algorithmes, architecture informatique, matériel. Plus les frais généraux.
Un OOP peut être conçu pour aligner exactement Avec le choix des structures de données et des algorithmes jugés optimaux par la théorie CS. Il aura la même caractéristique de performance que le programme optimal, plus des frais généraux. Les frais généraux peuvent généralement être minimisés.
Cependant, un programme qui est initialement Conçu avec seulement OOP Préoccupations, sans préoccuper des fondamentaux, peut être initialement sous-optimal. La sous-optimalité est parfois amovible en refactoring; parfois, ce n'est pas - nécessite une réécriture complète.
CAVEAT: La performance compte-t-elle dans des logiciels d'affaires?
Oui, mais le temps de marché (TTM) est plus important, par ordre de grandeur. Les logiciels commerciaux mettent l'accent sur l'adaptabilité du code aux règles commerciales complexes. Les mesures de performance doivent être prises tout au long du cycle de vie de développement. (Voir section: qu'est-ce que la performance optimale signifie?) Seules les améliorations commercialisables doivent être effectuées et doivent être progressivement introduites dans les versions ultérieures.
Qu'est-ce que la performance optimale signifie?
En règle générale, le problème avec la performance logicielle est que: Afin de prouver que "une version plus rapide existe", cette version plus rapide doit d'abord entrer dans l'existence (c'est-à-dire aucune preuve autre que elle-même).
Parfois, cette version plus rapide est d'abord vue dans une langue ou un paradigme différent. Cela devrait être considéré comme un indice d'amélioration et non un jugement d'infériorité de certaines autres langues ou paradigmes.
Pourquoi faisons-nous OOP si cela peut nuire à notre recherche de performances optimales?
OOP introduit les frais généraux (dans l'espace et l'exécution), en échange de l'amélioration de la "manipulation" et d'où la valeur commerciale du code. Cela réduit le coût de développement et d'optimisation ultérieurs. Voir @ Mikenakis .
Quelles parties de OOP peuvent-elles encourager une conception initialement sous-optimale?
Les parties de OOP = (i) encourage la simplicité/la intuitivité, (ii) l'utilisation de méthodes de conception familière au lieu de fondamentaux, (iii) décourage de multiples mises en œuvre sur mesure au même but.
- KISS
- Yagni
- DRY
- Conception d'objets (par exemple avec des cartes CRC) sans donner des pensées égales aux fondamentaux)
Application stricte de certains OOP Lignes directrices (encapsulation, passage de message, faire une chose bien) entraînera en effet un code plus lent au début. Les mesures de performance aideront à diagnostiquer ces problèmes. Tant que la structure de données et L'algorithme s'aligne sur la conception optimale prédite de la théorie, les frais généraux peuvent généralement être minimisés.
Quelles sont les atmosphérations communes à OOP des frais généraux?
Comme indiqué précédemment, en utilisant des structures de données optimales pour la conception.
Certaines langues prennent en charge l'allégement du code qui peut récupérer certaines performances d'exécution.
Comment pourrions-nous adopter OOP sans sacrifier la performance?
Apprenez et appliquez les deux OOP et les principes fondamentaux.
Il est vrai que l'adhérence stricte à OOP peut peut-être vous empêcher d'écrire une version plus rapide. Parfois, une version plus rapide ne peut être écrite à partir de zéro. C'est pourquoi il aide à écrire plusieurs versions du code à l'aide de différentes versions. Algorithmes et paradigmes (OOP, générique, fonctionnel, mathématique, spaghetti), puis utilisez des outils d'optimisation pour que chaque version s'approche de la performance maximale observée.
Y a-t-il des types de code qui ne bénéficieront pas d'OOP?
(Élargi de la discussion entre [@Quant_Dev], [@ SK-Logic] et [@mikenakis])
- Recettes numériques, qui proviennent de mathématiques.
- Les équations mathématiques et se transforment eux-mêmes peuvent être comprises comme des objets.
- Des techniques de transformation de code très sophistiquées sont nécessaires pour générer un code exécutable efficace. La mise en œuvre naïve ("carte blanche") aura une performance abyssale.
- Cependant, les compilateurs traditionnels d'aujourd'hui sont incapables de le faire.
- Des logiciels spécialisés (Matlab et Mathematica, etc.) ont à la fois des solvateurs JIT et symboliques capables de générer un code efficace pour certains sous-problèmes. Ces solveurs spécialisés peuvent être considérés comme des compilateurs spéciaux (médiateurs entre code lisible par l'homme et code exécutable de la machine) qui bénéficieront eux-mêmes d'un OOP conception.
- Chaque sous-problème nécessite son propre "compilateur" et "transformations de code". Il s'agit donc d'un domaine de recherche ouvert très actif avec de nouveaux résultats apparaissant chaque année.
- Étant donné que la recherche prend beaucoup de temps, les écrivains de logiciel doivent effectuer une optimisation sur papier et transcrire le code optimisé dans des logiciels. Le code transcrit pourrait bien être inintelligible.
- Code de niveau très bas.
- *
Ce n'est pas vraiment sur l'orientation des objets comme des conteneurs. Si vous avez utilisé une liste double liée pour stocker des pixels dans votre lecteur vidéo, il va souffrir.
Toutefois, si vous utilisez le conteneur correct, il n'y a aucune raison d'être un std :: Vecteur de STD :: est plus lent qu'un tableau, et puisque vous avez tous les algorithmes communs déjà écrits pour cela - par des experts - il est probablement plus rapide que votre code de matrice roulée à la maison.
Le POO est évidemment une bonne idée et comme une bonne idée de sa bonne idée. Dans mon expérience, c'est beaucoup trop utilisé. Résultat médiocre des performances et une mauvaise maintenabilité.
Cela n'a rien à voir avec les frais généraux d'appeler des fonctions virtuelles, et pas beaucoup à voir avec ce que l'optimiseur/la gigue fait.
Il a tout à voir avec les structures de données qui, tout en ayant la meilleure performance Big-O, ont de très mauvais facteurs constants. Cela se fait sur l'hypothèse selon laquelle s'il y a un problème de limitation de performance dans l'application, c'est ailleurs.
Une solution, ce manifeste est le nombre de fois par seconde nouveau est effectué, supposé avoir O(1) Les performances, mais peuvent exécuter des centaines à des milliers d'instructions (y compris la correspondance Supprimer ou Temps de GC). Vous pouvez être atténué en sauvegarde des objets utilisés, mais que rend le code moins "propre".
Une autre façon qu'il manifeste est la façon dont les gens sont encouragés à écrire des fonctions de propriété, des gestionnaires de notification, des appels vers des fonctions de classe de base, toutes sortes d'appels de fonctions souterraines qui existent pour essayer de maintenir la cohérence. Pour le maintien de la cohérence, ils ont un succès limité, mais ils réussissent énormément au gaspillage des cycles. Les programmeurs comprennent le concept de des données normalisées mais ils ont tendance à ne l'appliquer qu'à la conception de la base de données. Ils ne l'appliquent pas à la conception de la structure de données, au moins en partie parce que OOP===== Dites-leur qu'ils n'en ont pas à. Aussi simple chose que la définition d'un bit modifié dans un objet peut entraîner un tsunami. des mises à jour fonctionnant dans la structure de données, car aucune classe ne vaut son code ne prend un appel modifié et des magasins .
Peut-être que la performance d'une application donnée est tout simplement bien écrite.
D'autre part, s'il y a un problème de performance, (( Voici un exemple de la façon dont je vais le régler. C'est un processus de plusieurs étapes. À chaque étape, une activité particulière représente une grande fraction de temps et pourrait être remplacée par quelque chose de plus rapidement. (Je n'ai pas dit "goulot d'étranglement". Ce ne sont pas les types de choses que les profileurs sont bons à la recherche.) Ce processus nécessite souvent, afin d'obtenir le speed-up, le remplacement de gros de la structure de données. Souvent, cette structure de données n'est là que parce qu'elle est recommandée OOP Pratique.
En théorie, cela pourrait conduire à la lenteur, mais même à ce moment-là, ce ne serait pas un algorithme lent, ce serait une mise en œuvre lente. En pratique, l'orientation de l'objet vous permettra d'essayer différents scénarios (ou revisiter l'algorithme à l'avenir) et donc fournir algorithmique amélioration, que vous ne pourriez jamais espérer réaliser si vous l'aviez écrit la voie Spaghettis en premier lieu, car la tâche serait décourageante. (Vous devrez essentiellement réécrire le tout.)
Par exemple, en ayant divisé les différentes tâches et entités à des objets coupés à nettoyer, vous pourrez peut-être facilement venir plus tard et, par exemple, intégrer une installation de mise en cache entre certains objets (transparents pour eux), ce qui pourrait donner mille- déplier l'amélioration.
En règle générale, les types d'améliorations que vous pouvez réaliser en utilisant une langue de bas niveau (ou des astuces intelligentes avec une langue de haut niveau) donnent des améliorations de temps constantes (linéaires), qui ne figurent pas en termes de notation Big-Oh. Avec des améliorations algorithmiques, vous pourrez peut-être obtenir des améliorations non linéaires. C'est inestimable.
Oui, l'état d'esprit orienté objet peut certainement être neutre ou négatif lorsqu'il s'agit de programmation hautes performances, à la fois au niveau algorithmique et de mise en œuvre. Si OOP remplace l'analyse algorithmique, il peut vous guider dans la mise en œuvre prématurée et, au niveau le plus bas, le OOP Abstractions doit être mis de côté.
La question découle de l'accent sur la réflexion sur la réflexion sur les cas individuels. Je pense que c'est juste de dire que le OOP=== Lieu de penser à un algorithme est de penser à un ensemble de valeurs spécifique et de la mettre en œuvre de cette façon. Si c'est votre chemin de plus haut niveau, vous êtes il est peu probable de réaliser une transformation ou une restructuration qui conduirait à de grands gains.
Au niveau algorithmique, cela pense souvent à la plus grande image et aux contraintes ou relations entre les valeurs qui conduisent à de grands gains. Un exemple peut être qu'il n'ya rien dans le OOP MindSet qui vous conduirait à transformer "Sum à une gamme continue d'entiers" d'une boucle à (max + min) * n/2
Au niveau de la mise en œuvre, bien que les ordinateurs soient "assez rapides" pour la plupart des algorithmes de niveau d'application, dans le code de la performance de bas niveau, on s'inquiète beaucoup de la localité. Encore une fois, le OOP J'entend la réflexion sur une instance individuelle et que les valeurs d'un passage à travers la boucle peuvent être négatives. Dans un code performant, au lieu d'écrire une boucle simple, vous voudrez peut-être vouloir Pour dérouler partiellement la boucle, regroupez plusieurs instructions de chargement en haut, puis les transformez dans un groupe, puis écrivez-les dans un groupe. Tout le temps que vous faites attention aux calculs intermédiaires et, énormément, au cache et à l'accès à la mémoire ; questions où le OOP abstractions ne sont plus valides. Et, s'il est suivi, peut être trompeur: à ce niveau, vous devez connaître et penser aux représentations au niveau de la machine.
Lorsque vous regardez quelque chose comme des primitives de performance d'Intel, vous avez littéralement des milliers des implémentations de la transformation rapide de Fourier, chacune ajustée pour mieux fonctionner pour une architecture spécifique de taille de données et de machines. (Fascinant, il s'avère que la majeure partie de ces implémentations est générée par la machine: Programmation de performance automatique de Markus Püschel )
Bien sûr, comme la plupart des réponses ont dit, pour la plupart des réponses, pour la plupart des algorithmes, OOP est hors de propos de la performance. Tant que vous n'êtes pas "pessimiser prématuré" et d'ajouter beaucoup d'appels non locaux, le pointeur this n'est ni ici ni là.
Sa liité et souvent négligée.
Ce n'est pas une réponse facile, Son dépend de ce que vous voulez faire.
Certains algorithmes sont meilleurs dans la performance en utilisant une programmation structurée simple, tandis que d'autres sont meilleures en utilisant l'orientation de l'objet.
Avant l'orientation de l'objet, de nombreuses écoles enseignent (ed) design d'algorithme avec une programmation structurée. Aujourd'hui, de nombreuses écoles, enseignent la programmation orientée objet, ignorant l'algorithme de conception et de performance.
Bien sûr, là où les écoles qui enseignent la programmation structurée, qui ne se soucient pas du tout des algorithmes.
Performance Tout dépend de la CPU et des cycles de mémoire à la fin. Mais la différence de pourcentage entre les frais généraux de OOP messagerie et encapsulation et une programmation ouverte plus large peut être un pourcentage suffisant de manière significative pour faire une différence notable dans la performance de votre application. Si une application est le disque ou le cache-cache-mlt-Mlle, tout OOP Les frais généraux peuvent être complètement perdus dans le bruit.
Mais, dans les boucles internes du signal et du traitement de l'image en temps réel et d'autres applications liées à la calcul numérique, la différence peut être un pourcentage significatif de cycles de processeur et de mémoire, ce qui peut faire tout OOP beaucoup plus coûteux à exécuter.
La sémantique d'un fichier particulier OOP Language peut ne pas exposer suffisamment d'opportunités pour le compilateur d'optimiser ces cycles, ou pour les circuits de prévision de la succursale de la CPU afin de deviner toujours correctement et couvre ces cycles avec aller chercher et pipeler.
Un bon design orienté objet m'a aidé à accélérer considérablement une application. A a dû générer des graphiques complexes de manière algorithmique. Je l'ai fait via Microsoft Visio Automation. J'ai travaillé, mais était incroyablement lent. Heureusement, j'avais inséré un niveau d'abstraction supplémentaire entre la logique (l'algorithme) et les trucs Visio. Mon composant Visio a exposé sa fonctionnalité à travers une interface. Cela m'a permis de remplacer facilement le composant lent avec une autre création de fichiers SVG, qui était au moins 50 fois plus rapide! Sans une approche propre à orientation objet, les codes de l'algorithme et le contrôle de la vision auraient été empêtrés d'une manière, ce qui aurait transformé le changement en cauchemar.