[SciPy-user] LU: linalg.solve vs. dgetrf/dgetrs fortran subroutines

[fred]

Hi,

I want to compare execution times between linalg.solve from scipy
and dgetrf/dgetrs fortran subroutines (before using cvxopt...)

Here my functions:

    def calc_KW_LU(self, KV):
        from scipy.linalg import solve
        from sys import stdout
        t0 = time.time()
        print 'Computing kriging weights (scipy LU version)...',
        stdout.flush()
        KW = solve(self.KM, KV)
        self.KW = KW[:-1].squeeze()
        print '('+str(time.time()-t0)+' s)',
        print 'done !'
        stdout.flush()


subroutine calc_KW(KW, KM, KV, nbx, nby, nbz)
  
  implicit none
  
!f2py real intent(in, out) :: KW
!f2py real*8 intent(in) :: KM, KV
!f2py integer intent(in) :: nbx, nby, nbz
  
  integer :: nbx, nby, nbz
  real :: KW((2*nbx+1)*(2*nby+1)*(2*nbz+1))
  real*8 :: KM((2*nbx+1)*(2*nby+1)*(2*nbz+1)+1, (2*nbx+1)*(2*nby+1)*(2*nbz+1)+1)
  real*8 :: KV((2*nbx+1)*(2*nby+1)*(2*nbz+1)+1)
  
  integer :: ndim
  integer :: info
  integer, dimension(:), allocatable :: ipvt
  
  ndim = (2*nbx+1)*(2*nby+1)*(2*nbz+1)+1
  
  allocate(ipvt(ndim))
  
  call dgetrf(ndim, ndim, KM, ndim, ipvt, info)
  call dgetrs('N', ndim, 1, KM, ndim, ipvt, KV, ndim, info)
  
  KW = KV(1:size(KV)-1)
  
end subroutine calc_KW

This last is called by my python method:

    def calc_KW_LU_Fmodule(self, KV):
        from scipy import float32, zeros
        from sys import stdout
        from calc_KW_LU import calc_kw
        t0 = time.time()
        nbx, nby, nbz = self.nbx, self.nby, self.nbz
        ndx, ndy, ndz = (2*nbx+1), (2*nby+1), (2*nbz+1)
        ndt = ndx*ndy*ndz
        KM, KV = self.KM, self.KV
        print 'Computing kriging weights (LU Fortran module version)...',
        stdout.flush()
        KW = zeros((ndt,1), dtype=float32)
        KW = calc_kw(KW, KM, KV, nbx, nby, nbz)
        self.KW = KW.squeeze()
        print '('+str(time.time()-t0)+' s)',
        print 'done !'
        stdout.flush()

The execution times are very different:

1) On my Core 2 Duo T7200 (i686, Debian etch):

Computing kriging weights (LU version)... (142.409274817 s) done !

Computing kriging weights (LU Fortran module version)... (157.362993002 s) done !

2) On my Pentium 930 D (x86_64, Debian etch), differences are bigger:

Computing kriging weights (LU version)... (283.214334011 s) done !

Computing kriging weights (LU Fortran module version)... (583.182439089 s) done !

Could someone give me any clues ?

TIA.


Cheers,

-- 
http://scipy.org/FredericPetit