bench/spbench/spbenchsolver.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#include <iostream>
#include <fstream>
#include <Eigen/SparseCore>
#include <bench/BenchTimer.h>
#include <cstdlib>
#include <string>
#include <Eigen/Cholesky>
#include <Eigen/Jacobi>
#include <Eigen/Householder>
#include <Eigen/IterativeLinearSolvers>
#include <unsupported/Eigen/IterativeSolvers>
#include <Eigen/LU>
#include <unsupported/Eigen/SparseExtra>
#include <Eigen/SparseLU>

#include "spbenchstyle.h"

#ifdef EIGEN_METIS_SUPPORT
#include <Eigen/MetisSupport>
#endif

#ifdef EIGEN_CHOLMOD_SUPPORT
#include <Eigen/CholmodSupport>
#endif

#ifdef EIGEN_UMFPACK_SUPPORT
#include <Eigen/UmfPackSupport>
#endif

#ifdef EIGEN_KLU_SUPPORT
#include <Eigen/KLUSupport>
#endif

#ifdef EIGEN_PARDISO_SUPPORT
#include <Eigen/PardisoSupport>
#endif

#ifdef EIGEN_SUPERLU_SUPPORT
#include <Eigen/SuperLUSupport>
#endif

#ifdef EIGEN_PASTIX_SUPPORT
#include <Eigen/PaStiXSupport>
#endif

// CONSTANTS
#define EIGEN_UMFPACK 10
#define EIGEN_KLU 11
#define EIGEN_SUPERLU 20
#define EIGEN_PASTIX 30
#define EIGEN_PARDISO 40
#define EIGEN_SPARSELU_COLAMD 50
#define EIGEN_SPARSELU_METIS 51
#define EIGEN_BICGSTAB 60
#define EIGEN_BICGSTAB_ILUT 61
#define EIGEN_GMRES 70
#define EIGEN_GMRES_ILUT 71
#define EIGEN_SIMPLICIAL_LDLT 80
#define EIGEN_CHOLMOD_LDLT 90
#define EIGEN_PASTIX_LDLT 100
#define EIGEN_PARDISO_LDLT 110
#define EIGEN_SIMPLICIAL_LLT 120
#define EIGEN_CHOLMOD_SUPERNODAL_LLT 130
#define EIGEN_CHOLMOD_SIMPLICIAL_LLT 140
#define EIGEN_PASTIX_LLT 150
#define EIGEN_PARDISO_LLT 160
#define EIGEN_CG 170
#define EIGEN_CG_PRECOND 180

using namespace Eigen;
using namespace std;

// Global variables for input parameters
int MaximumIters;      // Maximum number of iterations
double RelErr;         // Relative error of the computed solution
double best_time_val;  // Current best time overall solvers
int best_time_id;      //  id of the best solver for the current system

template <typename T>
inline typename NumTraits<T>::Real test_precision() {
  return NumTraits<T>::dummy_precision();
}
template <>
inline float test_precision<float>() {
  return 1e-3f;
}
template <>
inline double test_precision<double>() {
  return 1e-6;
}
template <>
inline float test_precision<std::complex<float> >() {
  return test_precision<float>();
}
template <>
inline double test_precision<std::complex<double> >() {
  return test_precision<double>();
}

