Commit ab4bfaee authored by Mattijs Janssens's avatar Mattijs Janssens Committed by Andrew Heather
Browse files

ENH: lduMatrix: new matrix solvers: PPCG,PPCR

PPCG is pipelined version of PCG, PPCR is conjugate
residual version.
parent 2c4b639e
......@@ -383,6 +383,8 @@ $(lduMatrix)/solvers/smoothSolver/smoothSolver.C
$(lduMatrix)/solvers/PCG/PCG.C
$(lduMatrix)/solvers/PBiCG/PBiCG.C
$(lduMatrix)/solvers/PBiCGStab/PBiCGStab.C
$(lduMatrix)/solvers/PPCG/PPCG.C
$(lduMatrix)/solvers/PPCR/PPCR.C
$(lduMatrix)/smoothers/GaussSeidel/GaussSeidelSmoother.C
$(lduMatrix)/smoothers/symGaussSeidel/symGaussSeidelSmoother.C
......
......@@ -156,6 +156,21 @@ void reduce
NotImplemented;
}
// Non-blocking version of reduce. Sets request.
template<class T, class BinaryOp>
void reduce
(
T Value[],
const int size,
const BinaryOp& bop,
const int tag,
const label comm,
label& request
)
{
NotImplemented;
}
// Insist there are specialisations for the common reductions of scalar(s)
void reduce
......@@ -199,6 +214,16 @@ void reduce
label& request
);
void reduce
(
scalar Value[],
const int size,
const sumOp<scalar>& bop,
const int tag,
const label comm,
label& request
);
#if defined(WM_SPDP)
void reduce
......@@ -241,6 +266,16 @@ void reduce
const label comm,
label& request
);
void reduce
(
solveScalar Value[],
const int size,
const sumOp<solveScalar>& bop,
const int tag,
const label comm,
label& request
);
#endif
......
......@@ -708,7 +708,8 @@ public:
const lduInterfaceFieldPtrsList& interfaces,
const solveScalarField& psiif,
solveScalarField& result,
const direction cmpt
const direction cmpt,
const label startRequest // starting request (for non-blocking)
) const;
//- Set the residual field using an IOField on the object registry
......
......@@ -56,6 +56,8 @@ void Foam::lduMatrix::Amul
const scalar* const __restrict__ upperPtr = upper().begin();
const scalar* const __restrict__ lowerPtr = lower().begin();
const label startRequest = Pstream::nRequests();
// Initialise the update of interfaced interfaces
initMatrixInterfaces
(
......@@ -90,7 +92,8 @@ void Foam::lduMatrix::Amul
interfaces,
psi,
Apsi,
cmpt
cmpt,
startRequest
);
tpsi.clear();
......@@ -119,6 +122,8 @@ void Foam::lduMatrix::Tmul
const scalar* const __restrict__ lowerPtr = lower().begin();
const scalar* const __restrict__ upperPtr = upper().begin();
const label startRequest = Pstream::nRequests();
// Initialise the update of interfaced interfaces
initMatrixInterfaces
(
......@@ -151,7 +156,8 @@ void Foam::lduMatrix::Tmul
interfaces,
psi,
Tpsi,
cmpt
cmpt,
startRequest
);
tpsi.clear();
......@@ -240,6 +246,8 @@ void Foam::lduMatrix::residual
// To compensate for this, it is necessary to turn the
// sign of the contribution.
const label startRequest = Pstream::nRequests();
// Initialise the update of interfaced interfaces
initMatrixInterfaces
(
......@@ -274,7 +282,8 @@ void Foam::lduMatrix::residual
interfaces,
psi,
rA,
cmpt
cmpt,
startRequest
);
}
......
......@@ -106,7 +106,8 @@ void Foam::lduMatrix::updateMatrixInterfaces
const lduInterfaceFieldPtrsList& interfaces,
const solveScalarField& psiif,
solveScalarField& result,
const direction cmpt
const direction cmpt,
const label startRequest
) const
{
if (Pstream::defaultCommsType == Pstream::commsTypes::blocking)
......@@ -183,7 +184,7 @@ void Foam::lduMatrix::updateMatrixInterfaces
else
{
// Block for all requests and remove storage
UPstream::waitRequests();
UPstream::waitRequests(startRequest);
}
}
......
......@@ -115,6 +115,8 @@ void Foam::GaussSeidelSmoother::smooth
{
bPrime = source;
const label startRequest = Pstream::nRequests();
matrix_.initMatrixInterfaces
(
false,
......@@ -132,7 +134,8 @@ void Foam::GaussSeidelSmoother::smooth
interfaces_,
psi,
bPrime,
cmpt
cmpt,
startRequest
);
solveScalar psii;
......
......@@ -142,6 +142,8 @@ void Foam::nonBlockingGaussSeidelSmoother::smooth
{
bPrime = source;
const label startRequest = Pstream::nRequests();
matrix_.initMatrixInterfaces
(
false,
......@@ -190,7 +192,8 @@ void Foam::nonBlockingGaussSeidelSmoother::smooth
interfaces_,
psi,
bPrime,
cmpt
cmpt,
startRequest
);
// Update rest of the cells
......
......@@ -115,6 +115,8 @@ void Foam::symGaussSeidelSmoother::smooth
{
bPrime = source;
const label startRequest = Pstream::nRequests();
matrix_.initMatrixInterfaces
(
false,
......@@ -132,7 +134,8 @@ void Foam::symGaussSeidelSmoother::smooth
interfaces_,
psi,
bPrime,
cmpt
cmpt,
startRequest
);
solveScalar psii;
......
......@@ -52,6 +52,8 @@ void Foam::GAMGSolver::interpolate
Apsi = 0;
solveScalar* __restrict__ ApsiPtr = Apsi.begin();
const label startRequest = Pstream::nRequests();
m.initMatrixInterfaces
(
true,
......@@ -76,7 +78,8 @@ void Foam::GAMGSolver::interpolate
interfaces,
psi,
Apsi,
cmpt
cmpt,
startRequest
);
const label nCells = m.diag().size();
......
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019-2020 M. Janssens
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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.
OpenFOAM 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 OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "PPCG.H"
#include "PrecisionAdaptor.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(PPCG, 0);
lduMatrix::solver::addsymMatrixConstructorToTable<PPCG>
addPPCGSymMatrixConstructorToTable_;
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::PPCG::gSumMagProd
(
FixedList<solveScalar, 3>& globalSum,
const solveScalarField& a,
const solveScalarField& b,
const solveScalarField& c,
const solveScalarField& sumMag,
label& outstandingRequest,
const label comm
) const
{
const label nCells = a.size();
globalSum = 0.0;
for (label cell=0; cell<nCells; cell++)
{
globalSum[0] += a[cell]*b[cell]; // sumProd(a, b)
globalSum[1] += a[cell]*c[cell]; // sumProd(a, c)
globalSum[2] += mag(sumMag[cell]);
}
if (Pstream::parRun())
{
Foam::reduce
(
globalSum.begin(),
globalSum.size(),
sumOp<solveScalar>(),
Pstream::msgType(),
comm,
outstandingRequest
);
}
}
Foam::solverPerformance Foam::PPCG::scalarSolve
(
solveScalarField& psi,
const solveScalarField& source,
const direction cmpt,
const bool cgMode
) const
{
// --- Setup class containing solver performance data
solverPerformance solverPerf
(
lduMatrix::preconditioner::getName(controlDict_) + type(),
fieldName_
);
const label comm = matrix().mesh().comm();
const label nCells = psi.size();
solveScalarField w(nCells);
// --- Calculate A.psi
matrix_.Amul(w, psi, interfaceBouCoeffs_, interfaces_, cmpt);
// --- Calculate initial residual field
solveScalarField r(source - w);
// --- Calculate normalisation factor
solveScalarField p(nCells);
const solveScalar normFactor = this->normFactor(psi, source, w, p);
if (lduMatrix::debug >= 2)
{
Info<< " Normalisation factor = " << normFactor << endl;
}
// --- Select and construct the preconditioner
autoPtr<lduMatrix::preconditioner> preconPtr =
lduMatrix::preconditioner::New
(
*this,
controlDict_
);
// --- Precondition residual (= u0)
solveScalarField u(nCells);
preconPtr->precondition(u, r, cmpt);
// --- Calculate A*u - reuse w
matrix_.Amul(w, u, interfaceBouCoeffs_, interfaces_, cmpt);
// State
solveScalarField s(nCells);
solveScalarField q(nCells);
solveScalarField z(nCells);
solveScalarField m(nCells);
FixedList<solveScalar, 3> globalSum;
label outstandingRequest = -1;
if (cgMode)
{
// --- Start global reductions for inner products
gSumMagProd(globalSum, u, r, w, r, outstandingRequest, comm);
// --- Precondition residual
preconPtr->precondition(m, w, cmpt);
}
else
{
// --- Precondition residual
preconPtr->precondition(m, w, cmpt);
// --- Start global reductions for inner products
gSumMagProd(globalSum, w, u, m, r, outstandingRequest, comm);
}
// --- Calculate A*m
solveScalarField n(nCells);
matrix_.Amul(n, m, interfaceBouCoeffs_, interfaces_, cmpt);
solveScalar alpha = 0.0;
solveScalar gamma = 0.0;
// --- Solver iteration
for
(
solverPerf.nIterations() = 0;
solverPerf.nIterations() < maxIter_;
solverPerf.nIterations()++
)
{
// Make sure gamma,delta are available
if (Pstream::parRun())
{
Pstream::waitRequest(outstandingRequest);
outstandingRequest = -1;
}
const solveScalar gammaOld = gamma;
gamma = globalSum[0];
const solveScalar delta = globalSum[1];
solverPerf.finalResidual() = globalSum[2]/normFactor;
if (solverPerf.nIterations() == 0)
{
solverPerf.initialResidual() = solverPerf.finalResidual();
}
// Check convergence (bypass if not enough iterations yet)
if
(
(minIter_ <= 0 || solverPerf.nIterations() >= minIter_)
&& solverPerf.checkConvergence(tolerance_, relTol_)
)
{
break;
}
if (solverPerf.nIterations() == 0)
{
alpha = gamma/delta;
z = n;
q = m;
s = w;
p = u;
}
else
{
const solveScalar beta = gamma/gammaOld;
alpha = gamma/(delta-beta*gamma/alpha);
for (label cell=0; cell<nCells; cell++)
{
z[cell] = n[cell] + beta*z[cell];
q[cell] = m[cell] + beta*q[cell];
s[cell] = w[cell] + beta*s[cell];
p[cell] = u[cell] + beta*p[cell];
}
}
for (label cell=0; cell<nCells; cell++)
{
psi[cell] += alpha*p[cell];
r[cell] -= alpha*s[cell];
u[cell] -= alpha*q[cell];
w[cell] -= alpha*z[cell];
}
if (cgMode)
{
// --- Start global reductions for inner products
gSumMagProd(globalSum, u, r, w, r, outstandingRequest, comm);
// --- Precondition residual
preconPtr->precondition(m, w, cmpt);
}
else
{
// --- Precondition residual
preconPtr->precondition(m, w, cmpt);
// --- Start global reductions for inner products
gSumMagProd(globalSum, w, u, m, r, outstandingRequest, comm);
}
// --- Calculate A*m
matrix_.Amul(n, m, interfaceBouCoeffs_, interfaces_, cmpt);
}
return solverPerf;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::PPCG::PPCG
(
const word& fieldName,
const lduMatrix& matrix,
const FieldField<Field, scalar>& interfaceBouCoeffs,
const FieldField<Field, scalar>& interfaceIntCoeffs,
const lduInterfaceFieldPtrsList& interfaces,
const dictionary& solverControls
)
:
lduMatrix::solver
(
fieldName,
matrix,
interfaceBouCoeffs,
interfaceIntCoeffs,
interfaces,
solverControls
)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::solverPerformance Foam::PPCG::solve
(
scalarField& psi_s,
const scalarField& source,
const direction cmpt
) const
{
PrecisionAdaptor<solveScalar, scalar> tpsi(psi_s);
return scalarSolve
(
tpsi.ref(),
ConstPrecisionAdaptor<solveScalar, scalar>(source)(),
cmpt,
true // operate in conjugate-gradient mode
);
}
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2019-2020 M. Janssens
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM 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.
OpenFOAM 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 OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::PPCG
Description
Preconditioned pipelined conjugate gradient solver for symmetric
lduMatrices using a run-time selectable preconditioner.
Reference:
\verbatim
P. Ghysels, W. Vanroose.
"Hiding global synchronization latency in the
preconditioned Conjugate Gradient algorithm"
\endverbatim
and implementation details from
\verbatim
Paul Eller, William Gropp
"Scalable Non-blocking Preconditioned Conjugate Gradient Methods"
\endverbatim
SourceFiles
PPCG.C
\*---------------------------------------------------------------------------*/
#ifndef PPCG_H
#define PPCG_H
#include "lduMatrix.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class PPCG Declaration
\*---------------------------------------------------------------------------*/
class PPCG
:
public lduMatrix::solver
{
// Private Member Functions
//- Non-blocking version of sum(a*b), sum(a*c), sum(mag(sumMag))
void gSumMagProd