Simplified BdaSolverStatus

This commit is contained in:
T.D. (Tongdong) Qiu 2020-07-02 12:11:42 +02:00
parent 833ea8ae72
commit 779a713330
7 changed files with 24 additions and 67 deletions

View File

@ -26,7 +26,6 @@
#include <opm/material/common/Unused.hpp>
#include <opm/simulators/linalg/bda/BdaBridge.hpp>
#include <opm/simulators/linalg/bda/BdaSolverStatus.hpp>
#include <opm/simulators/linalg/bda/BdaResult.hpp>
#define PRINT_TIMERS_BRIDGE 0
@ -38,7 +37,7 @@ namespace Opm
using bda::BdaResult;
using bda::BdaSolver;
using bda::BdaSolverStatus;
using bda::SolverStatus;
template <class BridgeMatrix, class BridgeVector, int block_size>
BdaBridge<BridgeMatrix, BridgeVector, block_size>::BdaBridge(std::string gpu_mode, int linear_solver_verbosity, int maxit, double tolerance, unsigned int platformID, unsigned int deviceID)
@ -180,17 +179,16 @@ void BdaBridge<BridgeMatrix, BridgeVector, block_size>::solve_system(BridgeMatri
/////////////////////////
// actually solve
typedef BdaSolverStatus::Status Status;
// assume that underlying data (nonzeroes) from mat (Dune::BCRSMatrix) are contiguous, if this is not the case, cusparseSolver is expected to perform undefined behaviour
Status status = backend->solve_system(N, nnz, dim, static_cast<double*>(&(((*mat)[0][0][0][0]))), h_rows.data(), h_cols.data(), static_cast<double*>(&(b[0][0])), wellContribs, result);
SolverStatus status = backend->solve_system(N, nnz, dim, static_cast<double*>(&(((*mat)[0][0][0][0]))), h_rows.data(), h_cols.data(), static_cast<double*>(&(b[0][0])), wellContribs, result);
switch(status) {
case Status::BDA_SOLVER_SUCCESS:
case SolverStatus::BDA_SOLVER_SUCCESS:
//OpmLog::info("BdaSolver converged");
break;
case Status::BDA_SOLVER_ANALYSIS_FAILED:
case SolverStatus::BDA_SOLVER_ANALYSIS_FAILED:
OpmLog::warning("BdaSolver could not analyse level information of matrix, perhaps there is still a 0.0 on the diagonal of a block on the diagonal");
break;
case Status::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED:
case SolverStatus::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED:
OpmLog::warning("BdaSolver could not create preconditioner, perhaps there is still a 0.0 on the diagonal of a block on the diagonal");
break;
default:

View File

@ -22,14 +22,19 @@
#include <opm/simulators/linalg/bda/BdaResult.hpp>
#include <opm/simulators/linalg/bda/BdaSolverStatus.hpp>
#include <opm/simulators/linalg/bda/WellContributions.hpp>
namespace bda
{
using Opm::WellContributions;
typedef BdaSolverStatus::Status Status;
enum class SolverStatus {
BDA_SOLVER_SUCCESS,
BDA_SOLVER_ANALYSIS_FAILED,
BDA_SOLVER_CREATE_PRECONDITIONER_FAILED,
BDA_SOLVER_UNKNOWN_ERROR
};
/// This class serves to simplify choosing between different backend solvers, such as cusparseSolver and openclSolver
/// This class is abstract, no instantiations can of it can be made, only of its children
@ -75,7 +80,7 @@ namespace bda
virtual ~BdaSolver() {};
/// Define as pure virtual functions, so derivedclass must implement them
virtual Status solve_system(int N, int nnz, int dim,
virtual SolverStatus solve_system(int N, int nnz, int dim,
double *vals, int *rows, int *cols,
double *b, WellContributions& wellContribs, BdaResult &res) = 0;

View File

@ -1,42 +0,0 @@
/*
Copyright 2019 Equinor ASA
This file is part of the Open Porous Media project (OPM).
OPM is free software: 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 3 of the License, or
(at your option) any later version.
OPM 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_BDASOLVERSTATUS_HEADER_INCLUDED
#define OPM_BDASOLVERSTATUS_HEADER_INCLUDED
namespace bda
{
class BdaSolverStatus
{
public:
enum class Status {
BDA_SOLVER_SUCCESS,
BDA_SOLVER_ANALYSIS_FAILED,
BDA_SOLVER_CREATE_PRECONDITIONER_FAILED,
BDA_SOLVER_UNKNOWN_ERROR
};
}; // end class BdaSolverStatus
} // end namespace bda
#endif

View File

@ -475,10 +475,9 @@ void cusparseSolverBackend<block_size>::get_result(double *x) {
} // end get_result()
typedef BdaSolverStatus::Status Status;
template <unsigned int block_size>
Status cusparseSolverBackend<block_size>::solve_system(int N, int nnz, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) {
SolverStatus cusparseSolverBackend<block_size>::solve_system(int N, int nnz, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) {
if (initialized == false) {
initialize(N, nnz, dim);
copy_system_to_gpu(vals, rows, cols, b);
@ -487,16 +486,16 @@ Status cusparseSolverBackend<block_size>::solve_system(int N, int nnz, int dim,
}
if (analysis_done == false) {
if (!analyse_matrix()) {
return Status::BDA_SOLVER_ANALYSIS_FAILED;
return SolverStatus::BDA_SOLVER_ANALYSIS_FAILED;
}
}
reset_prec_on_gpu();
if (create_preconditioner()) {
solve_system(wellContribs, res);
} else {
return Status::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED;
return SolverStatus::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED;
}
return Status::BDA_SOLVER_SUCCESS;
return SolverStatus::BDA_SOLVER_SUCCESS;
}

View File

@ -46,7 +46,6 @@ class cusparseSolverBackend : public BdaSolver<block_size> {
using Base::maxit;
using Base::tolerance;
using Base::initialized;
typedef BdaSolverStatus::Status Status;
private:
@ -135,7 +134,7 @@ public:
/// \param[in] wellContribs contains all WellContributions, to apply them separately, instead of adding them to matrix A
/// \param[inout] res summary of solver result
/// \return status code
Status solve_system(int N, int nnz, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) override;
SolverStatus solve_system(int N, int nnz, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) override;
/// Get resulting vector x after linear solve, also includes post processing if necessary
/// \param[inout] x resulting x vector, caller must guarantee that x points to a valid array

View File

@ -681,31 +681,30 @@ void openclSolverBackend<block_size>::get_result(double *x) {
} // end get_result()
typedef BdaSolverStatus::Status Status;
template <unsigned int block_size>
Status openclSolverBackend<block_size>::solve_system(int N_, int nnz_, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) {
SolverStatus openclSolverBackend<block_size>::solve_system(int N_, int nnz_, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) {
if (initialized == false) {
initialize(N_, nnz_, dim, vals, rows, cols);
if (analysis_done == false) {
if (!analyse_matrix()) {
return Status::BDA_SOLVER_ANALYSIS_FAILED;
return SolverStatus::BDA_SOLVER_ANALYSIS_FAILED;
}
}
update_system(vals, b);
if (!create_preconditioner()) {
return Status::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED;
return SolverStatus::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED;
}
copy_system_to_gpu();
} else {
update_system(vals, b);
if (!create_preconditioner()) {
return Status::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED;
return SolverStatus::BDA_SOLVER_CREATE_PRECONDITIONER_FAILED;
}
update_system_on_gpu();
}
solve_system(wellContribs, res);
return Status::BDA_SOLVER_SUCCESS;
return SolverStatus::BDA_SOLVER_SUCCESS;
}

View File

@ -53,7 +53,6 @@ class openclSolverBackend : public BdaSolver<block_size>
using Base::maxit;
using Base::tolerance;
using Base::initialized;
typedef BdaSolverStatus::Status Status;
private:
@ -199,7 +198,7 @@ public:
/// \param[in] wellContribs WellContributions, to apply them separately, instead of adding them to matrix A
/// \param[inout] res summary of solver result
/// \return status code
Status solve_system(int N, int nnz, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) override;
SolverStatus solve_system(int N, int nnz, int dim, double *vals, int *rows, int *cols, double *b, WellContributions& wellContribs, BdaResult &res) override;
/// Get result after linear solve, and peform postprocessing if necessary
/// \param[inout] x resulting x vector, caller must guarantee that x points to a valid array