void printStatheader(std::ofstream& out) {
  // Print XML header
  // NOTE It would have been much easier to write these XML documents using external libraries like tinyXML or
  // Xerces-C++.

  out << "<?xml version='1.0' encoding='UTF-8'?> \n";
  out << "<?xml-stylesheet type='text/xsl' href='#stylesheet' ?> \n";
  out << "<!DOCTYPE BENCH  [\n<!ATTLIST xsl:stylesheet\n id\t ID  #REQUIRED>\n]>";
  out << "\n\n<!-- Generated by the Eigen library -->\n";

  out << "\n<BENCH> \n";  // root XML element
  // Print the xsl style section
  printBenchStyle(out);
  // List all available solvers
  out << " <AVAILSOLVER> \n";
#ifdef EIGEN_UMFPACK_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_UMFPACK << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> UMFPACK </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_KLU_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_KLU << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> KLU </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_SUPERLU_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_SUPERLU << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> SUPERLU </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_CHOLMOD_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_CHOLMOD_SIMPLICIAL_LLT << "'>\n";
  out << "   <TYPE> LLT SP</TYPE> \n";
  out << "   <PACKAGE> CHOLMOD </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_CHOLMOD_SUPERNODAL_LLT << "'>\n";
  out << "   <TYPE> LLT</TYPE> \n";
  out << "   <PACKAGE> CHOLMOD </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_CHOLMOD_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> CHOLMOD </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_PARDISO_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_PARDISO << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> PARDISO </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_PARDISO_LLT << "'>\n";
  out << "   <TYPE> LLT </TYPE> \n";
  out << "   <PACKAGE> PARDISO </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_PARDISO_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> PARDISO </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
#ifdef EIGEN_PASTIX_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_PASTIX << "'>\n";
  out << "   <TYPE> LU </TYPE> \n";
  out << "   <PACKAGE> PASTIX </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_PASTIX_LLT << "'>\n";
  out << "   <TYPE> LLT </TYPE> \n";
  out << "   <PACKAGE> PASTIX </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_PASTIX_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> PASTIX </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif

  out << "  <SOLVER ID='" << EIGEN_BICGSTAB << "'>\n";
  out << "   <TYPE> BICGSTAB </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_BICGSTAB_ILUT << "'>\n";
  out << "   <TYPE> BICGSTAB_ILUT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_GMRES_ILUT << "'>\n";
  out << "   <TYPE> GMRES_ILUT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_SIMPLICIAL_LDLT << "'>\n";
  out << "   <TYPE> LDLT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_SIMPLICIAL_LLT << "'>\n";
  out << "   <TYPE> LLT </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_CG << "'>\n";
  out << "   <TYPE> CG </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

  out << "  <SOLVER ID='" << EIGEN_SPARSELU_COLAMD << "'>\n";
  out << "   <TYPE> LU_COLAMD </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";

#ifdef EIGEN_METIS_SUPPORT
  out << "  <SOLVER ID='" << EIGEN_SPARSELU_METIS << "'>\n";
  out << "   <TYPE> LU_METIS </TYPE> \n";
  out << "   <PACKAGE> EIGEN </PACKAGE> \n";
  out << "  </SOLVER> \n";
#endif
  out << " </AVAILSOLVER> \n";
}

template <typename Solver, typename Scalar>
void call_solver(Solver& solver, const int solver_id, const typename Solver::MatrixType& A,
                 const Matrix<Scalar, Dynamic, 1>& b, const Matrix<Scalar, Dynamic, 1>& refX, std::ofstream& statbuf) {
  double total_time;
  double compute_time;
  double solve_time;
  double rel_error;
  Matrix<Scalar, Dynamic, 1> x;
  BenchTimer timer;
  timer.reset();
  timer.start();
  solver.compute(A);
  if (solver.info() != Success) {
    std::cerr << "Solver failed ... \n";
    return;
  }
  timer.stop();
  compute_time = timer.value();
  statbuf << "    <TIME>\n";
  statbuf << "     <COMPUTE> " << timer.value() << "</COMPUTE>\n";
  std::cout << "COMPUTE TIME : " << timer.value() << std::endl;

  timer.reset();
  timer.start();
  x = solver.solve(b);
  if (solver.info() == NumericalIssue) {
    std::cerr << "Solver failed ... \n";
    return;
  }
  timer.stop();
  solve_time = timer.value();
  statbuf << "     <SOLVE> " << timer.value() << "</SOLVE>\n";
  std::cout << "SOLVE TIME : " << timer.value() << std::endl;

  total_time = solve_time + compute_time;
  statbuf << "     <TOTAL> " << total_time << "</TOTAL>\n";
  std::cout << "TOTAL TIME : " << total_time << std::endl;
  statbuf << "    </TIME>\n";

  // Verify the relative error
  if (refX.size() != 0)
    rel_error = (refX - x).norm() / refX.norm();
  else {
    // Compute the relative residual norm
    Matrix<Scalar, Dynamic, 1> temp;
    temp = A * x;
    rel_error = (b - temp).norm() / b.norm();
  }
  statbuf << "    <ERROR> " << rel_error << "</ERROR>\n";
  std::cout << "REL. ERROR : " << rel_error << "\n\n";
  if (rel_error <= RelErr) {
    // check the best time if convergence
    if (!best_time_val || (best_time_val > total_time)) {
      best_time_val = total_time;
      best_time_id = solver_id;
    }
  }
}

