doc/annexe_common.rst

   1
   2 Annexe : traitement des commons fortran et variables globales C/C++
   3 ===================================================================
   4
   5
   6 Common fortran
   7 --------------
   8
   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``.
  16
  17 .. _f1:
  18
  19
  20 ``f1.f``
  21
  22 .. include:: ./exemples/exemple11/v1/f1.f
  23    :literal:
  24
  25 .. _f2:
  26
  27
  28 ``f2.f``
  29
  30 .. include:: ./exemples/exemple11/v1/f2.f
  31    :literal:
  32
  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).
  40
  41
  42 ``common.f``
  43
  44 .. include:: ./exemples/exemple11/v1/common.f
  45    :literal:
  46
  47 .. _figcommon0:
  48
  49
  50 .. image:: images/common0.png
  51    :width: 34ex
  52    :align: center
  53
  54 .. centered::
  55    Utilisation d'un common dans un composant
  56
  57 On donne ici un exemple d'encapsulation dans C++, puis dans python (via swig) :
  58
  59
  60 ``f.hxx``
  61
  62 .. include:: ./exemples/exemple11/v1/f.hxx
  63    :literal:
  64
  65
  66 ``modf.i``
  67
  68 .. include:: ./exemples/exemple11/v1/modf.i
  69    :literal:
  70
  71 Un exemple d'utilisation :
  72
  73
  74 .. include:: ./exemples/exemple11/v1/resultats.txt
  75    :literal:
  76
  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 :
  81
  82 #. Les deux composants sont montés localement depuis un même interpréteur
  83    python :
  84
  85      .. _figcommon1:
  86
  87
  88      .. image:: images/common1.png
  89         :width: 42ex
  90         :align: center
  91
  92      .. centered::
  93         Utilisation d'un common partagé entre deux librairies - version locale
  94
  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)
  97    :
  98
  99      .. _figcommon2:
 100
 101
 102      .. image:: images/common2.png
 103         :width: 47ex
 104         :align: center
 105
 106      .. centered::
 107         Utilisation d'un common partagé entre deux librairies - version distribuée
 108
 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 :
 113
 114 #. Pour le premier composant :
 115
 116
 117    ``f1.hxx``
 118
 119    .. include:: ./exemples/exemple11/v2/f1.hxx
 120       :literal:
 121
 122
 123    ``modf1.i``
 124
 125    .. include:: ./exemples/exemple11/v2/modf1.i
 126       :literal:
 127
 128 #. Pour le second composant :
 129
 130
 131    ``f2.hxx``
 132
 133    .. include:: ./exemples/exemple11/v2/f2.hxx
 134       :literal:
 135
 136
 137    ``modf2.i``
 138
 139    .. include:: ./exemples/exemple11/v2/modf2.i
 140       :literal:
 141
 142 #. Les fonctions de lecture d'écriture du common seront incorporées  dans chaque
 143    composant.
 144
 145 Un exemple d'utilisation
 146
 147
 148 .. include:: ./exemples/exemple11/v2/resultats.txt
 149    :literal:
 150
 151 En résumé,     si un code existant comportant des commons doit être découpé en
 152 plusieurs  composants, on peut soit :
 153
 154 * modifier le code en enlevant les commons et en faisant transiter  les
 155   informations via les listes de paramètres des fonctions;
 156
 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.
 160
 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.
 165
 166
 167 Variables globales C/C++
 168 ------------------------
 169
 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.
 173