Trouble with Intel MKL libraries: segfault / unresolved external symbol - fortran

Question

I am compiling some code trying to use the Intel MKL library eigensolvers. I am already using the VSL RNG's and the DFT libraries without issue. I am compiling and running everything in Visual Studio with Intel Parallel Studio XE installed. I have ensured that the mkl flag is enabled in project properties.
include 'lapack.f90'
program heev_test
use lapack95
implicit none
integer , parameter :: dp = kind(0.0d0)
complex(dp) :: matrix(4,4)
real(dp) :: eigs(4)
matrix = (1.0_dp,0.0_dp)
call zheev(matrix, eigs)
print*, eigs
read(*,*)
stop
end program
Running this code yields a segfault on two machines I have tested it on so far. I believe the issue is that the F77 routines are being called which require more arguments (documentation here). I would like to use the far simpler F95 routines. According to the documentation, I should replace zheev with heev. So I tried that, but then I get the error
fatal error LNK1120: 1 unresolved externals
error LNK2019: unresolved external symbol _ZHEEV_F95 referenced in function _MAIN__
ZHEEV_F95 has an interface defined in the lapack.f90 file.
The only other thing I have right now is that the documentation says I should also include mkl.fi, but doing so I get the following compilation errors
Error error #6218: This statement is positioned incorrectly and/or has syntax errors. C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\\mkl\include\lapack.f90 21
Error error #6790: This is an invalid statement; an END [PROGRAM] statement is required. C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\\mkl\include\lapack.f90 24
Error error #6785: This name does not match the unit name. [F95_PRECISION] C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\\mkl\include\lapack.f90 24
Error Compilation Aborted (code 1)
Warning warning #5427: Program may contain only one main entry routine
referring to these lines from the lapack.f90 file:
21 MODULE F95_PRECISION
22 INTEGER, PARAMETER :: SP = KIND(1.0E0)
23 INTEGER, PARAMETER :: DP = KIND(1.0D0)
24 END MODULE F95_PRECISION

Answer 1

The solution was to link the Lapack95 library explicitly, which is not linked with simply the -mkl flag. For example, on Windows 64-bit with 4 byte integers compiled with the Intel Fortran compiler, use
ifort /Qmkl heev_test.f90 mkl_lapack95_lp64.lib
As for the seg fault, I was improperly calling the F77 routines. Since I did not provide an interface for these routines, the compiler did not complain, and when I did call them, it caused a segmentation fault since the arguments were not properly input.
Here is a code which properly calls both routines, and can be verified to produce the same results.
include 'lapack.f90'
program heev_test
use lapack95
implicit none
integer , parameter :: dp = kind(0.0d0)
complex(dp) :: matrix(4,4)
real(dp) :: eigs(4)
matrix = (1.0_dp,0.0_dp)
print*, "checking eigenvalues using zheevr"
call eigenvalues(matrix,eigs)
print*, eigs
matrix = (1.0_dp,0.0_dp)
print*, "checking eigenvalues using heevr"
call heevr(matrix,eigs)
print*, eigs
read(*,*)
stop
contains
subroutine eigenvalues(a,w)
complex(dp) :: a(:,:)
real(dp) :: w(:)
character*1 :: jobz, range, uplo
integer :: n, m, lda, il, iu, ldz
real(dp) :: vl, vu, abstol
integer :: info
integer :: lwork, liwork, lrwork
complex(dp) , allocatable :: z(:,:)
complex(dp) , allocatable :: work(:)
real(dp) , allocatable :: rwork(:)
integer , allocatable :: iwork(:)
integer , allocatable :: isuppz(:)
jobz = 'N'
range = 'A'
uplo = 'U'
n = size(a,dim=1)
lda = max(1,n)
vl = -huge(vl)
vu = +huge(vl)
il = 1
iu = n
abstol = 0.0_dp
ldz = max(1,n)
lwork = max(1,2*n)
lrwork = max(1,24*n)
liwork = max(1,10*n)
allocate(work(lwork))
allocate(rwork(lrwork))
allocate(iwork(liwork))
allocate(z(ldz,max(1,n)))
allocate(isuppz(2*max(1,n)))
lwork = -1
liwork = -1
lrwork = -1
call zheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, &
& z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)
lwork = work(1)
liwork = iwork(1)
lrwork = rwork(1)
deallocate(work,iwork,rwork)
allocate(work(lwork))
allocate(iwork(liwork))
allocate(rwork(lrwork))
call zheevr(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, &
& z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info)
deallocate(work,iwork,rwork)
if (info /= 0) then
print*, "diagonalization failed, info = ", info
read(*,*)
stop
end if
end subroutine
end program
In my case, the f95 libraries were not installed on the target machine (a remote cluster), so I had to fall back on the f77 library, for which the above subroutine is essentially equivalent to the f95 interface for a square matrix and can be easily modified. See the documentation for definitions of variables.
Note that according to the documentation, heevr/zheevr is a more efficient routine than heev/zheev, so I switched them.