template <typename Solver, typename Scalar>
void call_directsolver(Solver& solver, const int solver_id, const typename Solver::MatrixType& A,
                       const Matrix<Scalar, Dynamic, 1>& b, const Matrix<Scalar, Dynamic, 1>& refX,
                       std::string& statFile) {
  std::ofstream statbuf(statFile.c_str(), std::ios::app);
  statbuf << "   <SOLVER_STAT ID='" << solver_id << "'>\n";
  call_solver(solver, solver_id, A, b, refX, statbuf);
  statbuf << "   </SOLVER_STAT>\n";
  statbuf.close();
}

template <typename Solver, typename Scalar>
void call_itersolver(Solver& solver, const int solver_id, const typename Solver::MatrixType& A,
                     const Matrix<Scalar, Dynamic, 1>& b, const Matrix<Scalar, Dynamic, 1>& refX,
                     std::string& statFile) {
  solver.setTolerance(RelErr);
  solver.setMaxIterations(MaximumIters);

  std::ofstream statbuf(statFile.c_str(), std::ios::app);
  statbuf << " <SOLVER_STAT ID='" << solver_id << "'>\n";
  call_solver(solver, solver_id, A, b, refX, statbuf);
  statbuf << "   <ITER> " << solver.iterations() << "</ITER>\n";
  statbuf << " </SOLVER_STAT>\n";
  std::cout << "ITERATIONS : " << solver.iterations() << "\n\n\n";
}

