2 Annexe : traitement des commons fortran et variables globales C/C++
3 ===================================================================
9 Cette section résulte de réflexions menées par Marc Boucker, Alexandre Douce,
10 Céline Béchaud et l'auteur (pour plus de détails, voir [COMMON]_). On ne prétend
11 pas ici présenter un état complet des situations possibles. Les codes
12 fortran 77 que l'on veut commander depuis l'interpréteur python ou depuis
13 Corba/Salomé, définissent souvent des zones mémoires partagées entre les
14 différentes fonctions fortran, appelées "common". Exemple : Les fonctions
15 ``f1`` et ``f2`` utilisent la même zone mémoire ``a`` dans le common ``C``.
22 .. include:: ./exemples/exemple11/v1/f1.f
30 .. include:: ./exemples/exemple11/v1/f2.f
33 Si les deux fonctions sont contenues dans le même composant et le common ``C``
34 n'est pas utilisé par des fonctions d'autres composants, le common n'est pas
35 visible de l'extérieur du composant et "tout se passe bien" (voir figure
36 :ref:`Utilisation d'un common dans un composant <figcommon0>`). Si le concepteur du composant veut permettre la lecture
37 et/ou l'écriture du common depuis la couche python et/ou CORBA, il pourra
38 écrire facilement des fonctions d'accès (par exemple fonctions ``setCommon`` et
39 ``getCommon`` dans l'exemple ci-après).
44 .. include:: ./exemples/exemple11/v1/common.f
50 .. image:: images/common0.png
55 Utilisation d'un common dans un composant
57 On donne ici un exemple d'encapsulation dans C++, puis dans python (via swig) :
62 .. include:: ./exemples/exemple11/v1/f.hxx
68 .. include:: ./exemples/exemple11/v1/modf.i
71 Un exemple d'utilisation :
74 .. include:: ./exemples/exemple11/v1/resultats.txt
77 Si le common ``C`` est utilisé dans plusieurs librairies dynamiques, la gestion
78 est plus délicate. De façon générale, on ne peut pas supposer que le common
79 utilisé par chacune des librairies est situé à la méme adresse mémoire. Il y
80 a deux situations types que l'on peut rencontrer :
82 #. Les deux composants sont montés localement depuis un même interpréteur
88 .. image:: images/common1.png
93 Utilisation d'un common partagé entre deux librairies - version locale
95 #. Les deux composants sont montés dans des espaces mémoire différents (sur la
96 même machine ou des machines différentes) via le mécanisme Salomé (conteneurs)
102 .. image:: images/common2.png
107 Utilisation d'un common partagé entre deux librairies - version distribuée
109 Dans les deux cas, il faut prévoir des fonctions de synchronisation (par
110 exemple en utilisant les fonctions de lecture/écriture des commons depuis la
111 couche de commande python et/ou Salomé). L'adaptation au cas des deux
112 composants locaux chargés depuis un interpréteur python s'écrit :
114 #. Pour le premier composant :
119 .. include:: ./exemples/exemple11/v2/f1.hxx
125 .. include:: ./exemples/exemple11/v2/modf1.i
128 #. Pour le second composant :
133 .. include:: ./exemples/exemple11/v2/f2.hxx
139 .. include:: ./exemples/exemple11/v2/modf2.i
142 #. Les fonctions de lecture d'écriture du common seront incorporées dans chaque
145 Un exemple d'utilisation
148 .. include:: ./exemples/exemple11/v2/resultats.txt
151 En résumé, si un code existant comportant des commons doit être découpé en
152 plusieurs composants, on peut soit :
154 * modifier le code en enlevant les commons et en faisant transiter les
155 informations via les listes de paramètres des fonctions;
157 * écrire des fonctions d'accès en lecture/écriture aux commons et utiliser ces
158 fonctions de lecture/écriture depuis les couches supérieures aux composant de
159 façon à synchroniser les état internes des différents composants.
161 La première solution demande d'intervenir en profondeur dans le code fortran,
162 la seconde exige que l'utilisateur synchronise explicitement les commons dans
163 les différents composants. En ce qui concerne les nouveaux codes fortran, on
164 déconseille vivement l'utilisation des commons.
167 Variables globales C/C++
168 ------------------------
170 La situation est analogue au cas des commons : chaque composant aura son propre
171 jeu de variables globales. Il faudra d'une façon ou d'une autre assurer la
172 cohérence de ces différents jeux de variables.