Discussion :

[Seabirds]

Hello!

Je suis sur ma première opération de refactoring d'un code pas-à-moi! C'est super intéressant, mais je ne suis pas certain d'utiliser les bons outils.

Par exemple, le codeur (un physicien) a largement copié collé et dupliqué son code sur des millier et des milliers de lignes. Ca donne des choses comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
                          MPI_Send(&save_x_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
                          MPI_Send(&save_y_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
                          MPI_Send(&save_z_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
 
                          MPI_Send(&save_vx_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
                          MPI_Send(&save_vy_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
                          MPI_Send(&save_vz_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
 
                          MPI_Send(&save_ax_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
                          MPI_Send(&save_ay_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);
                          MPI_Send(&save_az_i2cg_INRTL[ii][eee][ispan_constellation], 1, MPI_DOUBLE, ccc, iProc, MPI_COMM_WORLD);

Souvent il y a des comportements entiers (sur plusieurs dizaines de lignes) qui au lieu d'avoir été extraits en méthodes, ont été copié collé dans la même fonction en changeant le nom d'une variable.
Du coup j'essaie d'identifier les portions de code qui ont la plus forte priorité en terme de refactoring, c'est à dire trouver les redondances qui maximisent la longueur du pattern répété et le nombre de répétitions.
Existe-t-il un outil qui fait ça ou bien je dois scroller à travers tout le code manuellement ?

Merci !

[bacelar]

Je trouve votre métrique d’efficacité assez spéciale.
En général, le but d'un refactoring est de combler une dette technique et d'améliorer la maintenance et l'évolutivité.
C'est donc une chose qu'on doit faire de manière "globale" et non simplement réduire le nombre de ligne "redondante".

Pour votre exemple, le code n'utilise pas le bon niveau d'abstraction et il faut juste concevoir un module intermédiaire qui simplifie l'utilisation de "MPI_Send" de manière cohérente.
Donc, je conçois un module cohérent avec un modèle d'usage, qui n'a que peu de lien avec l'utilisation actuelle de "MPI_Send" car il doit simplifier le "vieux" code mais surtout être facile d'usage aussi pour les besoins futurs.

Une fois ce module bien conçu et implémenté, vous coupez la possibilité au vieux code d'utiliser l'API de bas niveau ( ici "MPI_Send") et vous corrigez les erreurs en utilisant le nouveau module qui fera son oeuvre : simplification des codes utilisateurs existant et facilitation de l'évolution de ce nouveau code.

Le bon paramètre, c'est pas la longueur en caractère du remplacement mais la "douleur" (en nombre de bugs qui ont été corrigés dans un module dû à une dette technique par exemple) ou en surcoût sur des nouveaux développement par manque de ce module supplémentaire/restructurant.

Un code "sale", long, mais qui ne génère pas de bugs ni de problème avec de évolution ne devrait pas être prioritaire.

[Mat.M]

Hello!
Existe-t-il un outil qui fait ça ou bien je dois scroller à travers tout le code manuellement ?
Merci !

dans visual studio cliquer sur la fonction que l'on veut,par exemple save_vx_i2cg_INRTL, clic droit et "chercher toutes les références" après il y a une liste qui sort
Sinon avec un simple éditeur de texte comme Notepad++ qui surligne les mots se répétant

[Seabirds]

Merci à vous deux pour vos réponses!

Bacelar, je comprends ce que tu veux dire. Mon problème est qu'il y a tellement à faire et si peu de temps que je voulais prioriser la modification qui aurait le maximum d'impact positif (et la concrètement pour ce projet, c'est diminuer le nombre de lignes - tout est "très très douloureux"!).

J'imagine que je vais juste devoir choisir un entry point et commencer par là ... :/

[ternel]

J'arrive un peu tard, mais un profiler peut donner ce type d'informations. Notamment le nombre d'appel de chaque fonction

[Seabirds]

ternel!

Ok je note cette jolie fonctionalité du profiler! Mais le problème c'est que ... il n'y a pas de fonctions Enfin si, mais elles font 5000 ou 6000+ lignes et ne sont appelées qu'une fois.
Bon en vrai j'ai fait ce que j'ai pu en 1 mois de refactoring, et puis voilà. C'est sauvage le refactoring. A la machette qu'on y va!

Bref pour ce que ça vaut, je quitte enfin l'académique et pars dans le videogame industrie de Seattle!

Arno