How to work with function pointers in Fortran in scientific programs

Question

Here is a typical usage of function pointers in C. I would like to do something similar in Fortran. I have some ideas, but I would like to know if there is some canonical way to do so.

The function pointers and contexts passed in by the user are stored, then called later.

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

The user's function is called back using their context at various later times.

In PETSc, they also make heavy use of string -> function pointer tables. Everything is a plugin, so the user can register their own implementations and they are first-class.

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

This registers the creation routine in an "FList", then PCSetFromOptions() offers the ability to choose this method versus any of the other choices. If the system supports dynamic loading, you can skip the compile-time dependency on the PCCreate_GAMG symbol and just pass NULL, then the symbol will be looked up in the shared library at run time.

Note that this one step beyond a "factory", it's an inversion of control device similar to what Martin Fowler calls "service locator".

Note: this came up in my private correspondence with Jed Brown, where he asked this question to me. I decided to outsource it and see what answers people can come up with.

Answer 1

There's no need to use transfer to emulate void * in a modern Fortran code. Instead, just use the ISO_C_BINDING intrinsic module, which is supported by all mainstream Fortran compilers. This module makes it very simple to interface between Fortran and C, with some very minor caveats. One can use the C_LOC and C_FUNLOC functions to get C pointers to Fortran data and procedures, respectively.

With regard to the PETSC example above, I assume the context is typically a pointer to a user-defined structure, which is equivalent to a derived data type in Fortran. That shouldn't be a problem to deal with using C_LOC. The opaque TSIFunction handle is also very simple to deal with: just use the ISO_C_BINDING data type c_ptr, which is equivalent to void * in C. A library written in Fortran can use c_ptr if it needs to work around modern Fortran's strict type checking.

Answer 2

There is a lot of what I'm guessing is PETSc-specific language in your question (with which I am unfamiliar), so there might be a wrinkle here I don't quite understand, but maybe this will still be useful to get you started.

Basically, you have to define the interface for the procedure, and then you can pass a pointer to a function that follows this interface. The following code shows an example. First, there is a module that defines the interface and shows a quick example of a chunk of code that would execute the routine provided by the user that follows that interface. Next is a program that shows how the user would use this module and define the function to be executed.

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