Comment travailler avec des pointeurs de fonction dans Fortran dans les programmes scientifiques

Voici une utilisation typique des pointeurs de fonction en C. Je voudrais faire quelque chose de similaire dans Fortran. J'ai quelques idées, mais j'aimerais savoir s'il existe un moyen canonique de le faire.

Les pointeurs de fonction et les contextes transmis par l'utilisateur sont stockés, puis appelés ultérieurement.

typedef PetscErrorCode (*TSIFunction)(TS,PetscReal,Vec,Vec,Vec,void*);
PetscErrorCode TSSetIFunction(TS ts,Vec res,TSIFunction f,void *ctx);

La fonction de l'utilisateur est rappelée à l'aide de son contexte à différents moments ultérieurs.

Dans PETSc, ils font également un usage intensif des tables de pointeurs chaîne -> fonction. Tout est un plugin, donc l'utilisateur peut enregistrer ses propres implémentations et ils sont de première classe.

#define PCGAMG "gamg"
  PCRegisterDynamic(PCGAMG         ,path,"PCCreate_GAMG",PCCreate_GAMG);

Cela enregistre la routine de création dans un "FList", puis PCSetFromOptions () offre la possibilité de choisir cette méthode par rapport à tout autre choix. Si le système prend en charge le chargement dynamique, vous pouvez ignorer la dépendance au moment de la compilation sur le symbole PCCreate_GAMG et simplement passer NULL, puis le symbole sera recherché dans la bibliothèque partagée au moment de l'exécution.

Notez que cette étape au-delà d'une "usine", c'est une inversion du dispositif de contrôle similaire à ce que Martin Fowler appelle "localisateur de service".

Remarque: cela est venu dans ma correspondance privée avec Jed Brown, où il m'a posé cette question. J'ai décidé de l'externaliser et de voir quelles réponses les gens peuvent trouver.

Il n'est pas nécessaire d'utiliser le transfert pour émuler void *dans un code Fortran moderne. À la place, utilisez simplement le module intrinsèque ISO_C_BINDING , qui est pris en charge par tous les compilateurs Fortran traditionnels. Ce module permet une interface très simple entre Fortran et C, avec quelques mises en garde très mineures. On peut utiliser les fonctions C_LOCet C_FUNLOCpour obtenir des pointeurs C vers les données et procédures Fortran, respectivement.

En ce qui concerne l'exemple PETSC ci-dessus, je suppose que le contexte est généralement un pointeur vers une structure définie par l'utilisateur, ce qui équivaut à un type de données dérivé dans Fortran. Cela ne devrait pas être un problème pour gérer l'utilisation C_LOC. La poignée TSIFunction opaque est également très simple à manipuler: utilisez simplement le type de données ISO_C_BINDING c_ptr, qui est équivalent à void *C. Une bibliothèque écrite en Fortran peut utiliser c_ptrsi elle a besoin de contourner la vérification de type stricte de Fortran moderne.

Il y a beaucoup de ce que je suppose être un langage spécifique à PETSc dans votre question (avec laquelle je ne suis pas familier), donc il pourrait y avoir une ride ici, je ne comprends pas très bien, mais peut-être que cela sera toujours utile pour vous commencé.

Fondamentalement, vous devez définir l'interface de la procédure, puis vous pouvez passer un pointeur vers une fonction qui suit cette interface. Le code suivant montre un exemple. Tout d'abord, il existe un module qui définit l'interface et montre un exemple rapide d'un morceau de code qui exécuterait la routine fournie par l'utilisateur qui suit cette interface. Vient ensuite un programme qui montre comment l'utilisateur utiliserait ce module et définirait la fonction à exécuter.

MODULE xmod

  ABSTRACT INTERFACE
  FUNCTION function_template(n,x) RESULT(y)
      INTEGER, INTENT(in) :: n
      REAL, INTENT(in) :: x(n)
      REAL :: y
  END FUNCTION function_template
  END INTERFACE

CONTAINS

  SUBROUTINE execute_function(n,x,func,y)
    INTEGER, INTENT(in) :: n
    REAL, INTENT(in) :: x(n)
    PROCEDURE(function_template), POINTER :: func
    REAL, INTENT(out) :: y
    y = func(n,x)
  END SUBROUTINE execute_function

END MODULE xmod


PROGRAM xprog

  USE xmod

  REAL :: x(4), y
  PROCEDURE(function_template), POINTER :: func

  x = [1.0, 2.0, 3.0, 4.0]
  func => summation

  CALL execute_function(4,x,func,y)

  PRINT*, y  ! should give 10.0

CONTAINS

  FUNCTION summation(n,x) RESULT(y)
    INTEGER, INTENT(in) :: n
    REAL, INTENT(in) :: x(n)
    REAL :: y
    y = SUM(x)
  END FUNCTION summation

END PROGRAM xprog