template <typename Scalar>
void SelectSolvers(const SparseMatrix<Scalar>& A, unsigned int sym, Matrix<Scalar, Dynamic, 1>& b,
                   const Matrix<Scalar, Dynamic, 1>& refX, std::string& statFile) {
  typedef SparseMatrix<Scalar, ColMajor> SpMat;
  // First, deal with Nonsymmetric and symmetric matrices
  best_time_id = 0;
  best_time_val = 0.0;
// UMFPACK
#ifdef EIGEN_UMFPACK_SUPPORT
  {
    cout << "Solving with UMFPACK LU ... \n";
    UmfPackLU<SpMat> solver;
    call_directsolver(solver, EIGEN_UMFPACK, A, b, refX, statFile);
  }
#endif
// KLU
#ifdef EIGEN_KLU_SUPPORT
  {
    cout << "Solving with KLU LU ... \n";
    KLU<SpMat> solver;
    call_directsolver(solver, EIGEN_KLU, A, b, refX, statFile);
  }
#endif
  // SuperLU
#ifdef EIGEN_SUPERLU_SUPPORT
  {
    cout << "\nSolving with SUPERLU ... \n";
    SuperLU<SpMat> solver;
    call_directsolver(solver, EIGEN_SUPERLU, A, b, refX, statFile);
  }
#endif

  // PaStix LU
#ifdef EIGEN_PASTIX_SUPPORT
  {
    cout << "\nSolving with PASTIX LU ... \n";
    PastixLU<SpMat> solver;
    call_directsolver(solver, EIGEN_PASTIX, A, b, refX, statFile);
  }
#endif

  // PARDISO LU
#ifdef EIGEN_PARDISO_SUPPORT
  {
    cout << "\nSolving with PARDISO LU ... \n";
    PardisoLU<SpMat> solver;
    call_directsolver(solver, EIGEN_PARDISO, A, b, refX, statFile);
  }
#endif

  // Eigen SparseLU METIS
  cout << "\n Solving with Sparse LU AND COLAMD ... \n";
  SparseLU<SpMat, COLAMDOrdering<int> > solver;
  call_directsolver(solver, EIGEN_SPARSELU_COLAMD, A, b, refX, statFile);
// Eigen SparseLU METIS
#ifdef EIGEN_METIS_SUPPORT
  {
    cout << "\n Solving with Sparse LU AND METIS ... \n";
    SparseLU<SpMat, MetisOrdering<int> > solver;
    call_directsolver(solver, EIGEN_SPARSELU_METIS, A, b, refX, statFile);
  }
#endif

  // BiCGSTAB
  {
    cout << "\nSolving with BiCGSTAB ... \n";
    BiCGSTAB<SpMat> solver;
    call_itersolver(solver, EIGEN_BICGSTAB, A, b, refX, statFile);
  }
  // BiCGSTAB+ILUT
  {
    cout << "\nSolving with BiCGSTAB and ILUT ... \n";
    BiCGSTAB<SpMat, IncompleteLUT<Scalar> > solver;
    call_itersolver(solver, EIGEN_BICGSTAB_ILUT, A, b, refX, statFile);
  }

  // GMRES
  //   {
  //     cout << "\nSolving with GMRES ... \n";
  //     GMRES<SpMat> solver;
  //     call_itersolver(solver, EIGEN_GMRES, A, b, refX,statFile);
  //   }
  // GMRES+ILUT
  {
    cout << "\nSolving with GMRES and ILUT ... \n";
    GMRES<SpMat, IncompleteLUT<Scalar> > solver;
    call_itersolver(solver, EIGEN_GMRES_ILUT, A, b, refX, statFile);
  }

  // Hermitian and not necessarily positive-definites
  if (sym != NonSymmetric) {
    // Internal Cholesky
    {
      cout << "\nSolving with Simplicial LDLT ... \n";
      SimplicialLDLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_SIMPLICIAL_LDLT, A, b, refX, statFile);
    }

// CHOLMOD
#ifdef EIGEN_CHOLMOD_SUPPORT
    {
      cout << "\nSolving with CHOLMOD LDLT ... \n";
      CholmodDecomposition<SpMat, Lower> solver;
      solver.setMode(CholmodLDLt);
      call_directsolver(solver, EIGEN_CHOLMOD_LDLT, A, b, refX, statFile);
    }
#endif

// PASTIX LLT
#ifdef EIGEN_PASTIX_SUPPORT
    {
      cout << "\nSolving with PASTIX LDLT ... \n";
      PastixLDLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PASTIX_LDLT, A, b, refX, statFile);
    }
#endif

// PARDISO LLT
#ifdef EIGEN_PARDISO_SUPPORT
    {
      cout << "\nSolving with PARDISO LDLT ... \n";
      PardisoLDLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PARDISO_LDLT, A, b, refX, statFile);
    }
#endif
  }

  // Now, symmetric POSITIVE DEFINITE matrices
  if (sym == SPD) {
    // Internal Sparse Cholesky
    {
      cout << "\nSolving with SIMPLICIAL LLT ... \n";
      SimplicialLLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_SIMPLICIAL_LLT, A, b, refX, statFile);
    }

// CHOLMOD
#ifdef EIGEN_CHOLMOD_SUPPORT
    {
      // CholMOD SuperNodal LLT
      cout << "\nSolving with CHOLMOD LLT (Supernodal)... \n";
      CholmodDecomposition<SpMat, Lower> solver;
      solver.setMode(CholmodSupernodalLLt);
      call_directsolver(solver, EIGEN_CHOLMOD_SUPERNODAL_LLT, A, b, refX, statFile);
      // CholMod Simplicial LLT
      cout << "\nSolving with CHOLMOD LLT (Simplicial) ... \n";
      solver.setMode(CholmodSimplicialLLt);
      call_directsolver(solver, EIGEN_CHOLMOD_SIMPLICIAL_LLT, A, b, refX, statFile);
    }
