[petsc-users] difference on MATLAB backslash and PETSc/external solvers

[Barry Smith]

> Then I compare the results with the MATLAB backslash which is also using UMFPACK as far as I can read from the documentation. PETSc is built in the default mode, which is the debug mode.

   What do you mean in the debug mode?  To do any fair comparisons of times you should have ./configure PETSc with --with-debugging=0

> Can this be the reason of this? 

   Reason of what?

   Different solvers will give different solution times, this is perfectly normal. In fact sometimes for different matrices different solvers will actually be best for different matrices?

   Are you asking why UMFPack in Matlab does much faster (it seems) than the one used by PETSc? The likely answer is that the Matlab folks tweak the hell out of it to get good performance and when Tim Davis says "UMFPACK is in Matlab" actually means he gave something to Matlab and they improved it. It is unlikely that Matlab just uses the downloadable open source UMFPACK that PETSc uses.

   If this does not answer your question please rephrase.

   Barry



On Apr 15, 2011, at 12:33 PM, Umut Tabak wrote:

> Dear all,
> 
> I have been testing the factors of a symmetric matrix of size 4225 by 4225 as a preconditioner for a pcg type iteration in MATLAB(Since I have these factors from an eigenvalue extraction process). I extract the main matrix from a commercial code and the sparsity pattern is not that optimum for the moment.
> 
> Using the built in profiler, I tried to check the performance of the implementation, most of my time was spent in the forward-backward substitutions resulting from the preconditioner usage, namely, the  p = M^{-1} r operation in the pcg algorithm, which was expected.
> 
> Moreover, I conducted a series of simple tests with the same operator matrix and right hand side in PETSc and with the external direct solver interfaces, I ended up some differences in the solution phases. I timed the process with PetscGetTime function. The related part of the code is given as
> 
>   std::cout << "First solve ... " << std::endl;
>   ierr = PetscGetTime(&t1);CHKERRQ(ierr);
>   ierr = KSPSolve(ksp,b,x);CHKERRQ(ierr);
>   ierr = PetscGetTime(&t2);CHKERRQ(ierr);
>   std::cout << "Code took " << t2-t1 << " seconds .. " << std::endl;
>   std::cout << "Second solve ... " << std::endl;
>   ierr = PetscGetTime(&t3);CHKERRQ(ierr);
>   ierr = KSPSolve(ksp,b,y);CHKERRQ(ierr);
>   ierr = PetscGetTime(&t4);CHKERRQ(ierr);
>   std::cout << "Code took " << t4-t3 << " seconds .. " << std::endl;
>   std::cout << "Third  solve ... " << std::endl;
>   ierr = PetscGetTime(&t5);CHKERRQ(ierr);
>   ierr = KSPSolve(ksp,b,z);CHKERRQ(ierr);
>   ierr = PetscGetTime(&t6);CHKERRQ(ierr);
>   std::cout << "Code took " << t6-t5 << " seconds .. " << std::endl;
> 
> Basically, I do a first solve where the factorization is done( just to be sure, KSPSolve is the step where the factorization is done, right?) Then, the results for different factorization and forward backward substitutions are given below, when I use the ksp object the second time, it basically does a forward-backward solve, right? Then I compare the results with the MATLAB backslash which is also using UMFPACK as far as I can read from the documentation. PETSc is built in the default mode, which is the debug mode. Can this be the reason of this? Any explanations are welcome on this.
> Actually the difference on the umfpack result was interesting to me.
> 
> Here are the results:
> 
> umfpack:
> ---------------------------------------------------
> First solve ...
> Code took 1.94039 seconds ..
> Second solve ...
> Code took 0.0264909 seconds ..
> Third  solve ...
> Code took 0.0264909 seconds ..
> 
> mumps:
> ---------------------------------------------------
> First solve ...
> Code took 1.40669 seconds ..
> Second solve ...
> Code took 0.0235441 seconds ..
> Third  solve ...
> Code took 0.023541 seconds ..
> 
> superlu:
> ---------------------------------------------------
> First solve ...
> Code took 3.20602 seconds ..
> Second solve ...
> Code took 0.0487978 seconds ..
> Third  solve ...
> Code took 0.048856 seconds ..
> 
> spooles:
> ----------------------------------------------------
> First solve ...
> Code took 1.43427 seconds ..
> Second solve ...
> Code took 0.0536189 seconds ..
> Third  solve ...
> Code took 0.053726 seconds ..
> 
> PETSc
> ----------------------------------------------------
> First solve ...
> Code took 1.3292 seconds ..
> Second solve ...
> Code took 0.0116079 seconds ..
> Third  solve ...
> Code took 0.011915 seconds ..
> 
> MATLAB by cputime function
> -----------------------------------------------------
> A \ b (native backslash)
> 3.800000000000006e-01 (with a bit fluctuation )
> 
> and by using the Factorize package also written by Timothy Davis;
> 
> t = cputime; factorOpA =factorize(OpA); factorOpA \ rhsA; cputime-t
> 6.300000000000026e-01
> 
> and a forward backward substitution using factorOpA
> 
> t = cputime; factorOpA \ rhsA; cputime-t
> 9.999999999998010e-03
> 
> Best,
> Umut
> 
> -- 
> If I have a thousand ideas and only one turns out to be good,
> I am satisfied.
> Alfred Nobel
>