Comment savoir si mon "use module" est obsolette .

Bonjour,
J’ai une question sur l’utilisation des modules en Fortran.
Pour utiliser un module, il faut inclure en tout début de son fichier l’instruction :

Code:

---

1 2 3

USE MODULE_1 USE MODULE_2 USE MODULE_etc…

---

Mon soucis vient du fait que avec toutes les évolutions qui ont été faites, certain appels à des modules sont devenu inutile. Ce n’est pas très ennuyeux parce que ça ne gène pas la compilation et l’exécution de mon code. Néanmoins, ce n’est pas très « propre ».
Mon code contient plusieur centaines de fichiers, et il serait très long de contrôler « à la main » si l’appel de chaque module est justifié ou non
(par exemple en commentant la ligne contenant l’appel au module et en relançant une compilation et une exécution).
Est-ce que à la connaissance de quelqu’un, il existerait une option de compilation, ou un outil de contrôle qui me permettrait de savoir si tel ou tel module est effectivement appelé à propos.

merci beaucoup pour ceux qui pourront être tenté de m’éclairer.

Salut,
Je suis pas du tout fan des modules, mais je sais que si tu compile comme ceci :

Citation:

---

gfortran -Wall *.f90

---

Il te dis quand tu fais un truc qui sert à rien.
Quand je l'utilise, il me dis quand mes tableaux sont mal déclarer même si cela fonctionne, et quand je déclare des trucs qui ne sont pas utilisé dans une subroutine ou autre. Si ça peut servir essaye !

Bonjour,

Citation:

---

Envoyé par Le_Boucher

Il te dis quand tu fais un truc qui sert à rien.

---

A ma connaissance, -Wall ne donnera pas d'information sur des variables/routines de modules non utilisées.

Le fond du problème de Wire.Less vient du fait que les modules sont inclus "en vrac" c.-à-d: avec

Code:

---

use module_1

---

alors que si on travaille proprement, on utilise

Code:

---

use module_1, only: ...

---

en mentionnant explicitement après le "only" les éléments (variables ou fonctions/routines) du module à utiliser... A partir de là, la maintenance du code suite aux évolutions est bien plus simple.

Pour en revenir à la question initiale, je ne connais pas d'outils qui irait automatiquement faire le tri pour déterminer quel module est effectivement chargé, mais il me semble qu'il suffit juste qu'un peu de méthode, comme par exemple:
- remplacer (temporairement) "module_X" par un "module_X" vide et lancer une recompilation de tout le code. Si il n'y a pas d'erreurs alors "module_X" était effectivement inutilisé et peut être supprimé.
- dans le cas ou ces modules contiennent une routines, e.g. "maroutine", on peut aussi imaginer faire une recherche textuelle (par exemple en utilisant l’utilitaire "grep" sous Linux) pour "maroutine" dans l'ensemble des fichiers sources; on voit très vite au résultat si elle est appelée quelque part ou pas.

Bon courage.

Il y a très longtemps, bien avant l'apparition des modules, j'utilisais une option de compilation qui me générait un "Symbols Cross Reference", soit la liste de toutes les variables, fonctions et subroutines avec les lignes dans lesquels elles apparaissaient.

Peut-être qu'une version moderne de cette liste indiquerait le module dans lequel la ressource est définie, s'il y a lieu.

Merci à tous pour votre contribution.
Je comprends qu'il n'y a pas de solution magique pour répondre à mon problème.
Je vais donc tester tous mes à modules pour vérifier s'ils sont ou non pertinent.

Je passes donc également mon fils de discussion en résolu :-*

Si tu lis l'anglais, vas voir la discussion https://software.intel.com/en-us/for...s/topic/282977

Ça ne donne pas la réponse, mais peut-être une piste.