Latest Fortran interface crashes in fio_eval_field_f

[rhager]

I encountered a problem with the latest version of the Fortran interface on the Greene cluster. When trying to read a field with fit_eval_field_f, the my code crashes.

I think the problem is that the C-version of fio_eval_field is called with a constant (0):

fusion-io/fusion_io/fusion_io_fortran.F90

Lines 40 to 54 in 4ba28ce

	subroutine fio_eval_field_f(ifield, x, v, ierr)
	integer, intent(in) :: ifield
	real, intent(in), dimension(*) :: x
	real, intent(out), dimension(*) :: v
	integer, intent(out) :: ierr
	call fio_eval_field(ifield, x, v, 0, ierr)
	end subroutine fio_eval_field_f
	subroutine fio_eval_field_deriv_f(ifield, x, v, ierr)
	integer, intent(in) :: ifield
	real, intent(in), dimension(*) :: x
	real, intent(out), dimension(*) :: v
	integer, intent(out) :: ierr
	call fio_eval_field_deriv(ifield, x, v, 0, ierr)
	end subroutine fio_eval_field_deriv_f

I modified the code slightly by declaring an integer variable s and setting s=0

  subroutine fio_eval_field_f(ifield, x, v, ierr)
    integer, intent(in) :: ifield
    real, intent(in), dimension(*) :: x
    real, intent(out), dimension(*) :: v
    integer, intent(out) :: ierr
    integer :: s
    s=0
    call fio_eval_field(ifield, x, v, s, ierr)
  end subroutine fio_eval_field_f

  subroutine fio_eval_field_deriv_f(ifield, x, v, ierr)
    integer, intent(in) :: ifield
    real, intent(in), dimension(*) :: x
    real, intent(out), dimension(*) :: v
    integer, intent(out) :: ierr
    integer :: s
    s=0
    call fio_eval_field_deriv(ifield, x, v, s, ierr)
  end subroutine fio_eval_field_deriv_f

This turned out to work. The only way I can make sense of this is that somewhere down the call-tree, a program tries to write into s, which results in a segfault if s is a constant.

[nferraro]

Thanks Robert. I think I see what is wrong here. We should actually be passing a null pointer to the underlying c function, not an integer with the value 0. Since it sees a non-null value being passed, it tries to update the pointed-to integer with some data, which is not allowed when passing a constant value.

Your solution will work fine for the time being -- what it will do is always start the element search at element 0, which is fine though not optimal. I will have to update this so that it correctly passes a null pointer. I'm actually not sure how to do this in Fortran off the top of my head...

[rhager]

You could change the declaration of s to
integer, pointer :: s => null()
which will give you a pointer of size integer that points to nothing.
I can give this a try.

[rhager]

The code using a null-pointer works as well:

integer, pointer :: s => null()

In the C-interface c_interface.cpp, there is =0 in the header of fio_eval_field and fio_eval_field_f:
int fio_eval_field(const int ifield, const double* x, double* v, void* s=0)

Is that still necessary if the Fortran code passes a proper null-pointer?

[nferraro]

These functions are defined as extern "C" in fusion_io_c.h, and I don't think setting a default argument value works in c (since this would involve name mangling). So we can't just drop that argument in the fortran call.

We can use your s => null() solution for the time being. I'll think of a way to have a more generic solution in the future that will let us set it when calling the fortran function. I don't think including an integer pointer in the fortran argument list is necessarily the best solution; maybe a type(c_ptr) (as suggested by Mark Cianciosa) would be better.

[nferraro]

For the time being, I've just removed the void* argument from the fortran bindings in fortran_interface.cpp . This means that argument no longer needs to be included in the calls from the *_f functions defined in fusion_io_fortran.F90 . The fortran bindings in fortran_interface.cpp will just pass a null pointer by default.

Eventually we will want to figure out the best way to add this optional argument to the fortran interface though.

If the updated code works for you, let me know and I'll close this.

[rhager]

Thanks, Nate! I'll pull the new version and give it a try.

I have not really looked into the C++ code yet. What is the purpose of the argument s? Is it something like a guess for the triangle search?

If you want to make s an optional argument in the Fortran call you could do something like this (with the type and attributes of s adjusted to what you need in the C++ call):

  subroutine fio_eval_field_f(ifield, x, v, ierr, s)
    integer, intent(in) :: ifield
    real, intent(in), dimension(*) :: x
    real, intent(out), dimension(*) :: v
    integer, intent(out) :: ierr
    integer, pointer, optional, intent(in) :: s
    integer, pointer :: s2=>null()
    if (present s) s2=>s
    call fio_eval_field(ifield, x, v, s, ierr)
  end subroutine fio_eval_field_f

  call fio_eval_field_f(field,x,v,ierr,s=...)