#endif

// PASTIX LLT
#ifdef EIGEN_PASTIX_SUPPORT
    {
      cout << "\nSolving with PASTIX LLT ... \n";
      PastixLLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PASTIX_LLT, A, b, refX, statFile);
    }
#endif

// PARDISO LLT
#ifdef EIGEN_PARDISO_SUPPORT
    {
      cout << "\nSolving with PARDISO LLT ... \n";
      PardisoLLT<SpMat, Lower> solver;
      call_directsolver(solver, EIGEN_PARDISO_LLT, A, b, refX, statFile);
    }
#endif

    // Internal CG
    {
      cout << "\nSolving with CG ... \n";
      ConjugateGradient<SpMat, Lower> solver;
      call_itersolver(solver, EIGEN_CG, A, b, refX, statFile);
    }
    // CG+IdentityPreconditioner
    //     {
    //       cout << "\nSolving with CG and IdentityPreconditioner ... \n";
    //       ConjugateGradient<SpMat, Lower, IdentityPreconditioner> solver;
    //       call_itersolver(solver,EIGEN_CG_PRECOND, A, b, refX,statFile);
    //     }
  }  // End SPD matrices
}

/* Browse all the matrices available in the specified folder
 * and solve the associated linear system.
 * The results of each solve are printed in the standard output
 * and optionally in the provided html file
 */
template <typename Scalar>
void Browse_Matrices(const string folder, bool statFileExists, std::string& statFile, int maxiters, double tol) {
  MaximumIters = maxiters;  // Maximum number of iterations, global variable
  RelErr = tol;             // Relative residual error  as stopping criterion for iterative solvers
  MatrixMarketIterator<Scalar> it(folder);
  for (; it; ++it) {
    // print the infos for this linear system
    if (statFileExists) {
      std::ofstream statbuf(statFile.c_str(), std::ios::app);
      statbuf << "<LINEARSYSTEM> \n";
      statbuf << "   <MATRIX> \n";
      statbuf << "     <NAME> " << it.matname() << " </NAME>\n";
      statbuf << "     <SIZE> " << it.matrix().rows() << " </SIZE>\n";
      statbuf << "     <ENTRIES> " << it.matrix().nonZeros() << "</ENTRIES>\n";
      if (it.sym() != NonSymmetric) {
        statbuf << "     <SYMMETRY> Symmetric </SYMMETRY>\n";
        if (it.sym() == SPD)
          statbuf << "     <POSDEF> YES </POSDEF>\n";
        else
          statbuf << "     <POSDEF> NO </POSDEF>\n";

      } else {
        statbuf << "     <SYMMETRY> NonSymmetric </SYMMETRY>\n";
        statbuf << "     <POSDEF> NO </POSDEF>\n";
      }
      statbuf << "   </MATRIX> \n";
      statbuf.close();
    }

    cout << "\n\n===================================================== \n";
    cout << " ======  SOLVING WITH MATRIX " << it.matname() << " ====\n";
    cout << " =================================================== \n\n";
    Matrix<Scalar, Dynamic, 1> refX;
    if (it.hasrefX()) refX = it.refX();
    // Call all suitable solvers for this linear system
    SelectSolvers<Scalar>(it.matrix(), it.sym(), it.rhs(), refX, statFile);

    if (statFileExists) {
      std::ofstream statbuf(statFile.c_str(), std::ios::app);
      statbuf << "  <BEST_SOLVER ID='" << best_time_id << "'></BEST_SOLVER>\n";
      statbuf << " </LINEARSYSTEM> \n";
      statbuf.close();
    }
  }
}

bool get_options(int argc, char** args, string option, string* value = 0) {
  int idx = 1, found = false;
  while (idx < argc && !found) {
    if (option.compare(args[idx]) == 0) {
      found = true;
      if (value) *value = args[idx + 1];
    }
    idx += 2;
  }
  return found;
}