From ada9e791450618d1d608db11fcdd97adde824cbe Mon Sep 17 00:00:00 2001 From: Desire NUENTSA Date: Thu, 29 Mar 2012 14:29:55 +0200 Subject: add a benchmark routine for all sparse linear solvers in Eigen --- bench/spbench/CMakeLists.txt | 65 +++++ bench/spbench/spbenchsolver.cpp | 79 ++++++ bench/spbench/spbenchsolver.h | 539 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 683 insertions(+) create mode 100644 bench/spbench/CMakeLists.txt create mode 100644 bench/spbench/spbenchsolver.cpp create mode 100644 bench/spbench/spbenchsolver.h (limited to 'bench/spbench') diff --git a/bench/spbench/CMakeLists.txt b/bench/spbench/CMakeLists.txt new file mode 100644 index 000000000..079912266 --- /dev/null +++ b/bench/spbench/CMakeLists.txt @@ -0,0 +1,65 @@ + + +set(BLAS_FOUND TRUE) +set(LAPACK_FOUND TRUE) +set(BLAS_LIBRARIES eigen_blas_static) +set(LAPACK_LIBRARIES eigen_lapack_static) + +set(SPARSE_LIBS "") + +# find_library(PARDISO_LIBRARIES pardiso412-GNU450-X86-64) +# if(PARDISO_LIBRARIES) +# add_definitions("-DEIGEN_PARDISO_SUPPORT") +# set(SPARSE_LIBS ${SPARSE_LIBS} ${PARDISO_LIBRARIES}) +# endif(PARDISO_LIBRARIES) + +find_package(Cholmod) +if(CHOLMOD_FOUND AND BLAS_FOUND AND LAPACK_FOUND) + add_definitions("-DEIGEN_CHOLMOD_SUPPORT") + include_directories(${CHOLMOD_INCLUDES}) + set(SPARSE_LIBS ${SPARSE_LIBS} ${CHOLMOD_LIBRARIES} ${BLAS_LIBRARIES} ${LAPACK_LIBRARIES}) + set(CHOLMOD_ALL_LIBS ${CHOLMOD_LIBRARIES} ${BLAS_LIBRARIES} ${LAPACK_LIBRARIES}) +endif() + +find_package(Umfpack) +if(UMFPACK_FOUND AND BLAS_FOUND) + add_definitions("-DEIGEN_UMFPACK_SUPPORT") + include_directories(${UMFPACK_INCLUDES}) + set(SPARSE_LIBS ${SPARSE_LIBS} ${UMFPACK_LIBRARIES} ${BLAS_LIBRARIES}) + set(UMFPACK_ALL_LIBS ${UMFPACK_LIBRARIES} ${BLAS_LIBRARIES}) +endif() + +find_package(SuperLU) +if(SUPERLU_FOUND AND BLAS_FOUND) + add_definitions("-DEIGEN_SUPERLU_SUPPORT") + include_directories(${SUPERLU_INCLUDES}) + set(SPARSE_LIBS ${SPARSE_LIBS} ${SUPERLU_LIBRARIES} ${BLAS_LIBRARIES}) + set(SUPERLU_ALL_LIBS ${SUPERLU_LIBRARIES} ${BLAS_LIBRARIES}) +endif() + + +find_package(Pastix) +find_package(Scotch) +find_package(Metis) +if(PASTIX_FOUND AND BLAS_FOUND) + add_definitions("-DEIGEN_PASTIX_SUPPORT") + include_directories(${PASTIX_INCLUDES}) + if(SCOTCH_FOUND) + include_directories(${SCOTCH_INCLUDES}) + set(PASTIX_LIBRARIES ${PASTIX_LIBRARIES} ${SCOTCH_LIBRARIES}) + elseif(METIS_FOUND) + include_directories(${METIS_INCLUDES}) + set(PASTIX_LIBRARIES ${PASTIX_LIBRARIES} ${METIS_LIBRARIES}) + endif(SCOTCH_FOUND) + set(SPARSE_LIBS ${SPARSE_LIBS} ${PASTIX_LIBRARIES} ${ORDERING_LIBRARIES} ${BLAS_LIBRARIES}) + set(PASTIX_ALL_LIBS ${PASTIX_LIBRARIES} ${BLAS_LIBRARIES}) +endif(PASTIX_FOUND AND BLAS_FOUND) + +find_library(RT_LIBRARY rt) +if(RT_LIBRARY) + set(SPARSE_LIBS ${SPARSE_LIBS} ${RT_LIBRARY}) +endif(RT_LIBRARY) + +add_executable(spbenchsolver spbenchsolver.cpp) +target_link_libraries (spbenchsolver ${SPARSE_LIBS}) + diff --git a/bench/spbench/spbenchsolver.cpp b/bench/spbench/spbenchsolver.cpp new file mode 100644 index 000000000..bcbe0d84f --- /dev/null +++ b/bench/spbench/spbenchsolver.cpp @@ -0,0 +1,79 @@ +#include + +void bench_printhelp() +{ + cout<< " \nbenchsolver : performs a benchmark of all the solvers available in Eigen \n\n"; + cout<< " MATRIX FOLDER : \n"; + cout<< " The matrices for the benchmark should be collected in a folder specified with an environment variable EIGEN_MATRIXDIR \n"; + cout<< " This folder should contain the subfolders real/ and complex/ : \n"; + cout<< " The matrices are stored using the matrix market coordinate format \n"; + cout<< " The matrix and associated right-hand side (rhs) files are named respectively \n"; + cout<< " as MatrixName.mtx and MatrixName_b.mtx. If the rhs does not exist, a random one is generated. \n"; + cout<< " If a matrix is SPD, the matrix should be named as MatrixName_SPD.mtx \n"; + cout<< " If a true solution exists, it should be named as MatrixName_x.mtx; \n" ; + cout<< " it will be used to compute the norm of the error relative to the computed solutions\n\n"; + cout<< " OPTIONS : \n"; + cout<< " -h or --help \n print this help and return\n\n"; + cout<< " -d matrixdir \n Use matrixdir as the matrix folder instead of the one specified in the environment variable EIGEN_MATRIXDIR\n\n"; + cout<< " -o outputfile.html \n Output the statistics to a html file \n\n"; + +} +int main(int argc, char ** args) +{ + + bool help = ( get_options(argc, args, "-h") || get_options(argc, args, "--help") ); + if(help) { + bench_printhelp(); + return 0; + } + + // Get the location of the test matrices + string matrix_dir; + if (!get_options(argc, args, "-d", &matrix_dir)) + { + if(getenv("EIGEN_MATRIXDIR") == NULL){ + std::cerr << "Please, specify the location of the matrices with -d mat_folder or the environment variable EIGEN_MATRIXDIR \n"; + std::cerr << " Run with --help to see the list of all the available options \n"; + return -1; + } + matrix_dir = getenv("EIGEN_MATRIXDIR"); + } + + std::ofstream statbuf; + string statFile ; + + // Get the file to write the statistics + bool statFileExists = get_options(argc, args, "-o", &statFile); + if(statFileExists) + { + statbuf.open(statFile.c_str(), std::ios::out); + if(statbuf.good()){ + statFileExists = true; + printStatheader(statbuf); + statbuf.close(); + } + else + std::cerr << "Unable to open the provided file for writting... \n"; + } + + string current_dir; + // Test the matrices in %EIGEN_MATRIXDIR/real + current_dir = matrix_dir + "/real"; + Browse_Matrices(current_dir, statFileExists, statFile); + + // Test the matrices in %EIGEN_MATRIXDIR/complex + current_dir = matrix_dir + "/complex"; + Browse_Matrices >(current_dir, statFileExists, statFile); + + if(statFileExists) + { + statbuf.open(statFile.c_str(), std::ios::app); + statbuf << " \n"; + cout << "\n Output written in " << statFile << " ...\n"; + statbuf.close(); + } + + return 0; +} + + diff --git a/bench/spbench/spbenchsolver.h b/bench/spbench/spbenchsolver.h new file mode 100644 index 000000000..2dffb3b4b --- /dev/null +++ b/bench/spbench/spbenchsolver.h @@ -0,0 +1,539 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. +// +// Copyright (C) 2012 Désiré Nuentsa-Wakam +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see . + + +#include +#include +#include "Eigen/SparseCore" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef EIGEN_CHOLMOD_SUPPORT +#include +#endif + +#ifdef EIGEN_UMFPACK_SUPPORT +#include +#endif + +#ifdef EIGEN_PARDISO_SUPPORT +#include +#endif + +#ifdef EIGEN_SUPERLU_SUPPORT +#include +#endif + +#ifdef EIGEN_PASTIX_SUPPORT +#include +#endif + +// CONSTANTS +#define EIGEN_UMFPACK 0 +#define EIGEN_SUPERLU 1 +#define EIGEN_PASTIX 2 +#define EIGEN_PARDISO 3 +#define EIGEN_BICGSTAB 4 +#define EIGEN_BICGSTAB_ILUT 5 +#define EIGEN_GMRES 6 +#define EIGEN_GMRES_ILUT 7 +#define EIGEN_SIMPLICIAL_LDLT 8 +#define EIGEN_CHOLMOD_LDLT 9 +#define EIGEN_PASTIX_LDLT 10 +#define EIGEN_PARDISO_LDLT 11 +#define EIGEN_SIMPLICIAL_LLT 12 +#define EIGEN_CHOLMOD_SUPERNODAL_LLT 13 +#define EIGEN_CHOLMOD_SIMPLICIAL_LLT 14 +#define EIGEN_PASTIX_LLT 15 +#define EIGEN_PARDISO_LLT 16 +#define EIGEN_CG 17 +#define EIGEN_CG_PRECOND 18 +#define EIGEN_ALL_SOLVERS 19 + +using namespace Eigen; +using namespace std; + +struct Stats{ + ComputationInfo info; + double total_time; + double compute_time; + double solve_time; + double rel_error; + int memory_used; + int iterations; + int isavail; + int isIterative; +}; + +template inline typename NumTraits::Real test_precision() { return NumTraits::dummy_precision(); } +template<> inline float test_precision() { return 1e-3f; } +template<> inline double test_precision() { return 1e-6; } +template<> inline float test_precision >() { return test_precision(); } +template<> inline double test_precision >() { return test_precision(); } + +void printStatheader(std::ofstream& out) +{ + int LUcnt = 0; + string LUlist =" ", LLTlist = " LLT", LDLTlist = " LDLT "; + +#ifdef EIGEN_UMFPACK_SUPPORT + LUlist += " UMFPACK "; LUcnt++; +#endif +#ifdef EIGEN_SUPERLU_SUPPORT + LUlist += " SUPERLU "; LUcnt++; +#endif +#ifdef EIGEN_CHOLMOD_SUPPORT + LLTlist += " CHOLMOD SP LLT CHOLMOD LLT"; + LDLTlist += "CHOLMOD LDLT"; +#endif +#ifdef EIGEN_PARDISO_SUPPORT + LUlist += " PARDISO LU"; LUcnt++; + LLTlist += " PARDISO LLT"; + LDLTlist += " PARDISO LDLT"; +#endif +#ifdef EIGEN_PASTIX_SUPPORT + LUlist += " PASTIX LU"; LUcnt++; + LLTlist += " PASTIX LLT"; + LDLTlist += " PASTIX LDLT"; +#endif + + out << "\n "; + out << "
Matrix N NNZ "; + if (LUcnt) out << LUlist; + out << " BiCGSTAB BiCGSTAB+ILUT"<< "GMRES+ILUT" < CG "<< std::endl; +} + + +template +Stats call_solver(Solver &solver, const typename Solver::MatrixType& A, const Matrix& b, const Matrix& refX) +{ + Stats stat; + Matrix x; + BenchTimer timer; + timer.reset(); + timer.start(); + solver.compute(A); + if (solver.info() != Success) + { + stat.info = NumericalIssue; + std::cerr << "Solver failed ... \n"; + return stat; + } + timer.stop(); + stat.compute_time = timer.value(); + + timer.reset(); + timer.start(); + x = solver.solve(b); + if (solver.info() == NumericalIssue) + { + stat.info = NumericalIssue; + std::cerr << "Solver failed ... \n"; + return stat; + } + + timer.stop(); + stat.solve_time = timer.value(); + stat.total_time = stat.solve_time + stat.compute_time; + stat.memory_used = 0; + // Verify the relative error + if(refX.size() != 0) + stat.rel_error = (refX - x).norm()/refX.norm(); + else + { + // Compute the relative residual norm + Matrix temp; + temp = A * x; + stat.rel_error = (b-temp).norm()/b.norm(); + } + if ( stat.rel_error > test_precision() ) + { + stat.info = NoConvergence; + return stat; + } + else + { + stat.info = Success; + return stat; + } +} + +template +Stats call_directsolver(Solver& solver, const typename Solver::MatrixType& A, const Matrix& b, const Matrix& refX) +{ + Stats stat; + stat = call_solver(solver, A, b, refX); + return stat; +} + +template +Stats call_itersolver(Solver &solver, const typename Solver::MatrixType& A, const Matrix& b, const Matrix& refX) +{ + Stats stat; + solver.setTolerance(1e-10); + stat = call_solver(solver, A, b, refX); + stat.iterations = solver.iterations(); + return stat; +} + +inline void printStatItem(Stats *stat, int solver_id, int& best_time_id, double& best_time_val) +{ + stat[solver_id].isavail = 1; + + if (stat[solver_id].info == NumericalIssue) + { + cout << " SOLVER FAILED ... Probably a numerical issue \n"; + return; + } + if (stat[solver_id].info == NoConvergence){ + cout << "REL. ERROR " << stat[solver_id].rel_error; + if(stat[solver_id].isIterative == 1) + cout << " (" << stat[solver_id].iterations << ") \n"; + return; + } + + // Record the best CPU time + if (!best_time_val) + { + best_time_val = stat[solver_id].total_time; + best_time_id = solver_id; + } + else if (stat[solver_id].total_time < best_time_val) + { + best_time_val = stat[solver_id].total_time; + best_time_id = solver_id; + } + // Print statistics to standard output + if (stat[solver_id].info == Success){ + cout<< "COMPUTE TIME : " << stat[solver_id].compute_time<< " \n"; + cout<< "SOLVE TIME : " << stat[solver_id].solve_time<< " \n"; + cout<< "TOTAL TIME : " << stat[solver_id].total_time<< " \n"; + cout << "REL. ERROR : " << stat[solver_id].rel_error ; + if(stat[solver_id].isIterative == 1) { + cout << " (" << stat[solver_id].iterations << ") "; + } + cout << std::endl; + } + +} + + +/* Print the results from all solvers corresponding to a particular matrix + * The best CPU time is printed in bold + */ +inline void printHtmlStatLine(Stats *stat, int best_time_id, string& statline) +{ + + string markup; + ostringstream compute,solve,total,error; + for (int i = 0; i < EIGEN_ALL_SOLVERS; i++) + { + if (stat[i].isavail == 0) continue; + if(i == best_time_id) + markup = ""; + else + markup = ""; + + if (stat[i].info == Success){ + compute << markup << stat[i].compute_time; + solve << markup << stat[i].solve_time; + total << markup << stat[i].total_time; + error << " " << stat[i].rel_error; + if(stat[i].isIterative == 1) { + error << " (" << stat[i].iterations << ") "; + } + } + else { + compute << " -" ; + solve << " -" ; + total << " -" ; + if(stat[i].info == NoConvergence){ + error << " "<< stat[i].rel_error ; + if(stat[i].isIterative == 1) + error << " (" << stat[i].iterations << ") "; + } + else error << " - "; + } + } + + statline = "Compute Time " + compute.str() + "\n" + + "
Solve Time " + solve.str() + "\n" + + "
Total Time " + total.str() + "\n" + +"
Error(Iter)" + error.str() + "\n"; + +} + +template +int SelectSolvers(const SparseMatrix&A, unsigned int sym, Matrix& b, const Matrix& refX, Stats *stat) +{ + typedef SparseMatrix SpMat; + // First, deal with Nonsymmetric and symmetric matrices + int best_time_id = 0; + double best_time_val = 0.0; + //UMFPACK + #ifdef EIGEN_UMFPACK_SUPPORT + { + cout << "Solving with UMFPACK LU ... \n"; + UmfPackLU solver; + stat[EIGEN_UMFPACK] = call_directsolver(solver, A, b, refX); + printStatItem(stat, EIGEN_UMFPACK, best_time_id, best_time_val); + } + #endif + //SuperLU + #ifdef EIGEN_SUPERLU_SUPPORT + { + cout << "\nSolving with SUPERLU ... \n"; + SuperLU solver; + stat[EIGEN_SUPERLU] = call_directsolver(solver, A, b, refX); + printStatItem(stat, EIGEN_SUPERLU, best_time_id, best_time_val); + } + #endif + + // PaStix LU + #ifdef EIGEN_PASTIX_SUPPORT + { + cout << "\nSolving with PASTIX LU ... \n"; + PastixLU solver; + stat[EIGEN_PASTIX] = call_directsolver(solver, A, b, refX) ; + printStatItem(stat, EIGEN_PASTIX, best_time_id, best_time_val); + } + #endif + + //PARDISO LU + #ifdef EIGEN_PARDISO_SUPPORT + { + cout << "\nSolving with PARDISO LU ... \n"; + PardisoLU solver; + stat[EIGEN_PARDISO] = call_directsolver(solver, A, b, refX); + printStatItem(stat, EIGEN_PARDISO, best_time_id, best_time_val); + } + #endif + + + + //BiCGSTAB + { + cout << "\nSolving with BiCGSTAB ... \n"; + BiCGSTAB solver; + stat[EIGEN_BICGSTAB] = call_itersolver(solver, A, b, refX); + stat[EIGEN_BICGSTAB].isIterative = 1; + printStatItem(stat, EIGEN_BICGSTAB, best_time_id, best_time_val); + } + //BiCGSTAB+ILUT + { + cout << "\nSolving with BiCGSTAB and ILUT ... \n"; + BiCGSTAB > solver; + stat[EIGEN_BICGSTAB_ILUT] = call_itersolver(solver, A, b, refX); + stat[EIGEN_BICGSTAB_ILUT].isIterative = 1; + printStatItem(stat, EIGEN_BICGSTAB_ILUT, best_time_id, best_time_val); + } + + + //GMRES +// { +// cout << "\nSolving with GMRES ... \n"; +// GMRES solver; +// stat[EIGEN_GMRES] = call_itersolver(solver, A, b, refX); +// stat[EIGEN_GMRES].isIterative = 1; +// printStatItem(stat, EIGEN_GMRES, best_time_id, best_time_val); +// } + //GMRES+ILUT + { + cout << "\nSolving with GMRES and ILUT ... \n"; + GMRES > solver; + stat[EIGEN_GMRES_ILUT] = call_itersolver(solver, A, b, refX); + stat[EIGEN_GMRES_ILUT].isIterative = 1; + printStatItem(stat, EIGEN_GMRES_ILUT, best_time_id, best_time_val); + } + + // Symmetric and not necessarily positive-definites + if ( (sym == Symmetric) || (sym == SPD) ) + { + // Internal Cholesky + { + cout << "\nSolving with Simplicial LDLT ... \n"; + SimplicialLDLT solver; + stat[EIGEN_SIMPLICIAL_LDLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat, EIGEN_SIMPLICIAL_LDLT, best_time_id, best_time_val); + } + + // CHOLMOD + #ifdef EIGEN_CHOLMOD_SUPPORT + { + cout << "\nSolving with CHOLMOD LDLT ... \n"; + CholmodDecomposition solver; + solver.setMode(CholmodLDLt); + stat[EIGEN_CHOLMOD_LDLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_CHOLMOD_LDLT, best_time_id, best_time_val); + } + #endif + + //PASTIX LLT + #ifdef EIGEN_PASTIX_SUPPORT + { + cout << "\nSolving with PASTIX LDLT ... \n"; + PastixLDLT solver; + stat[EIGEN_PASTIX_LDLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_PASTIX_LDLT, best_time_id, best_time_val); + } + #endif + + //PARDISO LLT + #ifdef EIGEN_PARDISO_SUPPORT + { + cout << "\nSolving with PARDISO LDLT ... \n"; + PardisoLDLT solver; + stat[EIGEN_PARDISO_LDLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_PARDISO_LDLT, best_time_id, best_time_val); + } + #endif + } + + // Now, symmetric POSITIVE DEFINITE matrices + if (sym == SPD) + { + + //Internal Sparse Cholesky + { + cout << "\nSolving with SIMPLICIAL LLT ... \n"; + SimplicialLLT solver; + stat[EIGEN_SIMPLICIAL_LLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_SIMPLICIAL_LLT, best_time_id, best_time_val); + } + + // CHOLMOD + #ifdef EIGEN_CHOLMOD_SUPPORT + { + // CholMOD SuperNodal LLT + cout << "\nSolving with CHOLMOD LLT (Supernodal)... \n"; + CholmodDecomposition solver; + solver.setMode(CholmodSupernodalLLt); + stat[EIGEN_CHOLMOD_SUPERNODAL_LLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_CHOLMOD_SUPERNODAL_LLT, best_time_id, best_time_val); + // CholMod Simplicial LLT + cout << "\nSolving with CHOLMOD LLT (Simplicial) ... \n"; + solver.setMode(CholmodSimplicialLLt); + stat[EIGEN_CHOLMOD_SIMPLICIAL_LLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_CHOLMOD_SIMPLICIAL_LLT, best_time_id, best_time_val); + } + #endif + + //PASTIX LLT + #ifdef EIGEN_PASTIX_SUPPORT + { + cout << "\nSolving with PASTIX LLT ... \n"; + PastixLLT solver; + stat[EIGEN_PASTIX_LLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_PASTIX_LLT, best_time_id, best_time_val); + } + #endif + + //PARDISO LLT + #ifdef EIGEN_PARDISO_SUPPORT + { + cout << "\nSolving with PARDISO LLT ... \n"; + PardisoLLT solver; + stat[EIGEN_PARDISO_LLT] = call_directsolver(solver, A, b, refX); + printStatItem(stat,EIGEN_PARDISO_LLT, best_time_id, best_time_val); + } + #endif + + // Internal CG + { + cout << "\nSolving with CG ... \n"; + ConjugateGradient solver; + stat[EIGEN_CG] = call_itersolver(solver, A, b, refX); + stat[EIGEN_CG].isIterative = 1; + printStatItem(stat,EIGEN_CG, best_time_id, best_time_val); + } + //CG+IdentityPreconditioner +// { +// cout << "\nSolving with CG and IdentityPreconditioner ... \n"; +// ConjugateGradient solver; +// stat[EIGEN_CG_PRECOND] = call_itersolver(solver, A, b, refX); +// stat[EIGEN_CG_PRECOND].isIterative = 1; +// printStatItem(stat,EIGEN_CG_PRECOND, best_time_id, best_time_val); +// } + } // End SPD matrices + + return best_time_id; +} + +/* 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 +void Browse_Matrices(const string folder, bool statFileExists, std::string& statFile) +{ + MatrixMarketIterator it(folder); + Stats stat[EIGEN_ALL_SOLVERS]; + for ( ; it; ++it) + { + for (int i = 0; i < EIGEN_ALL_SOLVERS; i++) + { + stat[i].isavail = 0; + stat[i].isIterative = 0; + } + + int best_time_id; + cout<< "\n\n===================================================== \n"; + cout<< " ====== SOLVING WITH MATRIX " << it.matname() << " ====\n"; + cout<< " =================================================== \n\n"; + Matrix refX; + if(it.hasrefX()) refX = it.refX(); + best_time_id = SelectSolvers(it.matrix(), it.sym(), it.rhs(), refX, &stat[0]); + + if(statFileExists) + { + string statline; + printHtmlStatLine(&stat[0], best_time_id, statline); + std::ofstream statbuf(statFile.c_str(), std::ios::app); + statbuf << "
" << it.matname() << " " + << it.matrix().rows() << " " << it.matrix().nonZeros()<< " "<< statline ; + statbuf.close(); + } + } +} + +bool get_options(int argc, char **args, string option, string* value=0) +{ + int idx = 1, found=false; + while (idx