Il y a quelques années, j’ai été affecté à l’école où je devais paralléliser un Raytracer.
C’était une tâche facile, et j’ai vraiment aimé travailler dessus.

Aujourd’hui, j’avais envie de profiler le traceur de rayons pour voir si je pouvais le faire fonctionner plus rapidement (sans refondre complètement le code). Lors du profilage, j’ai remarqué quelque chose d’intéressant:

// Sphere.Intersect public bool Intersect(Ray ray, Intersection hit) { double a = ray.Dir.x * ray.Dir.x + ray.Dir.y * ray.Dir.y + ray.Dir.z * ray.Dir.z; double b = 2 * (ray.Dir.x * (ray.Pos.x - Center.x) + ray.Dir.y * (ray.Pos.y - Center.y) + ray.Dir.z * (ray.Pos.z - Center.z)); double c = (ray.Pos.x - Center.x) * (ray.Pos.x - Center.x) + (ray.Pos.y - Center.y) * (ray.Pos.y - Center.y) + (ray.Pos.z - Center.z) * (ray.Pos.z - Center.z) - Radius * Radius; // more stuff here } 

Selon le profileur, 25% du temps processeur a été consacré à get_Dir et à get_Pos . C’est pourquoi j’ai décidé d’optimiser le code de la manière suivante:

  // Sphere.Intersect public bool Intersect(Ray ray, Intersection hit) { Vector3d dir = ray.Dir, pos = ray.Pos; double xDir = dir.x, yDir = dir.y, zDir = dir.z, xPos = pos.x, yPos = pos.y, zPos = pos.z, xCen = Center.x, yCen = Center.y, zCen = Center.z; double a = xDir * xDir + yDir * yDir + zDir * zDir; double b = 2 * (xDir * (xPos - xCen) + yDir * (yPos - yCen) + zDir * (zPos - zCen)); double c = (xPos - xCen) * (xPos - xCen) + (yPos - yCen) * (yPos - yCen) + (zPos - zCen) * (zPos - zCen) - Radius * Radius; // more stuff here } 

Avec des résultats étonnants.

• Comment utiliser l’argument de script CSI.exe
• Où puis-je télécharger l’outil PEVerify.exe?
• C # Lambdas et “this” variable scope
• Comment obtenir un constructeur en tant que MethodInfo en utilisant Reflection
• MemoryCache avec les régions en charge?

Dans le code d’origine, exécuter Raytracer avec ses arguments par défaut (créer une image 1024×1024 avec seulement l’éclairage direct et sans AA) prendrait environ 88 secondes .
Dans le code modifié, la même chose prendrait un peu moins de 60 secondes .
J’ai réalisé une accélération de ~ 1,5 avec seulement cette petite modification du code.

Au début, je pensais que le getter pour Ray.Dir et Ray.Pos faisait des choses en arrière-plan, qui ralentiraient le programme.

Voici les getters pour les deux:

  public Vector3d Pos { get { return _pos; } } public Vector3d Dir { get { return _dir; } } 

Donc, les deux renvoient un Vector3D, et c’est tout.

Je me demande vraiment comment il serait plus long d’appeler le getter que d’accéder directement à la variable.

Est-ce à cause des variables de mise en cache de la CPU? Ou peut-être que la surcharge d’appeler ces méthodes à plusieurs resockets s’est additionnée? Ou peut-être le JIT traitant le dernier cas mieux que le premier? Ou peut-être qu’il y a quelque chose d’autre que je ne vois pas?

Toute idée serait grandement appréciée.

Modifier:

Comme @MatthewWatson l’a suggéré, j’ai utilisé un StopWatch pour libérer les StopWatch de libération en dehors du débogueur. Afin de supprimer le bruit, j’ai exécuté les tests plusieurs fois. En conséquence, le premier code prend environ 21 secondes (entre 20,7 et 20,9), tandis que le dernier ne prend que 19 secondes (entre 19 et 19,2).
La différence est devenue négligeable, mais elle existe toujours.

• ASP.NET: Obtenez des millisecondes depuis le 1/1/1970
• Est-il utile en C # d’appliquer le théorème de DeMorgan pour optimiser manuellement les expressions booléennes dans des instructions conditionnelles (par exemple, des conditions)?
• Délégué C # pour le rappel C ++
• Comment puis-je obtenir un type de vecteur en C #?
• Chaînes de connexion Entity Framework Core 1.0