Efficacité des boucles écrites manuellement par rapport aux surcharges d'opérateur

Question

dans le programme sur lequel je travaille J'ai des tableaux à 3 éléments, que j'utilise comme vecteurs mathématiques à toutes fins pratiques.

Tout au long de l'écriture de mon code, je suis tenté de simplement rouler ma propre Vector classe avec des surcharges arithmétiques simples (+, -, * /) donc je peux simplifier les déclarations comme:

// old: 
for (int i = 0; i < 3; i++) 
    r[i] = r1[i] - r2[i]; 

// new: 
r = r1 - r2; 

qui devrait être plus ou moins identiques dans le code généré. Mais quand il s'agit de choses plus compliquées, est-ce que cela pourrait vraiment affecter ma performance? Un exemple que j'ai dans mon code est le suivant:

Version manuelle écrite:

for (int j = 0; j < 3; j++) 
{ 
    p.vel[j] = p.oldVel[j] + (p.oldAcc[j] + p.acc[j]) * dt2 + (p.oldJerk[j] - p.jerk[j]) * dt12; 
    p.pos[j] = p.oldPos[j] + (p.oldVel[j] + p.vel[j]) * dt2 + (p.oldAcc[j] - p.acc[j]) * dt12; 
} 

Utilisation de la Vector classe avec surcharge opérateur:

p.vel = p.oldVel + (p.oldAcc + p.acc) * dt2 + (p.oldJerk - p.jerk) * dt12; 
p.pos = p.oldPos + (p.oldVel + p.vel) * dt2 + (p.oldAcc - p.acc) * dt12; 

Je cherche à optimiser mon code pour la vitesse , puisque ce genre de code s'exécute à l'intérieur des boucles internes. Est-ce que l'utilisation des opérateurs surchargés pour ces choses affectera les performances? Je fais une intégration numérique d'un système de n corps mutuellement gravitaires. Ces opérations vectorielles sont extrêmement courantes, il est donc important d'avoir une exécution rapide.

Toute idée serait appréciée, comme le feraient tous les idiomes ou astuces que je ne connais pas.

Answer 1

Si les opérations sont bien intégrées et optimisées par votre compilateur, vous ne devriez généralement pas voir de différence entre l'écriture correcte du code (en utilisant des opérateurs pour le rendre lisible et maintenable) et manuellement tout. Manuel inlining augmente également considérablement le risque de bogues, car vous ne réutiliserez pas un seul morceau de code bien testé, vous écrivez le même code encore et encore. Je recommande d'écrire le code avec les opérateurs, puis si vous pouvez prouver que vous pouvez l'accélérer en insérant manuellement, dupliquer le code et manuellement en ligne la deuxième version. Ensuite, vous pouvez exécuter les deux variantes du code les unes contre les autres pour prouver (a) que le mode manuel est efficace, et (b) que le code lisible et manuellement introduit le même résultat. Cependant, avant de commencer manuellement, il existe un moyen simple de répondre à votre question: Écrivez quelques cas de test simples dans les deux sens, puis exécutez quelques millions d'itérations et voyez quelle approche s'exécute plus rapidement. Cela vous apprendra beaucoup sur ce qui se passe et vous donnera une réponse précise pour votre implémentation particulière et compilateur que vous n'obtiendrez jamais des réponses théoriques que vous recevrez ici.

Answer 2

Je voudrais regarder dans l'autre sens; en commençant par la classe Vector, et si vous rencontrez des problèmes de performances avec cela, vous pouvez voir si l'introduction manuelle des calculs est plus rapide. En plus des performances, vous mentionnez également que les calculs doivent être précis. Avoir les calculs spécifiques au vecteur dans une classe signifie qu'il est plus facile de les tester individuellement, et aussi que le code utilisant la classe devient plus court et plus facile à maintenir.

Answer 3

Découvrez les exemples de code ConCRT

http://code.msdn.microsoft.com/concrtextras/Release/ProjectReleases.aspx?ReleaseId=4270

Il y a un couple (y compris un échantillon Nbody) qui font un tas de trucs comme ça avec les types vecteur et modèles, etc.