Styjun

I want to use the modern Fortran interface of FFTW, but in a way that allows simple function calls like ifftshift(fft_c2c(vec)*exp(vec)) et cetera. This is my understanding of how to do this (I also understand that doing a new plan every call is not the most efficient thing). Currently this code is functional (returns correct results); however, there is a memory leak so that repeated calls result in losses. I'm not quite sure where though! I had hoped that the association of the return variable `fft' with the only unfreed memory would result in no leaks but this is evidently not true. What am I missing, and how can I better structure what I want to do with proper modern fortran? Thanks!

function fft_c2c(x) result(fft) 
integer :: N 
type(C_PTR) :: plan 
complex(C_DOUBLE_COMPLEX), pointer :: fft(:) 
complex(C_DOUBLE_COMPLEX), dimension(:), intent(in) :: x 

! Use an auxiliary array that is allocated with fftw_alloc_complex 
! to ensure memory alignment for performance, see FFTW docs 
complex(C_DOUBLE_COMPLEX), pointer :: x_align(:) 
type(C_PTR) :: p 

N = size(x) 
p = fftw_alloc_complex(int(N, C_SIZE_T)) 
call c_f_pointer(p, fft, [N]); 
p = fftw_alloc_complex(int(N, C_SIZE_T)) 
call c_f_pointer(p, x_align, [N]); 

plan = fftw_plan_dft_1d(N, x_align, fft, FFTW_FORWARD, FFTW_MEASURE); 
! FFTW overwrites x_align and fft during planning process, so assign 
! data here 
x_align = x 
call fftw_execute_dft(plan, x_align, fft); 
call fftw_free(p); 
end function fft_c2c 

You can't do that easily. You are forcing your notin of "modern"="everything is a function" on Fortran, here it does not fit that well (or not at all).

For the meory leaks the rule is simple - deallocate all the pointers. Using them for the result variable is a guarantee of a memory leak. If you need local allocted aligned memory, you need to locally allocate it, copy the data there, copy the data out and deallocate it.

Every pointer in Fortran need explicit deallocation, there is no reference counting or garbage collection to deallocate them for you.

You think about just using the nonaligned memory with the appropriate flags and measure the difference, you seem not to care about the top performance anyway.

Finally, doingFFTW_MEASURE before every transform is not just "not the most efficient thing", it is an absolute performance disaster. You should, at the very least, use FFTW_ESTIMATE to mitigate it.