Bonjour,

Une question sur l'interopérabilité Fortran/C++, svp

J'utilise une librairie C++ dans mon code Fortran, grâce à un 'wrapping' de cette librairie qui a été généré avec SWIG-Fortran.

Ce wrapping a produit une interface qui contient tous les 'binds' nécessaires vers les méthodes C++, ainsi que les définitions des TYPES FORTRAN correspondant aux objets C++ de la librairie.

Par exemple, le wrapper a génèré cette fonction Fortran CMESH (qui est reliée à la méthode cmesh de la libriairie C++) :

function CMESH() result(swig_result)
use, intrinsic :: ISO_C_BINDING
type(SWIGTYPE_p_MEDCoupling__MEDCouplingCMesh) :: swig_result
type(SwigClassWrapper) :: fresult  
fresult = swigc_CMESH()
swig_result%swigdata = fresult
end function

! WRAPPER DECLARATIONS
interface
function swigc_CMESH() bind(C, name="_wrap_CMESH") result(fresult)
use, intrinsic :: ISO_C_BINDING
import :: swigclasswrapper
type(SwigClassWrapper) :: fresult
end function

Avec ici la fonction C, générée aussi...

extern "C" {
SWIGEXPORT SwigClassWrapper _wrap_CMESH() {
  SwigClassWrapper fresult ;
  MEDCoupling::MEDCouplingCMesh *result = 0 ; 
  
  result = (MEDCoupling::MEDCouplingCMesh *)CMESH();
  fresult.cptr = (void*)result;
  fresult.cmemflags = SWIG_MEM_RVALUE | (0 ? SWIG_MEM_OWN : 0); 
  return fresult;
}

Ce wrapping fonctionne bien et permet au code Fortran de créer des Objet et d'exploiter les méthodes de la librairie C++...

Les choses se compliquent un peu :

Ce code Fortran a par ailleurs été 'encapsulé' dans une classe C++ de type 'Singleton' : On a mis quelques 'binds' dans le code Fortran, ce qui a permis de créer une classe C++ "au dessus du Fortran" dont toutes les méthodes correspondent aux binds qu'on a mis. Cette encapsulation nous permet d'utiliser un script C++ en tant que 'main'. 

Et là, la difficulté est de faire 'remonter' vers le main C++ les Objets FORTRAN qu'on a générés avec le 'wrapper' plus haut.

Par exemple, comment partager la donnée swig_result ci-dessus avec notre 'main' script C++ ? (Sachant qu'il est facile par ailleurs de partager des entiers, des doubles, etc...avec les ISO_C_BINDINGS)

Merci d'avance pour un conseil,

Pierre

Bonjour

Je connais rien au Fortran ou a ces "swig" de C++ mais si il y'a un type de donnees que les deux langages peuvent se partager pourquoi ne pas l'utiliser. Vous avez parlé de doubles, entiers, etc. je suppose donc que les types de base sont presents, mettre la donnee swig_result sous un format compatible(par un exemple un tableau contenant des donnes precises) n'est pas possible ? 

Je suis tout à fait d'accord avec @Asmitta sur le côté complètement casse-gueule d'un partage de données complexes sans l'usage d'infrastructure dédiées comme COM ou CORBA (quelqu'un a des références plus actuelles ?)

Déjà que je réprouve l'usage de classes dans les API entre code client d'un exe avec du code en Dll, alors entre langages qui n'utilisent pas une "lingua franca" comme le fait généralement le C, votre machin, pour moi, c'est de l'hérésie.

Au vue du code C++ "petit-nègre" (pointeurs nues, casts à foison, etc..;) que semble générer par SWIG-Fortran, je suis très dubitatif sur la portabilité du bidule.

Est-ce que la valeur ajoutée du code FORTRAN est tellement fort et son code tellement pourri pour ne pas simplement justifier son portage (même automatique) en C++ ?

(S'il n'a pas de valeur ajoutée, on prendrait directement la librairie C++ sans passer par les wrappers)

En utilisant qu'un langage, cela rend l'ensemble beaucoup plus simple et portable. Quel avantage à mettre du Fortran dans la boucle ?

>nous permet d'utiliser un script C++ en tant que 'main'.

Le C++ n'est pas un langage de script car il n'utilise pas d'interpréteur.

Donc, j'espère que vous n'utilisez pas des techniques spécifiques à ce type de technologie comme le binding dynamique, etc...

>Ce code Fortran a par ailleurs été 'encapsulé' dans une classe C++ de type 'Singleton

Peut-on avoir tout ou partie du code C++ généré pour une de ces classes "capsules", pour voir comment elles sont censées être utilisées (gestion du ownership, alignement mémoire, etc...) par du code C++ ?

>les Objets FORTRAN qu'on a générés avec le 'wrapper' plus haut.

Si les "wrappers" sont les wrappers des objets C++ pour qu'ils soient accessibles depuis un code Fortran, pourquoi les utiliser plutôt que d'utiliser directement la librairie C++ ? Cela donne beaucoup plus de simplicité et de portabilité.

Si les "wrappers" sont les "capsules" C++ qui "publient" des "objets Fortran", il faut déjà qu'on sache quel modèle d'instanciation vos objets Fortran suivent pour voir si vos "capsules" sont utilisables dans ce modèle et comment cela impacte leur usage dans un code C++.

L'outil qui sert à implémenter vos "capsules", il fournit pas des codes C++ d'exemple ???

>Et là, la difficulté est de faire 'remonter' vers le main C++ les Objets FORTRAN

C'est fonction du modèle d'instanciation de vos objets Fortran (durant mes études, il y a plus de 30 ans, Fortran n'était pas orienté objet, je ne sais donc pas s'il n'existe qu'un seul modèle d'instanciation en Fortran).

Il n'y a vraisemblablement rien à "partager" si c'est le code C++ qui est à l'initiative de la création de l'objet. (en espérant que vous n'utilisez pas ces cochonneries de variables globales)

Je suis vindicatif sur le partage de données complexes car le C++ n'a pas d'ABI (représentation binaire des données/objets en mémoire), il est donc illusoire de faire interagir "directement" du code C++ avec données qu'il n'a pas lui-même créé, d'où l'utilisation de DTOs spécifiés en C (pas en C++) ou de couches d'encapsulation type COM)

C'est résolu.

Swig-Fortran génère des structures Fortran sous forme de 'wrap', et dans le 'wrap' produit, on peut accéder au pointeur C de la donnée "wrappée".

En réponse à ma question, il suffit dans le Fortran de déclarer et créer une instance de l'objet généré par SWIG_Fortran, de déclarer un pointeur (C_PTR) et d'extraire le pointeur C associé à l'objet (ce pointeur peut être transmis ensuite au code C++).  Le membre "swigdata" qui est le membre principal de tout objet wrappé par swig-Fortran, contient le membre "swigdata%cptr" qui est précisément le pointeur C demandé.

USE ,INTRINSIC :: ISO_C_BINDING

TYPE(C_PTR) :: cptrf

TYPE(SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble)::FIELDG

...création de FIELDG

cptrf = FIELDG%swigdata%cptr

Merci @Bastringue pour ces informations.

Il s'agit bien de C, qui a une ABI, pas du C++. Attention.