From ac1253bb764fe3424f1afa87dea4ed349ef24dd9 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 10 Apr 2017 17:42:55 +0100 Subject: [PATCH 01/86] Corrected solver in rare kaon test --- tests/hadrons/Test_hadrons_rarekaon.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/hadrons/Test_hadrons_rarekaon.cc b/tests/hadrons/Test_hadrons_rarekaon.cc index 26622525..7c76312d 100644 --- a/tests/hadrons/Test_hadrons_rarekaon.cc +++ b/tests/hadrons/Test_hadrons_rarekaon.cc @@ -109,11 +109,10 @@ int main(int argc, char *argv[]) application.createModule("DWF_" + flavour[i], actionPar); // solvers - // RBPrecCG -> CG MSolver::CG::Par solverPar; solverPar.action = "DWF_" + flavour[i]; solverPar.residual = 1.0e-8; - application.createModule(solvers[i], + application.createModule(solvers[i], solverPar); } From af2d6ce2e08d54ea7a46e5eeb56e0374905d9343 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 10 Mar 2017 14:59:11 +0000 Subject: [PATCH 02/86] Encapsulated 4D->5D and 5D->4D conversions in separate functions & added corresponding tests. --- extras/Hadrons/Modules/Quark.hpp | 32 ++++-- tests/hadrons/Test_hadrons_quark.cc | 156 ++++++++++++++++++++++++++++ 2 files changed, 179 insertions(+), 9 deletions(-) create mode 100644 tests/hadrons/Test_hadrons_quark.cc diff --git a/extras/Hadrons/Modules/Quark.hpp b/extras/Hadrons/Modules/Quark.hpp index be7426ab..c08e0192 100644 --- a/extras/Hadrons/Modules/Quark.hpp +++ b/extras/Hadrons/Modules/Quark.hpp @@ -36,6 +36,27 @@ See the full license in the file "LICENSE" in the top level distribution directo BEGIN_HADRONS_NAMESPACE +/****************************************************************************** + * 5D -> 4D and 4D -> 5D conversions. * + ******************************************************************************/ +template // Note that 5D object is modified. +inline void make_4D(Lattice &in_5d, Lattice &out_4d, int Ls) +{ + axpby_ssp_pminus(in_5d, 0., in_5d, 1., in_5d, 0, 0); + axpby_ssp_pplus(in_5d, 1., in_5d, 1., in_5d, 0, Ls-1); + ExtractSlice(out_4d, in_5d, 0, 0); +} + +template +inline void make_5D(const Lattice &in_4d, Lattice &out_5d, int Ls) +{ + out_5d = zero; + InsertSlice(in_4d, out_5d, 0, 0); + InsertSlice(in_4d, out_5d, Ls-1, 0); + axpby_ssp_pplus(out_5d, 0., out_5d, 1., out_5d, 0, 0); + axpby_ssp_pminus(out_5d, 0., out_5d, 1., out_5d, Ls-1, Ls-1); +} + /****************************************************************************** * TQuark * ******************************************************************************/ @@ -143,12 +164,8 @@ void TQuark::execute(void) } else { - source = zero; PropToFerm(tmp, fullSrc, s, c); - InsertSlice(tmp, source, 0, 0); - InsertSlice(tmp, source, Ls_-1, 0); - axpby_ssp_pplus(source, 0., source, 1., source, 0, 0); - axpby_ssp_pminus(source, 0., source, 1., source, Ls_-1, Ls_-1); + make_5D(tmp, source, Ls_); } } // source conversion for 5D sources @@ -171,10 +188,7 @@ void TQuark::execute(void) { PropagatorField &p4d = *env().template getObject(getName()); - - axpby_ssp_pminus(sol, 0., sol, 1., sol, 0, 0); - axpby_ssp_pplus(sol, 1., sol, 1., sol, 0, Ls_-1); - ExtractSlice(tmp, sol, 0, 0); + make_4D(sol, tmp, Ls_); FermToProp(p4d, tmp, s, c); } } diff --git a/tests/hadrons/Test_hadrons_quark.cc b/tests/hadrons/Test_hadrons_quark.cc new file mode 100644 index 00000000..6a142ff6 --- /dev/null +++ b/tests/hadrons/Test_hadrons_quark.cc @@ -0,0 +1,156 @@ +/******************************************************************************* + Grid physics library, www.github.com/paboyle/Grid + + Source file: tests/hadrons/Test_hadrons_quark.cc + + Copyright (C) 2017 + + Author: Andrew Lawson + + This program 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 2 of the License, or + (at your option) any later version. + + This program 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + + See the full license in the file "LICENSE" in the top level distribution + directory. + *******************************************************************************/ + +#include "Test_hadrons.hpp" +#include + +using namespace Grid; +using namespace QCD; +using namespace Hadrons; + +/******************************************************************************* + * Unit test functions within Quark module. + ******************************************************************************/ + +// Alternative 4D & 5D projections +template +inline void make_4D_with_gammas(Lattice &in_5d, Lattice &out_4d, int Ls) +{ + GridBase *_grid(out_4d._grid); + Lattice tmp(_grid); + Gamma G5(Gamma::Algebra::Gamma5); + + ExtractSlice(tmp, in_5d, 0, 0); + out_4d = 0.5 * (tmp - G5*tmp); + ExtractSlice(tmp, in_5d, Ls - 1, 0); + out_4d += 0.5 * (tmp + G5*tmp); +} + +template +inline void make_5D_with_gammas(Lattice &in_4d, Lattice &out_5d, int Ls) +{ + out_5d = zero; + Gamma G5(Gamma::Algebra::Gamma5); + GridBase *_grid(in_4d._grid); + Lattice tmp(_grid); + + tmp = 0.5 * (in_4d + G5*in_4d); + InsertSlice(tmp, out_5d, 0, 0); + tmp = 0.5 * (in_4d - G5*in_4d); + InsertSlice(tmp, out_5d, Ls - 1, 0); +} + +int main(int argc, char **argv) +{ + /*************************************************************************** + * Initialisation. + **************************************************************************/ + Grid_init(&argc, &argv); + + std::vector latt_size = GridDefaultLatt(); + std::vector simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd()); + std::vector mpi_layout = GridDefaultMpi(); + + const int Ls = 8; + + GridCartesian UGrid(latt_size,simd_layout,mpi_layout); + GridCartesian *FGrid = SpaceTimeGrid::makeFiveDimGrid(Ls, &UGrid); + GridSerialRNG sRNG; + GridParallelRNG pRNG(&UGrid); + + std::vector seeds4({1,2,3,4}); + std::vector seeds5({5,6,7,8}); + GridParallelRNG rng4(&UGrid); + GridParallelRNG rng5(FGrid); + rng4.SeedFixedIntegers(seeds4); + rng5.SeedFixedIntegers(seeds5); + + /*************************************************************************** + * Build a 4D random source, and convert it to 5D. + **************************************************************************/ + LatticeFermion test4(&UGrid); + LatticeFermion test5(FGrid); + LatticeFermion check5(FGrid); + + gaussian(rng4, test4); + make_5D(test4, test5, Ls); + make_5D_with_gammas(test4, check5, Ls); + test5 -= check5; + std::cout << "4D -> 5D comparison, diff = " << Grid::sqrt(norm2(test5)) << std::endl; + + /*************************************************************************** + * Build a 5D random source, and project down to 4D. + **************************************************************************/ + LatticeFermion check4(&UGrid); + gaussian(rng5, test5); + check5 = test5; + + make_4D(test5, test4, Ls); + make_4D_with_gammas(check5, check4, Ls); + test4 -= check4; + std::cout << "5D -> 4D comparison, diff = " << Grid::sqrt(norm2(test4)) << std::endl; + + /*************************************************************************** + * Convert a propagator to a fermion & back. + **************************************************************************/ + LatticeFermion ferm(&UGrid); + LatticePropagator prop(&UGrid), ref(&UGrid); + gaussian(rng4, prop); + + // Define variables for sanity checking a single site. + typename SpinColourVector::scalar_object fermSite; + typename SpinColourMatrix::scalar_object propSite; + std::vector site(Nd, 0); + + for (int s = 0; s < Ns; ++s) + for (int c = 0; c < Nc; ++c) + { + ref = prop; + PropToFerm(ferm, prop, s, c); + FermToProp(prop, ferm, s, c); + + std::cout << "Spin = " << s << ", Colour = " << c << std::endl; + ref -= prop; + std::cout << "Prop->Ferm->Prop test, diff = " << Grid::sqrt(norm2(ref)) << std::endl; + + peekSite(fermSite, ferm, site); + peekSite(propSite, prop, site); + for (int s2 = 0; s2 < Ns; ++s2) + for (int c2 = 0; c2 < Nc; ++c2) + { + //if (propSite()(s2, s)(c2, c) != fermSite()(s2)(c2)) + //{ + std::cout << propSite()(s2, s)(c2, c) << " != " + << fermSite()(s2)(c2) << " for spin = " << s2 + << ", col = " << c2 << std::endl; + //} + } + } + + Grid_finalize(); + return EXIT_SUCCESS; +} From c382c351a5d088f6af5734ab5dbc11aec53e3cf4 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 10 Mar 2017 15:05:59 +0000 Subject: [PATCH 03/86] Quark test output correction. --- tests/hadrons/Test_hadrons_quark.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/hadrons/Test_hadrons_quark.cc b/tests/hadrons/Test_hadrons_quark.cc index 6a142ff6..5b9d0ce1 100644 --- a/tests/hadrons/Test_hadrons_quark.cc +++ b/tests/hadrons/Test_hadrons_quark.cc @@ -142,12 +142,12 @@ int main(int argc, char **argv) for (int s2 = 0; s2 < Ns; ++s2) for (int c2 = 0; c2 < Nc; ++c2) { - //if (propSite()(s2, s)(c2, c) != fermSite()(s2)(c2)) - //{ + if (propSite()(s2, s)(c2, c) != fermSite()(s2)(c2)) + { std::cout << propSite()(s2, s)(c2, c) << " != " << fermSite()(s2)(c2) << " for spin = " << s2 << ", col = " << c2 << std::endl; - //} + } } } From 1425afc72feae364a2629f30eb6c34783d6374eb Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Tue, 25 Apr 2017 17:26:56 +0100 Subject: [PATCH 04/86] Rare Kaon test fix --- tests/hadrons/Test_hadrons_rarekaon.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/hadrons/Test_hadrons_rarekaon.cc b/tests/hadrons/Test_hadrons_rarekaon.cc index 7c76312d..9d35c1bc 100644 --- a/tests/hadrons/Test_hadrons_rarekaon.cc +++ b/tests/hadrons/Test_hadrons_rarekaon.cc @@ -109,7 +109,7 @@ int main(int argc, char *argv[]) application.createModule("DWF_" + flavour[i], actionPar); // solvers - MSolver::CG::Par solverPar; + MSolver::RBPrecCG::Par solverPar; solverPar.action = "DWF_" + flavour[i]; solverPar.residual = 1.0e-8; application.createModule(solvers[i], From 44260643f6b2d61d8ea6a2543c67e08a76dab748 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Tue, 25 Apr 2017 18:00:24 +0100 Subject: [PATCH 05/86] First conserved current implementation for Wilson fermions only. Not implemented for Gparity or 5D-vectorised Wilson fermions. --- lib/qcd/QCD.h | 8 ++ lib/qcd/action/fermion/FermionOperator.h | 15 ++++ .../fermion/ImprovedStaggeredFermion.cc | 25 ++++++ .../action/fermion/ImprovedStaggeredFermion.h | 16 ++++ .../fermion/ImprovedStaggeredFermion5D.cc | 24 +++++ .../fermion/ImprovedStaggeredFermion5D.h | 15 ++++ lib/qcd/action/fermion/WilsonFermion.cc | 47 ++++++++++ lib/qcd/action/fermion/WilsonFermion.h | 16 ++++ lib/qcd/action/fermion/WilsonFermion5D.cc | 77 ++++++++++++++++ lib/qcd/action/fermion/WilsonFermion5D.h | 15 ++++ lib/qcd/action/fermion/WilsonKernels.cc | 89 +++++++++++++++++++ lib/qcd/action/fermion/WilsonKernels.h | 18 ++++ 12 files changed, 365 insertions(+) diff --git a/lib/qcd/QCD.h b/lib/qcd/QCD.h index 6e6144da..c66c7b13 100644 --- a/lib/qcd/QCD.h +++ b/lib/qcd/QCD.h @@ -489,6 +489,14 @@ namespace QCD { return traceIndex(lhs); } + ////////////////////////////////////////// + // Current types + ////////////////////////////////////////// + GRID_SERIALIZABLE_ENUM(Current, undef, + Vector, 0, + Axial, 1, + Tadpole, 2); + } //namespace QCD } // Grid diff --git a/lib/qcd/action/fermion/FermionOperator.h b/lib/qcd/action/fermion/FermionOperator.h index 676a0e83..144b70f6 100644 --- a/lib/qcd/action/fermion/FermionOperator.h +++ b/lib/qcd/action/fermion/FermionOperator.h @@ -112,6 +112,21 @@ namespace Grid { /////////////////////////////////////////////// virtual void ImportGauge(const GaugeField & _U)=0; + ////////////////////////////////////////////////////////////////////// + // Conserved currents, either contract at sink or insert sequentially. + ////////////////////////////////////////////////////////////////////// + virtual void ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu)=0; + virtual void SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax)=0; }; } diff --git a/lib/qcd/action/fermion/ImprovedStaggeredFermion.cc b/lib/qcd/action/fermion/ImprovedStaggeredFermion.cc index 2ba4f4af..ef8c79bd 100644 --- a/lib/qcd/action/fermion/ImprovedStaggeredFermion.cc +++ b/lib/qcd/action/fermion/ImprovedStaggeredFermion.cc @@ -395,6 +395,31 @@ void ImprovedStaggeredFermion::DhopInternal(StencilImpl &st, LebesgueOrder } }; +//////////////////////////////////////////////////////// +// Conserved current - not yet implemented. +//////////////////////////////////////////////////////// +template +void ImprovedStaggeredFermion::ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu) +{ + assert(0); +} + +template +void ImprovedStaggeredFermion::SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax) +{ + assert(0); +} + FermOpStaggeredTemplateInstantiate(ImprovedStaggeredFermion); //AdjointFermOpTemplateInstantiate(ImprovedStaggeredFermion); diff --git a/lib/qcd/action/fermion/ImprovedStaggeredFermion.h b/lib/qcd/action/fermion/ImprovedStaggeredFermion.h index 7d1f2996..9d5270c6 100644 --- a/lib/qcd/action/fermion/ImprovedStaggeredFermion.h +++ b/lib/qcd/action/fermion/ImprovedStaggeredFermion.h @@ -157,6 +157,22 @@ class ImprovedStaggeredFermion : public StaggeredKernels, public ImprovedS LebesgueOrder Lebesgue; LebesgueOrder LebesgueEvenOdd; + + /////////////////////////////////////////////////////////////// + // Conserved current utilities + /////////////////////////////////////////////////////////////// + void ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu); + void SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax); }; typedef ImprovedStaggeredFermion ImprovedStaggeredFermionF; diff --git a/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.cc b/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.cc index 61a3c559..293077f7 100644 --- a/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.cc +++ b/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.cc @@ -345,6 +345,30 @@ void ImprovedStaggeredFermion5D::MooeeInvDag(const FermionField &in, MooeeInv(in, out); } +//////////////////////////////////////////////////////// +// Conserved current - not yet implemented. +//////////////////////////////////////////////////////// +template +void ImprovedStaggeredFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu) +{ + assert(0); +} + +template +void ImprovedStaggeredFermion5D::SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax) +{ + assert(0); +} FermOpStaggeredTemplateInstantiate(ImprovedStaggeredFermion5D); FermOpStaggeredVec5dTemplateInstantiate(ImprovedStaggeredFermion5D); diff --git a/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.h b/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.h index 4961da49..1c540892 100644 --- a/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.h +++ b/lib/qcd/action/fermion/ImprovedStaggeredFermion5D.h @@ -160,6 +160,21 @@ namespace QCD { // Comms buffer std::vector > comm_buf; + /////////////////////////////////////////////////////////////// + // Conserved current utilities + /////////////////////////////////////////////////////////////// + void ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu); + void SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax); }; }} diff --git a/lib/qcd/action/fermion/WilsonFermion.cc b/lib/qcd/action/fermion/WilsonFermion.cc index 32083d5e..839f5215 100644 --- a/lib/qcd/action/fermion/WilsonFermion.cc +++ b/lib/qcd/action/fermion/WilsonFermion.cc @@ -347,6 +347,53 @@ void WilsonFermion::DhopInternal(StencilImpl &st, LebesgueOrder &lo, } }; +/******************************************************************************* + * Conserved current utilities for Wilson fermions, for contracting propagators + * to make a conserved current sink or inserting the conserved current + * sequentially. + ******************************************************************************/ +template +void WilsonFermion::ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu) +{ + Gamma g5(Gamma::Algebra::Gamma5); + conformable(_grid, q_in_1._grid); + conformable(_grid, q_in_2._grid); + conformable(_grid, q_out._grid); + Kernels::ContractConservedCurrentInternal(q_in_1, q_in_2, q_out, + Umu, curr_type, mu); +} + +template +void WilsonFermion::SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax) +{ + conformable(_grid, q_in._grid); + conformable(_grid, q_out._grid); + Lattice> ph(_grid), coor(_grid); + Complex i(0.0,1.0); + + // Momentum projection + ph = zero; + for(unsigned int mu = 0; mu < Nd - 1; mu++) + { + LatticeCoordinate(coor, mu); + ph = ph + mom[mu]*coor*((1./(_grid->_fdimensions[mu]))); + } + ph = exp((Real)(2*M_PI)*i*ph); + + Kernels::SeqConservedCurrentInternal(q_in, q_out, Umu, curr_type, mu, ph, + tmin, tmax); +} + FermOpTemplateInstantiate(WilsonFermion); AdjointFermOpTemplateInstantiate(WilsonFermion); TwoIndexFermOpTemplateInstantiate(WilsonFermion); diff --git a/lib/qcd/action/fermion/WilsonFermion.h b/lib/qcd/action/fermion/WilsonFermion.h index 933be732..feba40ed 100644 --- a/lib/qcd/action/fermion/WilsonFermion.h +++ b/lib/qcd/action/fermion/WilsonFermion.h @@ -146,6 +146,22 @@ class WilsonFermion : public WilsonKernels, public WilsonFermionStatic { LebesgueOrder Lebesgue; LebesgueOrder LebesgueEvenOdd; + + /////////////////////////////////////////////////////////////// + // Conserved current utilities + /////////////////////////////////////////////////////////////// + void ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu); + void SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax); }; typedef WilsonFermion WilsonFermionF; diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index 88bc425a..d0d3d055 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -679,6 +679,83 @@ void WilsonFermion5D::MomentumSpacePropagatorHw(FermionField &out,const Fe } +/******************************************************************************* + * Conserved current utilities for Wilson fermions, for contracting propagators + * to make a conserved current sink or inserting the conserved current + * sequentially. + ******************************************************************************/ +template +void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu) +{ + conformable(q_in_1._grid, FermionGrid()); + conformable(q_in_1._grid, q_in_2._grid); + conformable(_FourDimGrid, q_out._grid); + + PropagatorField q1_s(_FourDimGrid); + PropagatorField q2_s(_FourDimGrid); + PropagatorField tmp(_FourDimGrid); + + // Contract across 5th dimension. + q_out = zero; + for (int s = 0; s < Ls; ++s) + { + ExtractSlice(q1_s, q_in_1, 0, s); + ExtractSlice(q2_s, q_in_2, 0, Ls - s - 1); + Kernels::ContractConservedCurrentInternal(q1_s, q2_s, tmp, Umu, curr_type, mu); + + // Axial current sign + Real G_s = (curr_type == Current::Axial) ? ((s < Ls/2) ? -1. : 1.) : 1.; + q_out += G_s*tmp; + } +} + + +template +void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax) +{ + conformable(q_in._grid, FermionGrid()); + conformable(q_in._grid, q_out._grid); + Lattice> ph(_FourDimGrid), coor(_FourDimGrid); + Complex i(0.0, 1.0); + + // Momentum projection + ph = zero; + for(unsigned int nu = 0; nu < Nd - 1; nu++) + { + LatticeCoordinate(coor, nu); + ph = ph + mom[nu]*coor*((1./(_FourDimGrid->_fdimensions[nu]))); + } + ph = exp((Real)(2*M_PI)*i*ph); + + // Sequential insertion + Kernels::SeqConservedCurrentInternal(q_in, q_out, Umu, curr_type, + mu, ph, tmin, tmax); + + // Axial current sign. + if (curr_type == Current::Axial) + { + SitePropagator result; + parallel_for(int sU = 0; sU < Umu._grid->oSites(); sU++) + { + int sF = sU * Ls; + for (int s = 0; s < Ls/2; s++) + { + vstream(q_out._odata[sF], -q_out._odata[sF]); + sF++; + } + } + } +} FermOpTemplateInstantiate(WilsonFermion5D); GparityFermOpTemplateInstantiate(WilsonFermion5D); diff --git a/lib/qcd/action/fermion/WilsonFermion5D.h b/lib/qcd/action/fermion/WilsonFermion5D.h index e87e927e..d66f4a1d 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.h +++ b/lib/qcd/action/fermion/WilsonFermion5D.h @@ -214,6 +214,21 @@ namespace QCD { // Comms buffer std::vector > comm_buf; + /////////////////////////////////////////////////////////////// + // Conserved current utilities + /////////////////////////////////////////////////////////////// + void ContractConservedCurrent(PropagatorField &q_in_1, + PropagatorField &q_in_2, + PropagatorField &q_out, + Current curr_type, + unsigned int mu); + void SeqConservedCurrent(PropagatorField &q_in, + PropagatorField &q_out, + Current curr_type, + unsigned int mu, + std::vector mom, + unsigned int tmin, + unsigned int tmax); }; }} diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 6e72e089..fbf8dc00 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -567,6 +567,95 @@ void WilsonKernels::DhopDir( StencilImpl &st, DoubledGaugeField &U,SiteHal vstream(out._odata[sF], result); } +/******************************************************************************* + * Conserved current utilities for Wilson fermions, for contracting propagators + * to make a conserved current sink or inserting the conserved current + * sequentially. Common to both 4D and 5D. + ******************************************************************************/ +#define WilsonCurrentFwd(expr, mu) (0.5*(Gamma::gmu[mu]*expr - expr)) +#define WilsonCurrentBwd(expr, mu) (0.5*(Gamma::gmu[mu]*expr + expr)) + +template +void WilsonKernels::ContractConservedCurrentInternal(const PropagatorField &q_in_1, + const PropagatorField &q_in_2, + PropagatorField &q_out, + DoubledGaugeField &U, + Current curr_type, + unsigned int mu) +{ + Gamma g5(Gamma::Algebra::Gamma5); + PropagatorField tmp(q_out._grid); + GaugeLinkField Umu(U._grid); + Umu = PeekIndex(U, mu); + + tmp = this->CovShiftForward(Umu, mu, q_in_1); + q_out = (g5*adj(q_in_2)*g5)*WilsonCurrentFwd(tmp, mu); + + tmp = adj(Umu)*q_in_1; + q_out += (g5*adj(this->CovShiftForward(Umu, mu, q_in_2))*g5)*WilsonCurrentBwd(q_in_1, mu); +} + + +template +void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, + PropagatorField &q_out, + DoubledGaugeField &U, + Current curr_type, + unsigned int mu, + Lattice> &ph, + unsigned int tmin, + unsigned int tmax) +{ + int tshift = (mu == Nd - 1) ? 1 : 0; + Real G_T = (curr_type == Current::Tadpole) ? -1. : 1.; + PropagatorField tmp(q_in._grid); + GaugeLinkField Umu(U._grid); + Umu = PeekIndex(U, mu); + Lattice> t(q_in._grid); + + tmp = this->CovShiftForward(Umu, mu, q_in)*ph; + where((t >= tmin) and (t <= tmax), tmp, 0.*tmp); + q_out = G_T*WilsonCurrentFwd(tmp, mu); + + tmp = q_in*ph; + tmp = this->CovShiftBackward(Umu, mu, tmp); + where((t >= tmin + tshift) and (t <= tmax + tshift), tmp, 0.*tmp); + q_out += WilsonCurrentBwd(tmp, mu); +} + + +// GParity, (Z)DomainWallVec5D -> require special implementation +#define NO_CURR(Impl) \ +template <> void \ +WilsonKernels::ContractConservedCurrentInternal(const PropagatorField &q_in_1, \ + const PropagatorField &q_in_2, \ + PropagatorField &q_out, \ + DoubledGaugeField &U, \ + Current curr_type, \ + unsigned int mu) \ +{ \ + assert(0); \ +} \ +template <> void \ +WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, \ + PropagatorField &q_out, \ + DoubledGaugeField &U, \ + Current curr_type, \ + unsigned int mu, \ + Lattice> &ph, \ + unsigned int tmin, \ + unsigned int tmax) \ +{ \ + assert(0); \ +} + +NO_CURR(GparityWilsonImplF); +NO_CURR(GparityWilsonImplD); +NO_CURR(DomainWallVec5dImplF); +NO_CURR(DomainWallVec5dImplD); +NO_CURR(ZDomainWallVec5dImplF); +NO_CURR(ZDomainWallVec5dImplD); + FermOpTemplateInstantiate(WilsonKernels); AdjointFermOpTemplateInstantiate(WilsonKernels); TwoIndexFermOpTemplateInstantiate(WilsonKernels); diff --git a/lib/qcd/action/fermion/WilsonKernels.h b/lib/qcd/action/fermion/WilsonKernels.h index 20ee87f2..34820274 100644 --- a/lib/qcd/action/fermion/WilsonKernels.h +++ b/lib/qcd/action/fermion/WilsonKernels.h @@ -166,6 +166,24 @@ public: void DhopDir(StencilImpl &st, DoubledGaugeField &U,SiteHalfSpinor * buf, int sF, int sU, const FermionField &in, FermionField &out, int dirdisp, int gamma); + ////////////////////////////////////////////////////////////////////////////// + // Utilities for inserting Wilson conserved current. + ////////////////////////////////////////////////////////////////////////////// + void ContractConservedCurrentInternal(const PropagatorField &q_in_1, + const PropagatorField &q_in_2, + PropagatorField &q_out, + DoubledGaugeField &U, + Current curr_type, + unsigned int mu); + void SeqConservedCurrentInternal(const PropagatorField &q_in, + PropagatorField &q_out, + DoubledGaugeField &U, + Current curr_type, + unsigned int mu, + Lattice> &ph, + unsigned int tmin, + unsigned int tmax); + private: // Specialised variants void GenericDhopSite(StencilImpl &st, LebesgueOrder &lo, DoubledGaugeField &U, SiteHalfSpinor * buf, From dc5a6404eadc237985a1b4ffac7b8a51760e6bc4 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Tue, 25 Apr 2017 22:08:33 +0100 Subject: [PATCH 06/86] Hadrons: modules for testing conserved current contractions and sequential insertion. --- extras/Hadrons/Modules.hpp | 3 + .../Modules/MContraction/WardIdentity.hpp | 151 ++++++++++++++++++ .../Modules/MContraction/WardIdentitySeq.hpp | 117 ++++++++++++++ .../Hadrons/Modules/MSource/SeqConserved.hpp | 129 +++++++++++++++ extras/Hadrons/modules.inc | 3 + 5 files changed, 403 insertions(+) create mode 100644 extras/Hadrons/Modules/MContraction/WardIdentity.hpp create mode 100644 extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp create mode 100644 extras/Hadrons/Modules/MSource/SeqConserved.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 05ad1697..67762246 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -32,6 +32,8 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include #include +#include +#include #include #include #include @@ -42,6 +44,7 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include #include +#include #include #include #include diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp new file mode 100644 index 00000000..39221148 --- /dev/null +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -0,0 +1,151 @@ +#ifndef Hadrons_WardIdentity_hpp_ +#define Hadrons_WardIdentity_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/* + Ward Identity contractions + ----------------------------- + + * options: + - q: propagator, 5D if available (string) + - q4d: 4D propagator, duplicate of q if q is not 5D (string) + - action: action module used for propagator solution (string) + - mass: mass of quark (double) +*/ + +/****************************************************************************** + * WardIdentity * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MContraction) + +class WardIdentityPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(WardIdentityPar, + std::string, q, + std::string, q4d, + std::string, action, + double, mass); +}; + +template +class TWardIdentity: public Module +{ +public: + TYPE_ALIASES(FImpl,); +public: + // constructor + TWardIdentity(const std::string name); + // destructor + virtual ~TWardIdentity(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +private: + unsigned int Ls_; +}; + +MODULE_REGISTER_NS(WardIdentity, TWardIdentity, MContraction); + +/****************************************************************************** + * TWardIdentity implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TWardIdentity::TWardIdentity(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TWardIdentity::getInput(void) +{ + std::vector in = {par().q, par().q4d, par().action}; + + return in; +} + +template +std::vector TWardIdentity::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TWardIdentity::setup(void) +{ + Ls_ = env().getObjectLs(par().q); +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TWardIdentity::execute(void) +{ + LOG(Message) << "Performing Ward Identity checks for quark '" << par().q + << "'." << std::endl; + + PropagatorField psi(env().getGrid()), tmp(env().getGrid()); + PropagatorField q = *env().template getObject(par().q); + PropagatorField q4d = *env().template getObject(par().q4d); + FMat &act = *(env().template getObject(par().action)); + Gamma g5(Gamma::Algebra::Gamma5); + LatticeComplex PP(env().getGrid()), PA(env().getGrid()), + c(env().getGrid()), PJ5q(env().getGrid()), + vector_WI(env().getGrid()), defect(env().getGrid()); + c = zero; PJ5q = zero; vector_WI = zero; defect = zero; + std::vector Vmu(Nd, c); + std::vector Amu(Nd, c); + + // Get PP, PA, V_mu, A_mu for 4D. + PP = trace(adj(q4d)*q4d); + PA = trace(adj(q4d)*g5*q4d); + for (unsigned int mu = 0; mu < Nd; ++mu) + { + act.ContractConservedCurrent(q, q, tmp, Current::Vector, mu); + Vmu[mu] = trace(g5*tmp); + act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu); + Amu[mu] = trace(g5*tmp); + } + + // Get PJ5q for 5D (zero for 4D). + if (Ls_ > 1) + { + ExtractSlice(psi, q, 0, Ls_/2 - 1); + psi = 0.5 * (psi + g5*psi); + ExtractSlice(tmp, q, 0, Ls_/2); + psi += 0.5 * (tmp - g5*tmp); + PJ5q = trace(adj(psi)*psi); + } + + // Test ward identities, D_mu V_mu = 0; D_mu A_mu = 2m + 2 PJ5q + for (unsigned int mu = 0; mu < Nd; ++mu) + { + vector_WI += Vmu[mu] - Cshift(Vmu[mu], mu, -1); + defect += Amu[mu] - Cshift(Amu[mu], mu, -1); + } + defect -= 2.*PJ5q; + defect -= 2.*(par().mass)*PP; + + LOG(Message) << "Vector Ward Identity check Delta_mu V_mu = " + << norm2(vector_WI) << std::endl; + LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = " + << norm2(defect) << std::endl; +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_WardIdentity_hpp_ diff --git a/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp b/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp new file mode 100644 index 00000000..3e72c11e --- /dev/null +++ b/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp @@ -0,0 +1,117 @@ +#ifndef Hadrons_WardIdentitySeq_hpp_ +#define Hadrons_WardIdentitySeq_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/* + Ward Identity contractions using sequential propagators. + ----------------------------- + + * options: + - q_x: propagator, mu = x current insertion (string). + - q_y: propagator, mu = y current insertion (string). + - q_z: propagator, mu = z current insertion (string). + - q_t: propagator, mu = t current insertion (string). +*/ + +/****************************************************************************** + * WardIdentitySeq * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MContraction) + +class WardIdentitySeqPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(WardIdentitySeqPar, + std::string, q_x, + std::string, q_y, + std::string, q_z, + std::string, q_t); +}; + +template +class TWardIdentitySeq: public Module +{ +public: + TYPE_ALIASES(FImpl,); +public: + // constructor + TWardIdentitySeq(const std::string name); + // destructor + virtual ~TWardIdentitySeq(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(WardIdentitySeq, TWardIdentitySeq, MContraction); + +/****************************************************************************** + * TWardIdentitySeq implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TWardIdentitySeq::TWardIdentitySeq(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TWardIdentitySeq::getInput(void) +{ + std::vector in = {par().q_x, par().q_y, par().q_z, par().q_t}; + + return in; +} + +template +std::vector TWardIdentitySeq::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TWardIdentitySeq::setup(void) +{ + +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TWardIdentitySeq::execute(void) +{ + LatticeComplex vector_WI(env().getGrid()), c(env().getGrid()); + PropagatorField q_x = *env().template getObject(par().q_x); + PropagatorField q_y = *env().template getObject(par().q_y); + PropagatorField q_z = *env().template getObject(par().q_z); + PropagatorField q_t = *env().template getObject(par().q_t); + PropagatorField *q[Nd] = {&q_x, &q_y, &q_z, &q_t}; + Gamma g5(Gamma::Algebra::Gamma5); + + // Check D_mu V_mu = 0 + for (unsigned int mu = 0; mu < Nd; ++mu) + { + c = trace(g5*(*q[mu])); + vector_WI += c - Cshift(c, mu, -1); + } + + LOG(Message) << "Ward Identity checks for sequential vector current " + << "insertion = " << norm2(vector_WI) << std::endl; +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_WardIdentitySeq_hpp_ diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp new file mode 100644 index 00000000..7d4974f4 --- /dev/null +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -0,0 +1,129 @@ +#ifndef Hadrons_SeqConserved_hpp_ +#define Hadrons_SeqConserved_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/* + + Sequential source + ----------------------------- + * src_x = q_x * theta(x_3 - tA) * theta(tB - x_3) * J_mu * exp(i x.mom) + + * options: + - q: input propagator (string) + - action: fermion action used for propagator q (string) + - tA: begin timeslice (integer) + - tB: end timesilce (integer) + - curr_type: type of conserved current to insert (Current) + - mu: Lorentz index of current to insert (integer) + - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0.") + + */ + +/****************************************************************************** + * SeqConserved * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MSource) + +class SeqConservedPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(SeqConservedPar, + std::string, q, + std::string, action, + unsigned int, tA, + unsigned int, tB, + Current, curr_type, + unsigned int, mu, + std::string, mom); +}; + +template +class TSeqConserved: public Module +{ +public: + TYPE_ALIASES(FImpl,); +public: + // constructor + TSeqConserved(const std::string name); + // destructor + virtual ~TSeqConserved(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(SeqConserved, TSeqConserved, MSource); + +/****************************************************************************** + * TSeqConserved implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TSeqConserved::TSeqConserved(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TSeqConserved::getInput(void) +{ + std::vector in; + + return in; +} + +template +std::vector TSeqConserved::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TSeqConserved::setup(void) +{ + +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TSeqConserved::execute(void) +{ + if (par().tA == par().tB) + { + LOG(Message) << "Generating sequential source with conserved " + << par().curr_type << " current insertion (mu = " + << par().mu << ") at " << "t = " << par().tA << std::endl; + } + else + { + LOG(Message) << "Generating sequential source with conserved " + << par().curr_type << " current insertion (mu = " + << par().mu << ") for " << par().tA << " <= t <= " + << par().tB << std::endl; + } + PropagatorField &src = *env().template createLattice(getName()); + PropagatorField &q = *env().template getObject(par().q); + FMat &mat = *(env().template getObject(par().action)); + + std::vector mom = strToVec(par().mom); + mat.SeqConservedCurrent(q, src, par().curr_type, par().mu, + mom, par().tA, par().tB); +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_SeqConserved_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index af291631..32655c3b 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -13,6 +13,8 @@ modules_hpp =\ Modules/MContraction/DiscLoop.hpp \ Modules/MContraction/Gamma3pt.hpp \ Modules/MContraction/Meson.hpp \ + Modules/MContraction/WardIdentity.hpp \ + Modules/MContraction/WardIdentitySeq.hpp \ Modules/MContraction/WeakHamiltonian.hpp \ Modules/MContraction/WeakHamiltonianEye.hpp \ Modules/MContraction/WeakHamiltonianNonEye.hpp \ @@ -23,6 +25,7 @@ modules_hpp =\ Modules/MLoop/NoiseLoop.hpp \ Modules/MSolver/RBPrecCG.hpp \ Modules/MSource/Point.hpp \ + Modules/MSource/SeqConserved.hpp \ Modules/MSource/SeqGamma.hpp \ Modules/MSource/Wall.hpp \ Modules/MSource/Z2.hpp \ From 159770e21ba2515d145bb331305593474ce33b01 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Wed, 26 Apr 2017 09:32:57 +0100 Subject: [PATCH 07/86] Legal Banners added --- .../Modules/MContraction/WardIdentity.hpp | 28 +++++++++++++++++++ .../Modules/MContraction/WardIdentitySeq.hpp | 28 +++++++++++++++++++ .../Hadrons/Modules/MSource/SeqConserved.hpp | 28 +++++++++++++++++++ 3 files changed, 84 insertions(+) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 39221148..355126da 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -1,3 +1,31 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MContraction/WardIdentity.hpp + +Copyright (C) 2017 + +Author: Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_WardIdentity_hpp_ #define Hadrons_WardIdentity_hpp_ diff --git a/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp b/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp index 3e72c11e..31409925 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp @@ -1,3 +1,31 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp + +Copyright (C) 2017 + +Author: Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_WardIdentitySeq_hpp_ #define Hadrons_WardIdentitySeq_hpp_ diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index 7d4974f4..ccfb68f4 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -1,3 +1,31 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MContraction/SeqConserved.hpp + +Copyright (C) 2017 + +Author: Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_SeqConserved_hpp_ #define Hadrons_SeqConserved_hpp_ From a39daecb62a0bf8a128f4650d311badaa1659fda Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Wed, 26 Apr 2017 12:39:07 +0100 Subject: [PATCH 08/86] Removed make_5D const declaration to avoid compilation error --- extras/Hadrons/Modules/Quark.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extras/Hadrons/Modules/Quark.hpp b/extras/Hadrons/Modules/Quark.hpp index c08e0192..fff34edf 100644 --- a/extras/Hadrons/Modules/Quark.hpp +++ b/extras/Hadrons/Modules/Quark.hpp @@ -48,7 +48,7 @@ inline void make_4D(Lattice &in_5d, Lattice &out_4d, int Ls) } template -inline void make_5D(const Lattice &in_4d, Lattice &out_5d, int Ls) +inline void make_5D(Lattice &in_4d, Lattice &out_5d, int Ls) { out_5d = zero; InsertSlice(in_4d, out_5d, 0, 0); From 6299dd35f57b03131447d70f7b8e7f002dc4cdf9 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Wed, 26 Apr 2017 12:41:39 +0100 Subject: [PATCH 09/86] Hadrons: Added test of conserved current code. Tests Ward identities for conserved vector and partially conserved axial currents. --- .../hadrons/Test_hadrons_conserved_current.cc | 127 ++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 tests/hadrons/Test_hadrons_conserved_current.cc diff --git a/tests/hadrons/Test_hadrons_conserved_current.cc b/tests/hadrons/Test_hadrons_conserved_current.cc new file mode 100644 index 00000000..df774ac0 --- /dev/null +++ b/tests/hadrons/Test_hadrons_conserved_current.cc @@ -0,0 +1,127 @@ +/******************************************************************************* + Grid physics library, www.github.com/paboyle/Grid + + Source file: tests/hadrons/Test_hadrons_conserved_current.cc + + Copyright (C) 2017 + + Author: Andrew Lawson + + This program 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 2 of the License, or + (at your option) any later version. + + This program 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + + See the full license in the file "LICENSE" in the top level distribution + directory. + *******************************************************************************/ + +#include "Test_hadrons.hpp" + +using namespace Grid; +using namespace Hadrons; + +int main(int argc, char *argv[]) +{ + // initialization ////////////////////////////////////////////////////////// + Grid_init(&argc, &argv); + HadronsLogError.Active(GridLogError.isActive()); + HadronsLogWarning.Active(GridLogWarning.isActive()); + HadronsLogMessage.Active(GridLogMessage.isActive()); + HadronsLogIterative.Active(GridLogIterative.isActive()); + HadronsLogDebug.Active(GridLogDebug.isActive()); + LOG(Message) << "Grid initialized" << std::endl; + + // run setup /////////////////////////////////////////////////////////////// + Application application; + unsigned int nt = GridDefaultLatt()[Tp]; + double mass = 0.04; + + // global parameters + Application::GlobalPar globalPar; + globalPar.trajCounter.start = 1500; + globalPar.trajCounter.end = 1520; + globalPar.trajCounter.step = 20; + globalPar.seed = "1 2 3 4"; + globalPar.genetic.maxGen = 1000; + globalPar.genetic.maxCstGen = 200; + globalPar.genetic.popSize = 20; + globalPar.genetic.mutationRate = .1; + application.setPar(globalPar); + + // gauge field + application.createModule("gauge"); + + // action + std::string actionName = "DWF"; + MAction::DWF::Par actionPar; + actionPar.gauge = "gauge"; + actionPar.Ls = 12; + actionPar.M5 = 1.8; + actionPar.mass = mass; + application.createModule(actionName, actionPar); + + // solver + std::string solverName = "CG"; + MSolver::RBPrecCG::Par solverPar; + solverPar.action = actionName; + solverPar.residual = 1.0e-8; + application.createModule(solverName, + solverPar); + + // Conserved current sink contractions: use a single point propagator. + std::string pointProp = "q_0"; + std::string pos = "0 0 0 0"; + std::string modName = "Ward Identity Test"; + MAKE_POINT_PROP(pos, pointProp, solverName); + if (!(Environment::getInstance().hasModule(modName))) + { + MContraction::WardIdentity::Par wiPar; + wiPar.q = pointProp + "_5d"; + wiPar.q4d = pointProp; + wiPar.action = actionName; + wiPar.mass = mass; + application.createModule(modName, wiPar); + } + + // Conserved current contractions with sequential insertion of vector + // current. + std::string q_x = "q_x"; + std::string q_y = "q_y"; + std::string q_z = "q_z"; + std::string q_t = "q_t"; + std::string mom = ZERO_MOM; + modName = "Sequential Ward Identity Test"; + MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_x, solverName); + MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_y, solverName); + MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_z, solverName); + MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_t, solverName); + if (!(Environment::getInstance().hasModule(modName))) + { + MContraction::WardIdentitySeq::Par wiPar; + wiPar.q_x = q_x; + wiPar.q_y = q_y; + wiPar.q_z = q_z; + wiPar.q_t = q_t; + application.createModule(modName, wiPar); + } + + // execution + application.saveParameterFile("ConservedCurrentTest.xml"); + application.run(); + + // epilogue + LOG(Message) << "Grid is finalizing now" << std::endl; + Grid_finalize(); + + return EXIT_SUCCESS; +} \ No newline at end of file From d2003f24f49b68f49fd0cb5764ef32f6ef4cd498 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Wed, 26 Apr 2017 17:25:28 +0100 Subject: [PATCH 10/86] Corrected incorrect usage of ExtractSlice for conserved current code. --- extras/Hadrons/Modules/MContraction/WardIdentity.hpp | 4 ++-- lib/qcd/action/fermion/WilsonFermion5D.cc | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 355126da..41d8c6d1 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -150,9 +150,9 @@ void TWardIdentity::execute(void) // Get PJ5q for 5D (zero for 4D). if (Ls_ > 1) { - ExtractSlice(psi, q, 0, Ls_/2 - 1); + ExtractSlice(psi, q, Ls_/2 - 1, 0); psi = 0.5 * (psi + g5*psi); - ExtractSlice(tmp, q, 0, Ls_/2); + ExtractSlice(tmp, q, Ls_/2, 0); psi += 0.5 * (tmp - g5*tmp); PJ5q = trace(adj(psi)*psi); } diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index d0d3d055..99ff0dc1 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -703,8 +703,8 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, q_out = zero; for (int s = 0; s < Ls; ++s) { - ExtractSlice(q1_s, q_in_1, 0, s); - ExtractSlice(q2_s, q_in_2, 0, Ls - s - 1); + ExtractSlice(q1_s, q_in_1, s, 0); + ExtractSlice(q2_s, q_in_2, Ls - s - 1, 0); Kernels::ContractConservedCurrentInternal(q1_s, q2_s, tmp, Umu, curr_type, mu); // Axial current sign From a6ccbbe1080f8c7d2bd193e08ad38b97d0f5af1d Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 28 Apr 2017 10:43:47 +0100 Subject: [PATCH 11/86] Conserved current sequential source now registered properly and fixed module inputs. --- extras/Hadrons/Modules/MSource/SeqConserved.hpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index ccfb68f4..6e5fb197 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -104,7 +104,7 @@ TSeqConserved::TSeqConserved(const std::string name) template std::vector TSeqConserved::getInput(void) { - std::vector in; + std::vector in = {par().q, par().action}; return in; } @@ -121,7 +121,8 @@ std::vector TSeqConserved::getOutput(void) template void TSeqConserved::setup(void) { - + auto Ls_ = env().getObjectLs(par().action); + env().template registerLattice(getName(), Ls_); } // execution /////////////////////////////////////////////////////////////////// From f302eea91e00e1b5e47190253708f9fd1ac36ff7 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 28 Apr 2017 15:27:49 +0100 Subject: [PATCH 12/86] SitePropagator redefined to be a scalar object in TYPE_ALIASES. --- extras/Hadrons/Global.hpp | 14 +++++++------- extras/Hadrons/Modules/MSource/Point.hpp | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/extras/Hadrons/Global.hpp b/extras/Hadrons/Global.hpp index 3e11ddf8..ebf93283 100644 --- a/extras/Hadrons/Global.hpp +++ b/extras/Hadrons/Global.hpp @@ -60,13 +60,13 @@ BEGIN_HADRONS_NAMESPACE // type aliases #define TYPE_ALIASES(FImpl, suffix)\ -typedef FermionOperator FMat##suffix; \ -typedef typename FImpl::FermionField FermionField##suffix; \ -typedef typename FImpl::PropagatorField PropagatorField##suffix; \ -typedef typename FImpl::SitePropagator SitePropagator##suffix; \ -typedef typename FImpl::DoubledGaugeField DoubledGaugeField##suffix;\ -typedef std::function SolverFn##suffix; +typedef FermionOperator FMat##suffix; \ +typedef typename FImpl::FermionField FermionField##suffix; \ +typedef typename FImpl::PropagatorField PropagatorField##suffix; \ +typedef typename FImpl::SitePropagator::scalar_object SitePropagator##suffix; \ +typedef typename FImpl::DoubledGaugeField DoubledGaugeField##suffix;\ +typedef std::function SolverFn##suffix; // logger class HadronsLogger: public Logger diff --git a/extras/Hadrons/Modules/MSource/Point.hpp b/extras/Hadrons/Modules/MSource/Point.hpp index a0ecbc2a..36e1cc5b 100644 --- a/extras/Hadrons/Modules/MSource/Point.hpp +++ b/extras/Hadrons/Modules/MSource/Point.hpp @@ -118,7 +118,7 @@ template void TPoint::execute(void) { std::vector position = strToVec(par().position); - typename SitePropagator::scalar_object id; + SitePropagator id; LOG(Message) << "Creating point source at position [" << par().position << "]" << std::endl; From b9356d38662144acfa5b3f1d5184123b9769598d Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 28 Apr 2017 16:46:40 +0100 Subject: [PATCH 13/86] Added more complete test of sequential insertion of conserved current. --- extras/Hadrons/Modules.hpp | 1 + .../Modules/MUtilities/TestSeqConserved.hpp | 166 ++++++++++++++++++ extras/Hadrons/modules.inc | 1 + 3 files changed, 168 insertions(+) create mode 100644 extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 67762246..0286333c 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -48,4 +48,5 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include #include +#include #include diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp new file mode 100644 index 00000000..0730b8ed --- /dev/null +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -0,0 +1,166 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp + +Copyright (C) 2017 + +Author: Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + +#ifndef Hadrons_TestSeqConserved_hpp_ +#define Hadrons_TestSeqConserved_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/* + Ward Identity contractions using sequential propagators. + ----------------------------- + + * options: + - q: point source propagator, 5D if available (string) + - q4d: 4D point source propagator, duplicate of q if q is 4D (string) + - qSeq: result of sequential insertion of conserved current using q (string) + - action: action used for computation of q (string) + - origin: string giving point source origin of q (string) + - t_J: time at which sequential current is inserted (int) + - mu: Lorentz index of current inserted (int) + - curr: current type, e.g. vector/axial (Current) +*/ + +/****************************************************************************** + * TestSeqConserved * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MUtilities) + +class TestSeqConservedPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(TestSeqConservedPar, + std::string, q, + std::string, q4d, + std::string, qSeq, + std::string, action, + std::string, origin, + unsigned int, t_J, + unsigned int, mu, + Current, curr); +}; + +template +class TTestSeqConserved: public Module +{ +public: + TYPE_ALIASES(FImpl,); +public: + // constructor + TTestSeqConserved(const std::string name); + // destructor + virtual ~TTestSeqConserved(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(TestSeqConserved, TTestSeqConserved, MUtilities); + +/****************************************************************************** + * TTestSeqConserved implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TTestSeqConserved::TTestSeqConserved(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TTestSeqConserved::getInput(void) +{ + std::vector in = {par().q, par().q4d, + par().qSeq, par().action}; + + return in; +} + +template +std::vector TTestSeqConserved::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TTestSeqConserved::setup(void) +{ + +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TTestSeqConserved::execute(void) +{ + PropagatorField tmp(env().getGrid()); + PropagatorField &q = *env().template getObject(par().q); + PropagatorField &q4d = *env().template getObject(par().q4d); + PropagatorField &qSeq = *env().template getObject(par().qSeq); + FMat &act = *(env().template getObject(par().action)); + Gamma g5(Gamma::Algebra::Gamma5); + SitePropagator qSite; + LatticeComplex c(env().getGrid()); + Complex seq_res, check_res; + std::vector check_buf; + + // Check sequential insertion of current gives same result as conserved + // current sink upon contraction. Assume q uses a point source. + std::vector siteCoord; + siteCoord = strToVec(par().origin); + peekSite(qSite, q, siteCoord); + seq_res = trace(g5*qSite); + + act.ContractConservedCurrent(q, q, tmp, par().curr, par().mu); + c = trace(tmp); + sliceSum(c, check_buf, Tp); + check_res = TensorRemove(check_buf[par().t_J]); + + // Check difference = 0 + check_res -= seq_res; + + LOG(Message) << "Consistency check for sequential conserved " + << par().curr << " current insertion = " << abs(check_res) + << std::endl; +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_TestSeqConserved_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 32655c3b..4ab51ce0 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -29,5 +29,6 @@ modules_hpp =\ Modules/MSource/SeqGamma.hpp \ Modules/MSource/Wall.hpp \ Modules/MSource/Z2.hpp \ + Modules/MUtilities/TestSeqConserved.hpp \ Modules/Quark.hpp From db14fb30df901c5e6bb445a2c59a55bf28ac75d5 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 28 Apr 2017 16:48:00 +0100 Subject: [PATCH 14/86] Hadrons: overhaul of conserved current test --- tests/hadrons/Test_hadrons.hpp | 125 +++++++++++++++++- .../hadrons/Test_hadrons_conserved_current.cc | 54 ++++---- 2 files changed, 145 insertions(+), 34 deletions(-) diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 26d02a5c..c4dcedaf 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -40,6 +40,7 @@ using namespace Hadrons; #define LABEL_3PT(s, t1, t2) ADD_INDEX(INIT_INDEX(s, t1), t2) #define LABEL_4PT(s, t1, t2, t3) ADD_INDEX(ADD_INDEX(INIT_INDEX(s, t1), t2), t3) #define LABEL_4PT_NOISE(s, t1, t2, t3, nn) ADD_INDEX(ADD_INDEX(ADD_INDEX(INIT_INDEX(s, t1), t2), t3), nn) +#define LABEL_5D(s) s + "_5d"; // Wall source/sink macros #define NAME_3MOM_WALL_SOURCE(t, mom) ("wall_" + std::to_string(t) + "_" + mom) @@ -123,6 +124,44 @@ inline void makeSequentialSource(Application &application, std::string srcName, } } +/******************************************************************************* + * Name: makeConservedSequentialSource + * Purpose: Construct sequential source with conserved current insertion and + * add to application module. + * Parameters: application - main application that stores modules. + * srcName - name of source module to create. + * qSrc - Input quark for sequential inversion. + * actionName - action corresponding to quark. + * tS - sequential source timeslice. + * curr - conserved current type to insert. + * mu - Lorentz index of current to insert. + * mom - momentum insertion (default is zero). + * Returns: None. + ******************************************************************************/ +inline void makeConservedSequentialSource(Application &application, + std::string &srcName, + std::string &qSrc, + std::string &actionName, + unsigned int tS, + Current curr, + unsigned int mu, + std::string mom = ZERO_MOM) +{ + // If the source already exists, don't make the module again. + if (!(Environment::getInstance().hasModule(srcName))) + { + MSource::SeqConserved::Par seqPar; + seqPar.q = qSrc; + seqPar.action = actionName; + seqPar.tA = tS; + seqPar.tB = tS; + seqPar.curr_type = curr; + seqPar.mu = mu; + seqPar.mom = mom; + application.createModule(srcName, seqPar); + } +} + /******************************************************************************* * Name: makeWallSource * Purpose: Construct wall source and add to application module. @@ -132,7 +171,7 @@ inline void makeSequentialSource(Application &application, std::string srcName, * mom - momentum insertion (default is zero). * Returns: None. ******************************************************************************/ -inline void makeWallSource(Application &application, std::string srcName, +inline void makeWallSource(Application &application, std::string &srcName, unsigned int tW, std::string mom = ZERO_MOM) { // If the source already exists, don't make the module again. @@ -154,8 +193,8 @@ inline void makeWallSource(Application &application, std::string srcName, * mom - momentum insertion (default is zero). * Returns: None. ******************************************************************************/ -inline void makeWallSink(Application &application, std::string propName, - std::string wallName, std::string mom = ZERO_MOM) +inline void makeWallSink(Application &application, std::string &propName, + std::string &wallName, std::string mom = ZERO_MOM) { // If the propagator has already been smeared, don't smear it again. // Temporarily removed, strategy for sink smearing likely to change. @@ -365,4 +404,82 @@ inline void discLoopContraction(Application &application, discPar.gamma = gamma; application.createModule(modName, discPar); } - } +} + +/******************************************************************************* + * Name: makeWITest + * Purpose: Create module to test Ward Identities for conserved current + * contractions and add to application module. + * Parameters: application - main application that stores modules. + * modName - name of module to create. + * propName - 4D quark propagator. + * actionName - action used to compute quark propagator. + * mass - mass of quark. + * Ls - length of 5th dimension (default = 1). + * Returns: None. + ******************************************************************************/ +inline void makeWITest(Application &application, std::string &modName, + std::string &propName, std::string &actionName, + double mass, unsigned int Ls = 1) +{ + if (!(Environment::getInstance().hasModule(modName))) + { + MContraction::WardIdentity::Par wiPar; + if (Ls > 1) + { + wiPar.q = LABEL_5D(propName); + } + else + { + wiPar.q = propName; + } + wiPar.q4d = propName; + wiPar.action = actionName; + wiPar.mass = mass; + application.createModule(modName, wiPar); + } +} + +/******************************************************************************* + * Name: makeSeqTest + * Purpose: Create module to test sequential insertion of conserved current + * and add to application module. + * Parameters: application - main application that stores modules. + * modName - name of module to create. + * propName - 4D quark propagator. + * seqProp - 4D quark propagator with sequential insertion of + * conserved current. + * actionName - action used to compute quark propagators. + * t_J - time at which sequential current is inserted. + * mu - Lorentz index of sequential current. + * curr - type of conserved current inserted. + * Ls - length of 5th dimension (default = 1). + * Returns: None. + ******************************************************************************/ +inline void makeSeqTest(Application &application, std::string &modName, + std::string &propName, std::string &seqName, + std::string &actionName, std::string &origin, + unsigned int t_J, unsigned int mu, Current curr, + unsigned int Ls = 1) +{ + if (!(Environment::getInstance().hasModule(modName))) + { + MUtilities::TestSeqConserved::Par seqPar; + if (Ls > 1) + { + seqPar.q = LABEL_5D(propName); + } + else + { + seqPar.q = propName; + } + seqPar.q4d = propName; + seqPar.qSeq = seqName; + seqPar.action = actionName; + seqPar.origin = origin; + seqPar.t_J = t_J; + seqPar.mu = mu; + seqPar.curr = curr; + application.createModule(modName, seqPar); + } +} diff --git a/tests/hadrons/Test_hadrons_conserved_current.cc b/tests/hadrons/Test_hadrons_conserved_current.cc index df774ac0..a11a3530 100644 --- a/tests/hadrons/Test_hadrons_conserved_current.cc +++ b/tests/hadrons/Test_hadrons_conserved_current.cc @@ -45,6 +45,7 @@ int main(int argc, char *argv[]) Application application; unsigned int nt = GridDefaultLatt()[Tp]; double mass = 0.04; + unsigned int Ls = 12; // global parameters Application::GlobalPar globalPar; @@ -65,7 +66,7 @@ int main(int argc, char *argv[]) std::string actionName = "DWF"; MAction::DWF::Par actionPar; actionPar.gauge = "gauge"; - actionPar.Ls = 12; + actionPar.Ls = Ls; actionPar.M5 = 1.8; actionPar.mass = mass; application.createModule(actionName, actionPar); @@ -83,37 +84,30 @@ int main(int argc, char *argv[]) std::string pos = "0 0 0 0"; std::string modName = "Ward Identity Test"; MAKE_POINT_PROP(pos, pointProp, solverName); - if (!(Environment::getInstance().hasModule(modName))) - { - MContraction::WardIdentity::Par wiPar; - wiPar.q = pointProp + "_5d"; - wiPar.q4d = pointProp; - wiPar.action = actionName; - wiPar.mass = mass; - application.createModule(modName, wiPar); - } + makeWITest(application, modName, pointProp, actionName, mass, Ls); - // Conserved current contractions with sequential insertion of vector + // Conserved current contractions with sequential insertion of vector/axial // current. - std::string q_x = "q_x"; - std::string q_y = "q_y"; - std::string q_z = "q_z"; - std::string q_t = "q_t"; - std::string mom = ZERO_MOM; - modName = "Sequential Ward Identity Test"; - MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_x, solverName); - MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_y, solverName); - MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_z, solverName); - MAKE_SEQUENTIAL_PROP(nt/2, pointProp, mom, q_t, solverName); - if (!(Environment::getInstance().hasModule(modName))) - { - MContraction::WardIdentitySeq::Par wiPar; - wiPar.q_x = q_x; - wiPar.q_y = q_y; - wiPar.q_z = q_z; - wiPar.q_t = q_t; - application.createModule(modName, wiPar); - } + std::string mom = ZERO_MOM; + unsigned int t_J = nt/2; + std::string seqPropA = ADD_INDEX(pointProp + "_seq_A", t_J); + std::string seqPropV = ADD_INDEX(pointProp + "_seq_V", t_J); + std::string seqSrcA = seqPropA + "_src"; + std::string seqSrcV = seqPropV + "_src"; + std::string point5d = LABEL_5D(pointProp); + makeConservedSequentialSource(application, seqSrcA, point5d, + actionName, t_J, Current::Axial, Tp, mom); + makePropagator(application, seqPropA, seqSrcA, solverName); + makeConservedSequentialSource(application, seqSrcV, point5d, + actionName, t_J, Current::Vector, Tp, mom); + makePropagator(application, seqPropV, seqSrcV, solverName); + + std::string modNameA = "Axial Sequential Test"; + std::string modNameV = "Vector Sequential Test"; + makeSeqTest(application, modNameA, pointProp, seqPropA, + actionName, pos, t_J, Tp, Current::Axial, Ls); + makeSeqTest(application, modNameV, pointProp, seqPropV, + actionName, pos, t_J, Tp, Current::Vector, Ls); // execution application.saveParameterFile("ConservedCurrentTest.xml"); From 51d84ec057a80b9898369c7181dacce9979a945d Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 28 Apr 2017 16:49:14 +0100 Subject: [PATCH 15/86] Bugfixes in Wilson 5D sequential conserved current insertion --- lib/qcd/action/fermion/WilsonFermion5D.cc | 24 ++++++++++------------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index 99ff0dc1..bae5ae70 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -726,6 +726,8 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, conformable(q_in._grid, FermionGrid()); conformable(q_in._grid, q_out._grid); Lattice> ph(_FourDimGrid), coor(_FourDimGrid); + PropagatorField q_in_s(_FourDimGrid); + PropagatorField q_out_s(_FourDimGrid); Complex i(0.0, 1.0); // Momentum projection @@ -737,23 +739,17 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, } ph = exp((Real)(2*M_PI)*i*ph); - // Sequential insertion - Kernels::SeqConservedCurrentInternal(q_in, q_out, Umu, curr_type, - mu, ph, tmin, tmax); - - // Axial current sign. - if (curr_type == Current::Axial) + // Sequential insertion across 5th dimension + for (int s = 0; s < Ls; s++) { - SitePropagator result; - parallel_for(int sU = 0; sU < Umu._grid->oSites(); sU++) + ExtractSlice(q_in_s, q_in, s, 0); + Kernels::SeqConservedCurrentInternal(q_in_s, q_out_s, Umu, curr_type, + mu, ph, tmin, tmax); + if ((curr_type == Current::Axial) && (s < Ls/2)) { - int sF = sU * Ls; - for (int s = 0; s < Ls/2; s++) - { - vstream(q_out._odata[sF], -q_out._odata[sF]); - sF++; - } + q_out_s = -q_out_s; } + InsertSlice(q_out_s, q_out, s, 0); } } From 49331a3e72b6b644cd48424b8566440a7338fa64 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 28 Apr 2017 16:50:17 +0100 Subject: [PATCH 16/86] Minor improvements to Ward Identity checks --- .../Hadrons/Modules/MContraction/WardIdentity.hpp | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 41d8c6d1..d312bd4d 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -115,6 +115,10 @@ template void TWardIdentity::setup(void) { Ls_ = env().getObjectLs(par().q); + if (Ls_ != env().getObjectLs(par().action)) + { + HADRON_ERROR("Ls mismatch between quark action and propagator"); + } } // execution /////////////////////////////////////////////////////////////////// @@ -125,8 +129,8 @@ void TWardIdentity::execute(void) << "'." << std::endl; PropagatorField psi(env().getGrid()), tmp(env().getGrid()); - PropagatorField q = *env().template getObject(par().q); - PropagatorField q4d = *env().template getObject(par().q4d); + PropagatorField &q = *env().template getObject(par().q); + PropagatorField &q4d = *env().template getObject(par().q4d); FMat &act = *(env().template getObject(par().action)); Gamma g5(Gamma::Algebra::Gamma5); LatticeComplex PP(env().getGrid()), PA(env().getGrid()), @@ -142,7 +146,7 @@ void TWardIdentity::execute(void) for (unsigned int mu = 0; mu < Nd; ++mu) { act.ContractConservedCurrent(q, q, tmp, Current::Vector, mu); - Vmu[mu] = trace(g5*tmp); + Vmu[mu] = trace(tmp); act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu); Amu[mu] = trace(g5*tmp); } @@ -170,6 +174,9 @@ void TWardIdentity::execute(void) << norm2(vector_WI) << std::endl; LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = " << norm2(defect) << std::endl; + LOG(Message) << "norm2(PP) = " << norm2(PP) << std::endl; + LOG(Message) << "norm2(PA) = " << norm2(PA) << std::endl; + LOG(Message) << "norm2(PJ5q) = " << norm2(PJ5q) << std::endl; } END_MODULE_NAMESPACE From 77e0af9c2eca8ce816b6c6a54bc2d0edef26e213 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 5 May 2017 12:27:50 +0100 Subject: [PATCH 17/86] Compilation fix after merge - conserved current code not yet operational for vectorised 5D or Gparity Impl. --- lib/qcd/action/fermion/WilsonKernels.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 5deec27c..8dc6bd8c 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -365,10 +365,16 @@ WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, NO_CURR(GparityWilsonImplF); NO_CURR(GparityWilsonImplD); +NO_CURR(GparityWilsonImplFH); +NO_CURR(GparityWilsonImplDF); NO_CURR(DomainWallVec5dImplF); NO_CURR(DomainWallVec5dImplD); +NO_CURR(DomainWallVec5dImplFH); +NO_CURR(DomainWallVec5dImplDF); NO_CURR(ZDomainWallVec5dImplF); NO_CURR(ZDomainWallVec5dImplD); +NO_CURR(ZDomainWallVec5dImplFH); +NO_CURR(ZDomainWallVec5dImplDF); FermOpTemplateInstantiate(WilsonKernels); AdjointFermOpTemplateInstantiate(WilsonKernels); From d44cc204d166e19c0198ab9176061d3d8595930a Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 12 May 2017 14:58:17 +0100 Subject: [PATCH 18/86] Added test module for sequential gamma matrix insertion --- extras/Hadrons/Modules.hpp | 1 + .../Modules/MUtilities/TestSeqGamma.hpp | 119 ++++++++++++++++++ extras/Hadrons/modules.inc | 1 + 3 files changed, 121 insertions(+) create mode 100644 extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 0286333c..dd6a6010 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -49,4 +49,5 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include #include +#include #include diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp new file mode 100644 index 00000000..b3e99617 --- /dev/null +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -0,0 +1,119 @@ +#ifndef Hadrons_TestSeqGamma_hpp_ +#define Hadrons_TestSeqGamma_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * TestSeqGamma * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MUtilities) + +class TestSeqGammaPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(TestSeqGammaPar, + std::string, q, + std::string, qSeq, + std::string, origin, + Gamma::Algebra, gamma, + unsigned int, t_g); +}; + +template +class TTestSeqGamma: public Module +{ +public: + TYPE_ALIASES(FImpl,); +public: + // constructor + TTestSeqGamma(const std::string name); + // destructor + virtual ~TTestSeqGamma(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(TestSeqGamma, TTestSeqGamma, MUtilities); + +/****************************************************************************** + * TTestSeqGamma implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TTestSeqGamma::TTestSeqGamma(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TTestSeqGamma::getInput(void) +{ + std::vector in = {par().q, par().qSeq}; + + return in; +} + +template +std::vector TTestSeqGamma::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TTestSeqGamma::setup(void) +{ + +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TTestSeqGamma::execute(void) +{ + PropagatorField &q = *env().template getObject(par().q); + PropagatorField &qSeq = *env().template getObject(par().qSeq); + LatticeComplex c(env().getGrid()); + Gamma g5(Gamma::Algebra::Gamma5); + Gamma g(par().gamma); + SitePropagator qSite; + Complex test, check; + std::vector check_buf; + + // Check sequential insertion of gamma matrix gives same result as + // insertion of gamma at sink upon contraction. Assume q uses a point + // source. + std::vector siteCoord; + siteCoord = strToVec(par().origin); + peekSite(qSite, qSeq, siteCoord); + test = trace(g*qSite); + + c = trace(adj(g)*g5*adj(q)*g5*g*q); + sliceSum(c, check_buf, Tp); + check = TensorRemove(check_buf[par().t_g]); + + LOG(Message) << "Seq Result = " << abs(test) << std::endl; + LOG(Message) << "Reference = " << abs(check) << std::endl; + + // Check difference = 0 + check -= test; + + LOG(Message) << "Consistency check for sequential " << par().gamma + << " insertion = " << abs(check) << std::endl; +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_TestSeqGamma_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 4ab51ce0..0364502a 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -30,5 +30,6 @@ modules_hpp =\ Modules/MSource/Wall.hpp \ Modules/MSource/Z2.hpp \ Modules/MUtilities/TestSeqConserved.hpp \ + Modules/MUtilities/TestSeqGamma.hpp \ Modules/Quark.hpp From 98f610ce5384f75883d7e4a31be54e55c6251410 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 12 May 2017 16:15:26 +0100 Subject: [PATCH 19/86] Reduced code duplication in hadron tests --- tests/hadrons/Test_hadrons.hpp | 96 ++++++++++++++++++++++++++ tests/hadrons/Test_hadrons_rarekaon.cc | 41 +++-------- 2 files changed, 107 insertions(+), 30 deletions(-) diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index c4dcedaf..c0a596b5 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -33,6 +33,30 @@ using namespace Hadrons; /******************************************************************************* * Macros to reduce code duplication. ******************************************************************************/ +// Common initialisation +#define HADRONS_DEFAULT_INIT \ + Grid_init(&argc, &argv); \ + HadronsLogError.Active(GridLogError.isActive()); \ + HadronsLogWarning.Active(GridLogWarning.isActive()); \ + HadronsLogMessage.Active(GridLogMessage.isActive()); \ + HadronsLogIterative.Active(GridLogIterative.isActive()); \ + HadronsLogDebug.Active(GridLogDebug.isActive()); \ + LOG(Message) << "Grid initialized" << std::endl; + +#define HADRONS_DEFAULT_GLOBALS(application) \ +{ \ + Application::GlobalPar globalPar; \ + globalPar.trajCounter.start = 1500; \ + globalPar.trajCounter.end = 1520; \ + globalPar.trajCounter.step = 20; \ + globalPar.seed = "1 2 3 4"; \ + globalPar.genetic.maxGen = 1000; \ + globalPar.genetic.maxCstGen = 200; \ + globalPar.genetic.popSize = 20; \ + globalPar.genetic.mutationRate = .1; \ + application.setPar(globalPar); \ +} + // Useful definitions #define ZERO_MOM "0. 0. 0. 0." #define INIT_INDEX(s, n) (std::string(s) + "_" + std::to_string(n)) @@ -73,10 +97,82 @@ using namespace Hadrons; makePropagator(application, propName, srcName, solver);\ } +/******************************************************************************* + * Action setups. + ******************************************************************************/ + +/******************************************************************************* + * Name: makeWilsonAction + * Parameters: application - main application that stores modules. + * actionName - name of action module to create. + * gaugeField - gauge field module. + * mass - quark mass. + * Returns: None. + ******************************************************************************/ +inline void makeWilsonAction(Application &application, std::string actionName, + std::string &gaugeField, double mass) +{ + if (!(Environment::getInstance().hasModule(actionName))) + { + MAction::Wilson::Par actionPar; + actionPar.gauge = gaugeField; + actionPar.mass = mass; + application.createModule(actionName, actionPar); + } +} + +/******************************************************************************* + * Name: makeDWFAction + * Parameters: application - main application that stores modules. + * actionName - name of action module to create. + * gaugeField - gauge field module. + * mass - quark mass. + * M5 - domain wall height. + * Ls - fifth dimension extent. + * Returns: None. + ******************************************************************************/ +inline void makeDWFAction(Application &application, std::string actionName, + std::string &gaugeField, double mass, double M5, + unsigned int Ls) +{ + if (!(Environment::getInstance().hasModule(actionName))) + { + MAction::DWF::Par actionPar; + actionPar.gauge = gaugeField; + actionPar.Ls = Ls; + actionPar.M5 = M5; + actionPar.mass = mass; + application.createModule(actionName, actionPar); + } +} + /******************************************************************************* * Functions for propagator construction. ******************************************************************************/ +/******************************************************************************* + * Name: makeRBPrecCGSolver + * Purpose: Make RBPrecCG solver module for specified action. + * Parameters: application - main application that stores modules. + * solverName - name of solver module to create. + * actionName - action module corresponding to propagators to be + * computed. + * residual - CG target residual. + * Returns: None. + ******************************************************************************/ +inline void makeRBPrecCGSolver(Application &application, std::string &solverName, + std::string &actionName, double residual = 1e-8) +{ + if (!(Environment::getInstance().hasModule(solverName))) + { + MSolver::RBPrecCG::Par solverPar; + solverPar.action = actionName; + solverPar.residual = residual; + application.createModule(solverName, + solverPar); + } +} + /******************************************************************************* * Name: makePointSource * Purpose: Construct point source and add to application module. diff --git a/tests/hadrons/Test_hadrons_rarekaon.cc b/tests/hadrons/Test_hadrons_rarekaon.cc index 9d35c1bc..1b5a45d9 100644 --- a/tests/hadrons/Test_hadrons_rarekaon.cc +++ b/tests/hadrons/Test_hadrons_rarekaon.cc @@ -51,13 +51,7 @@ int main(int argc, char *argv[]) configStem = argv[1]; // initialization ////////////////////////////////////////////////////////// - Grid_init(&argc, &argv); - HadronsLogError.Active(GridLogError.isActive()); - HadronsLogWarning.Active(GridLogWarning.isActive()); - HadronsLogMessage.Active(GridLogMessage.isActive()); - HadronsLogIterative.Active(GridLogIterative.isActive()); - HadronsLogDebug.Active(GridLogDebug.isActive()); - LOG(Message) << "Grid initialized" << std::endl; + HADRONS_DEFAULT_INIT; // run setup /////////////////////////////////////////////////////////////// Application application; @@ -74,46 +68,33 @@ int main(int argc, char *argv[]) unsigned int n_noise = 1; unsigned int nt = 32; bool do_disconnected(false); + Gamma::Algebra gT = Gamma::Algebra::GammaT; + unsigned int Ls = 16; + double M5 = 1.8; // Global parameters. - Application::GlobalPar globalPar; - globalPar.trajCounter.start = 1500; - globalPar.trajCounter.end = 1520; - globalPar.trajCounter.step = 20; - globalPar.seed = "1 2 3 4"; - globalPar.genetic.maxGen = 1000; - globalPar.genetic.maxCstGen = 200; - globalPar.genetic.popSize = 20; - globalPar.genetic.mutationRate = .1; - application.setPar(globalPar); + HADRONS_DEFAULT_GLOBALS(application); // gauge field + std::string gaugeField = "gauge"; if (configStem == "None") { - application.createModule("gauge"); + application.createModule(gaugeField); } else { MGauge::Load::Par gaugePar; gaugePar.file = configStem; - application.createModule("gauge", gaugePar); + application.createModule(gaugeField, gaugePar); } for (unsigned int i = 0; i < flavour.size(); ++i) { // actions - MAction::DWF::Par actionPar; - actionPar.gauge = "gauge"; - actionPar.Ls = 16; - actionPar.M5 = 1.8; - actionPar.mass = mass[i]; - application.createModule("DWF_" + flavour[i], actionPar); + std::string actionName = "DWF_" + flavour[i]; + makeDWFAction(application, actionName, gaugeField, mass[i], M5, Ls); // solvers - MSolver::RBPrecCG::Par solverPar; - solverPar.action = "DWF_" + flavour[i]; - solverPar.residual = 1.0e-8; - application.createModule(solvers[i], - solverPar); + makeRBPrecCGSolver(application, solvers[i], actionName); } // Create noise propagators for loops. From c2010f21aba12b3f2fd7166211b6c3243b428ed9 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 12 May 2017 16:23:01 +0100 Subject: [PATCH 20/86] Added sequential propagator test for gamma matrix insertion --- tests/hadrons/Test_hadrons.hpp | 42 ++++++++++-- tests/hadrons/Test_hadrons_rarekaon.cc | 10 +-- tests/hadrons/Test_hadrons_seq_gamma.cc | 89 +++++++++++++++++++++++++ 3 files changed, 131 insertions(+), 10 deletions(-) create mode 100644 tests/hadrons/Test_hadrons_seq_gamma.cc diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index c0a596b5..61e90bac 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -82,11 +82,11 @@ using namespace Hadrons; MAKE_3MOM_WALL_PROP(tW, ZERO_MOM, propName, solver) // Sequential source macros -#define MAKE_SEQUENTIAL_PROP(tS, qSrc, mom, propName, solver)\ +#define MAKE_SEQUENTIAL_PROP(tS, qSrc, mom, seqPropName, solver, gamma)\ {\ - std::string srcName = ADD_INDEX(qSrc + "_seq", tS);\ - makeSequentialSource(application, srcName, qSrc, tS, mom);\ - makePropagator(application, propName, srcName, solver);\ + std::string srcName = seqPropName + "_src";\ + makeSequentialSource(application, srcName, qSrc, tS, gamma, mom);\ + makePropagator(application, seqPropName, srcName, solver);\ } // Point source macros @@ -205,6 +205,7 @@ inline void makePointSource(Application &application, std::string srcName, ******************************************************************************/ inline void makeSequentialSource(Application &application, std::string srcName, std::string qSrc, unsigned int tS, + Gamma::Algebra gamma = Gamma::Algebra::GammaT, std::string mom = ZERO_MOM) { // If the source already exists, don't make the module again. @@ -215,7 +216,7 @@ inline void makeSequentialSource(Application &application, std::string srcName, seqPar.tA = tS; seqPar.tB = tS; seqPar.mom = mom; - seqPar.gamma = Gamma::Algebra::GammaT; + seqPar.gamma = gamma; application.createModule(srcName, seqPar); } } @@ -579,3 +580,34 @@ inline void makeSeqTest(Application &application, std::string &modName, application.createModule(modName, seqPar); } } + +/******************************************************************************* + * Name: makeSeqGamComparison + * Purpose: Create module to compare sequential insertion of gamma matrix + * against sink contraction and add to application module. + * Parameters: application - main application that stores modules. + * modName - name of module to create. + * propName - 4D quark propagator. + * seqProp - 4D quark propagator with sequential insertion of + * gamma matrix. + * gamma - Inserted gamma matrix. + * t_g - time at which gamma matrix is inserted + * sequentially. + * Returns: None. + ******************************************************************************/ +inline void makeSeqGamComparison(Application &application, std::string &modName, + std::string &propName, std::string &seqProp, + std::string &origin, Gamma::Algebra gamma, + unsigned int t_g) +{ + if (!(Environment::getInstance().hasModule(modName))) + { + MUtilities::TestSeqGamma::Par seqPar; + seqPar.q = propName; + seqPar.qSeq = seqProp; + seqPar.origin = origin; + seqPar.t_g = t_g; + seqPar.gamma = gamma; + application.createModule(modName, seqPar); + } +} diff --git a/tests/hadrons/Test_hadrons_rarekaon.cc b/tests/hadrons/Test_hadrons_rarekaon.cc index 1b5a45d9..3a642f24 100644 --- a/tests/hadrons/Test_hadrons_rarekaon.cc +++ b/tests/hadrons/Test_hadrons_rarekaon.cc @@ -212,10 +212,10 @@ int main(int argc, char *argv[]) std::string q_KsCs_mq = LABEL_3PT("Q_KsCs_mq", tK, tJ); std::string q_pilCl_q = LABEL_3PT("Q_pilCl_q", tpi, tJ); std::string q_pilCl_mq = LABEL_3PT("Q_pilCl_mq", tpi, tJ); - MAKE_SEQUENTIAL_PROP(tJ, q_Kl_0, qmom, q_KlCl_q, solvers[light]); - MAKE_SEQUENTIAL_PROP(tJ, q_Ks_k, mqmom, q_KsCs_mq, solvers[strange]); - MAKE_SEQUENTIAL_PROP(tJ, q_pil_p, qmom, q_pilCl_q, solvers[light]); - MAKE_SEQUENTIAL_PROP(tJ, q_pil_0, mqmom, q_pilCl_mq, solvers[light]); + MAKE_SEQUENTIAL_PROP(tJ, q_Kl_0, qmom, q_KlCl_q, solvers[light], gT); + MAKE_SEQUENTIAL_PROP(tJ, q_Ks_k, mqmom, q_KsCs_mq, solvers[strange], gT); + MAKE_SEQUENTIAL_PROP(tJ, q_pil_p, qmom, q_pilCl_q, solvers[light], gT); + MAKE_SEQUENTIAL_PROP(tJ, q_pil_0, mqmom, q_pilCl_mq, solvers[light], gT); /******************************************************************* * CONTRACTIONS: pi and K 3pt contractions with current insertion. @@ -271,7 +271,7 @@ int main(int argc, char *argv[]) std::string loop_qCq = LABEL_3PT(loop_stem + flavour[f], tJ, nn); std::string loop_qCq_res = loop_qCq + "_res"; MAKE_SEQUENTIAL_PROP(tJ, noiseRes[f][nn], qmom, - loop_qCq_res, solvers[f]); + loop_qCq_res, solvers[f], gT); makeLoop(application, loop_qCq, eta, loop_qCq_res); /******************************************************* diff --git a/tests/hadrons/Test_hadrons_seq_gamma.cc b/tests/hadrons/Test_hadrons_seq_gamma.cc new file mode 100644 index 00000000..22c35ecb --- /dev/null +++ b/tests/hadrons/Test_hadrons_seq_gamma.cc @@ -0,0 +1,89 @@ +/******************************************************************************* + Grid physics library, www.github.com/paboyle/Grid + + Source file: tests/hadrons/Test_hadrons_seq_gamma.cc + + Copyright (C) 2017 + + Author: Andrew Lawson + + This program 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 2 of the License, or + (at your option) any later version. + + This program 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + + See the full license in the file "LICENSE" in the top level distribution + directory. + *******************************************************************************/ + +#include "Test_hadrons.hpp" + +using namespace Grid; +using namespace QCD; +using namespace Hadrons; + +/******************************************************************************* + * Consistency test for sequential gamma insertion. + ******************************************************************************/ + +int main(int argc, char *argv[]) +{ + // initialization ////////////////////////////////////////////////////////// + HADRONS_DEFAULT_INIT; + + // run setup /////////////////////////////////////////////////////////////// + Application application; + unsigned int nt = GridDefaultLatt()[Tp]; + unsigned int tS = nt / 2; + unsigned int Ls = 12; + double mass = 0.04; + double M5 = 1.8; + + // global parameters + HADRONS_DEFAULT_GLOBALS(application); + + // gauge field + std::string gaugeField = "gauge"; + application.createModule(gaugeField); + + // action + std::string actionName = "DWF"; + makeDWFAction(application, actionName, gaugeField, mass, M5, Ls); + + // solver + std::string solverName = "CG"; + makeRBPrecCGSolver(application, solverName, actionName); + + // test sequential propagator, with g5 insertion. + Gamma::Algebra g = Gamma::Algebra::Gamma5; + std::string pointProp = "q_0"; + std::string point5d = LABEL_5D(pointProp); + std::string origin = "0 0 0 0"; + MAKE_POINT_PROP(origin, pointProp, solverName); + + std::string seqProp = ADD_INDEX(pointProp + "_seqg5", tS); + std::string seqSrc = seqProp + "_src"; + MAKE_SEQUENTIAL_PROP(tS, pointProp, ZERO_MOM, seqProp, solverName, g); + + std::string modName = "Test g5 sequential insertion"; + makeSeqGamComparison(application, modName, pointProp, seqProp, origin, g, tS); + + // execution + application.saveParameterFile("SeqGamma5Test.xml"); + application.run(); + + // epilogue + LOG(Message) << "Grid is finalizing now" << std::endl; + Grid_finalize(); + + return EXIT_SUCCESS; +} \ No newline at end of file From 34332fe3934754025446cec92b6c099c6828df9f Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 12 May 2017 16:30:43 +0100 Subject: [PATCH 21/86] Improvement to sequential conserved current insertion tests --- .../Modules/MUtilities/TestSeqConserved.hpp | 45 +++-- tests/hadrons/Test_hadrons.hpp | 31 ++-- .../hadrons/Test_hadrons_conserved_current.cc | 156 +++++++++++------- 3 files changed, 131 insertions(+), 101 deletions(-) diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index 0730b8ed..3ae1b8b0 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -41,7 +41,6 @@ BEGIN_HADRONS_NAMESPACE * options: - q: point source propagator, 5D if available (string) - - q4d: 4D point source propagator, duplicate of q if q is 4D (string) - qSeq: result of sequential insertion of conserved current using q (string) - action: action used for computation of q (string) - origin: string giving point source origin of q (string) @@ -60,7 +59,6 @@ class TestSeqConservedPar: Serializable public: GRID_SERIALIZABLE_CLASS_MEMBERS(TestSeqConservedPar, std::string, q, - std::string, q4d, std::string, qSeq, std::string, action, std::string, origin, @@ -103,8 +101,7 @@ TTestSeqConserved::TTestSeqConserved(const std::string name) template std::vector TTestSeqConserved::getInput(void) { - std::vector in = {par().q, par().q4d, - par().qSeq, par().action}; + std::vector in = {par().q, par().qSeq, par().action}; return in; } @@ -121,7 +118,11 @@ std::vector TTestSeqConserved::getOutput(void) template void TTestSeqConserved::setup(void) { - + auto Ls = env().getObjectLs(par().q); + if (Ls != env().getObjectLs(par().action)) + { + HADRON_ERROR("Ls mismatch between quark action and propagator"); + } } // execution /////////////////////////////////////////////////////////////////// @@ -130,33 +131,43 @@ void TTestSeqConserved::execute(void) { PropagatorField tmp(env().getGrid()); PropagatorField &q = *env().template getObject(par().q); - PropagatorField &q4d = *env().template getObject(par().q4d); PropagatorField &qSeq = *env().template getObject(par().qSeq); FMat &act = *(env().template getObject(par().action)); Gamma g5(Gamma::Algebra::Gamma5); + Gamma::Algebra gA = (par().curr == Current::Axial) ? + Gamma::Algebra::Gamma5 : + Gamma::Algebra::Identity; + Gamma g(gA); SitePropagator qSite; - LatticeComplex c(env().getGrid()); - Complex seq_res, check_res; - std::vector check_buf; + Complex test_S, test_V, check_S, check_V; + std::vector check_buf; // Check sequential insertion of current gives same result as conserved // current sink upon contraction. Assume q uses a point source. std::vector siteCoord; siteCoord = strToVec(par().origin); - peekSite(qSite, q, siteCoord); - seq_res = trace(g5*qSite); + peekSite(qSite, qSeq, siteCoord); + test_S = trace(qSite*g); + test_V = trace(qSite*g*Gamma::gmu[par().mu]); act.ContractConservedCurrent(q, q, tmp, par().curr, par().mu); - c = trace(tmp); - sliceSum(c, check_buf, Tp); - check_res = TensorRemove(check_buf[par().t_J]); + sliceSum(tmp, check_buf, Tp); + check_S = TensorRemove(trace(check_buf[par().t_J]*g)); + check_V = TensorRemove(trace(check_buf[par().t_J]*g*Gamma::gmu[par().mu])); + + LOG(Message) << "Test S = " << abs(test_S) << std::endl; + LOG(Message) << "Test V = " << abs(test_V) << std::endl; + LOG(Message) << "Check S = " << abs(check_S) << std::endl; + LOG(Message) << "Check V = " << abs(check_V) << std::endl; // Check difference = 0 - check_res -= seq_res; + check_S -= test_S; + check_V -= test_V; LOG(Message) << "Consistency check for sequential conserved " - << par().curr << " current insertion = " << abs(check_res) - << std::endl; + << par().curr << " current insertion: " << std::endl; + LOG(Message) << "Check S = " << abs(check_S) << std::endl; + LOG(Message) << "Check V = " << abs(check_V) << std::endl; } END_MODULE_NAMESPACE diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 61e90bac..1b038388 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -538,39 +538,30 @@ inline void makeWITest(Application &application, std::string &modName, } /******************************************************************************* - * Name: makeSeqTest - * Purpose: Create module to test sequential insertion of conserved current - * and add to application module. + * Name: makeSeqCurrComparison + * Purpose: Create module to compare sequential insertion of conserved current + * against sink contraction and add to application module. * Parameters: application - main application that stores modules. * modName - name of module to create. - * propName - 4D quark propagator. - * seqProp - 4D quark propagator with sequential insertion of + * propName - quark propagator (point source), 5D if available. + * seqName - 4D quark propagator with sequential insertion of * conserved current. * actionName - action used to compute quark propagators. + * origin - origin of point source propagator. * t_J - time at which sequential current is inserted. * mu - Lorentz index of sequential current. * curr - type of conserved current inserted. - * Ls - length of 5th dimension (default = 1). * Returns: None. ******************************************************************************/ -inline void makeSeqTest(Application &application, std::string &modName, - std::string &propName, std::string &seqName, - std::string &actionName, std::string &origin, - unsigned int t_J, unsigned int mu, Current curr, - unsigned int Ls = 1) +inline void makeSeqCurrComparison(Application &application, std::string &modName, + std::string &propName, std::string &seqName, + std::string &actionName, std::string &origin, + unsigned int t_J, unsigned int mu, Current curr) { if (!(Environment::getInstance().hasModule(modName))) { MUtilities::TestSeqConserved::Par seqPar; - if (Ls > 1) - { - seqPar.q = LABEL_5D(propName); - } - else - { - seqPar.q = propName; - } - seqPar.q4d = propName; + seqPar.q = propName; seqPar.qSeq = seqName; seqPar.action = actionName; seqPar.origin = origin; diff --git a/tests/hadrons/Test_hadrons_conserved_current.cc b/tests/hadrons/Test_hadrons_conserved_current.cc index a11a3530..080fef73 100644 --- a/tests/hadrons/Test_hadrons_conserved_current.cc +++ b/tests/hadrons/Test_hadrons_conserved_current.cc @@ -30,84 +30,112 @@ using namespace Grid; using namespace Hadrons; +inline void setupSeqCurrTests(Application &application, std::string modStem, + std::string &pointProp, std::string &seqStem, + std::string &actionName, std::string &solverName, + std::string &origin, Current curr, + unsigned int t_J, unsigned int mu, + unsigned int Ls = 1) +{ + std::string modName = ADD_INDEX(modStem, mu); + std::string seqProp = ADD_INDEX(seqStem, mu); + std::string seqSrc = seqProp + "_src"; + + // 5D actions require 5D propagator as input for conserved current + // insertions. + std::string propIn; + if (Ls > 1) + { + propIn = LABEL_5D(pointProp); + } + else + { + propIn = pointProp; + } + + makeConservedSequentialSource(application, seqSrc, propIn, + actionName, t_J, curr, mu); + makePropagator(application, seqProp, seqSrc, solverName); + makeSeqCurrComparison(application, modName, propIn, seqProp, + actionName, origin, t_J, mu, curr); +} + +inline void setupWardIdentityTests(Application &application, + std::string &actionName, + double mass, + unsigned int Ls = 1, + bool perform_axial_tests = false) +{ + // solver + std::string solverName = actionName + "_CG"; + makeRBPrecCGSolver(application, solverName, actionName); + + unsigned int nt = GridDefaultLatt()[Tp]; + unsigned int t_J = nt/2; + + /*************************************************************************** + * Conserved current sink contractions: use a single point propagator for + * the Ward Identity test. + **************************************************************************/ + std::string pointProp = actionName + "_q_0"; + std::string origin = "0 0 0 0"; + std::string modName = actionName + " Ward Identity Test"; + MAKE_POINT_PROP(origin, pointProp, solverName); + makeWITest(application, modName, pointProp, actionName, mass, Ls); + + /*************************************************************************** + * Conserved current tests with sequential insertion of vector/axial + * current. If above Ward Identity passes, sufficient to test sequential + * insertion of conserved current agrees with contracted version. + **************************************************************************/ + // Compare sequential insertion to contraction. Should be enough to perform + // for time and one space component. + std::string seqStem = ADD_INDEX(pointProp + "seq_V", t_J); + std::string modStem = actionName + " Vector Sequential Test mu"; + setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, + solverName, origin, Current::Vector, t_J, Tp, Ls); + setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, + solverName, origin, Current::Vector, t_J, Xp, Ls); + + // Perform axial tests only if partially-conserved axial current exists for + // the action. + if (perform_axial_tests) + { + seqStem = ADD_INDEX(pointProp + "seq_A", t_J); + modStem = actionName + " Axial Sequential Test mu"; + setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, + solverName, origin, Current::Axial, t_J, Tp, Ls); + setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, + solverName, origin, Current::Axial, t_J, Xp, Ls); + } +} + int main(int argc, char *argv[]) { // initialization ////////////////////////////////////////////////////////// - Grid_init(&argc, &argv); - HadronsLogError.Active(GridLogError.isActive()); - HadronsLogWarning.Active(GridLogWarning.isActive()); - HadronsLogMessage.Active(GridLogMessage.isActive()); - HadronsLogIterative.Active(GridLogIterative.isActive()); - HadronsLogDebug.Active(GridLogDebug.isActive()); - LOG(Message) << "Grid initialized" << std::endl; - + HADRONS_DEFAULT_INIT; + // run setup /////////////////////////////////////////////////////////////// Application application; - unsigned int nt = GridDefaultLatt()[Tp]; double mass = 0.04; + double M5 = 1.8; unsigned int Ls = 12; // global parameters - Application::GlobalPar globalPar; - globalPar.trajCounter.start = 1500; - globalPar.trajCounter.end = 1520; - globalPar.trajCounter.step = 20; - globalPar.seed = "1 2 3 4"; - globalPar.genetic.maxGen = 1000; - globalPar.genetic.maxCstGen = 200; - globalPar.genetic.popSize = 20; - globalPar.genetic.mutationRate = .1; - application.setPar(globalPar); + HADRONS_DEFAULT_GLOBALS(application); // gauge field - application.createModule("gauge"); + std::string gaugeField = "gauge"; + application.createModule(gaugeField); - // action + // Setup each action and the conserved current tests relevant to it. std::string actionName = "DWF"; - MAction::DWF::Par actionPar; - actionPar.gauge = "gauge"; - actionPar.Ls = Ls; - actionPar.M5 = 1.8; - actionPar.mass = mass; - application.createModule(actionName, actionPar); + makeDWFAction(application, actionName, gaugeField, mass, M5, Ls); + setupWardIdentityTests(application, actionName, mass, Ls, true); - // solver - std::string solverName = "CG"; - MSolver::RBPrecCG::Par solverPar; - solverPar.action = actionName; - solverPar.residual = 1.0e-8; - application.createModule(solverName, - solverPar); - - // Conserved current sink contractions: use a single point propagator. - std::string pointProp = "q_0"; - std::string pos = "0 0 0 0"; - std::string modName = "Ward Identity Test"; - MAKE_POINT_PROP(pos, pointProp, solverName); - makeWITest(application, modName, pointProp, actionName, mass, Ls); - - // Conserved current contractions with sequential insertion of vector/axial - // current. - std::string mom = ZERO_MOM; - unsigned int t_J = nt/2; - std::string seqPropA = ADD_INDEX(pointProp + "_seq_A", t_J); - std::string seqPropV = ADD_INDEX(pointProp + "_seq_V", t_J); - std::string seqSrcA = seqPropA + "_src"; - std::string seqSrcV = seqPropV + "_src"; - std::string point5d = LABEL_5D(pointProp); - makeConservedSequentialSource(application, seqSrcA, point5d, - actionName, t_J, Current::Axial, Tp, mom); - makePropagator(application, seqPropA, seqSrcA, solverName); - makeConservedSequentialSource(application, seqSrcV, point5d, - actionName, t_J, Current::Vector, Tp, mom); - makePropagator(application, seqPropV, seqSrcV, solverName); - - std::string modNameA = "Axial Sequential Test"; - std::string modNameV = "Vector Sequential Test"; - makeSeqTest(application, modNameA, pointProp, seqPropA, - actionName, pos, t_J, Tp, Current::Axial, Ls); - makeSeqTest(application, modNameV, pointProp, seqPropV, - actionName, pos, t_J, Tp, Current::Vector, Ls); + actionName = "Wilson"; + makeWilsonAction(application, actionName, gaugeField, mass); + setupWardIdentityTests(application, actionName, mass); // execution application.saveParameterFile("ConservedCurrentTest.xml"); From 08b314fd0fadd012492710bf57fd17b37ea9cf54 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Thu, 18 May 2017 13:16:14 +0100 Subject: [PATCH 22/86] Hadrons: conserved current test fixes. Axial current tests now also optional. --- .../Modules/MContraction/WardIdentity.hpp | 106 ++++++++++-------- tests/hadrons/Test_hadrons.hpp | 13 ++- .../hadrons/Test_hadrons_conserved_current.cc | 3 +- 3 files changed, 69 insertions(+), 53 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index d312bd4d..fa51ce95 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -40,10 +40,10 @@ BEGIN_HADRONS_NAMESPACE ----------------------------- * options: - - q: propagator, 5D if available (string) - - q4d: 4D propagator, duplicate of q if q is not 5D (string) - - action: action module used for propagator solution (string) - - mass: mass of quark (double) + - q: propagator, 5D if available (string) + - action: action module used for propagator solution (string) + - mass: mass of quark (double) + - test_axial: whether or not to test PCAC relation. */ /****************************************************************************** @@ -56,9 +56,9 @@ class WardIdentityPar: Serializable public: GRID_SERIALIZABLE_CLASS_MEMBERS(WardIdentityPar, std::string, q, - std::string, q4d, std::string, action, - double, mass); + double, mass, + bool, test_axial); }; template @@ -97,7 +97,7 @@ TWardIdentity::TWardIdentity(const std::string name) template std::vector TWardIdentity::getInput(void) { - std::vector in = {par().q, par().q4d, par().action}; + std::vector in = {par().q, par().action}; return in; } @@ -128,55 +128,69 @@ void TWardIdentity::execute(void) LOG(Message) << "Performing Ward Identity checks for quark '" << par().q << "'." << std::endl; - PropagatorField psi(env().getGrid()), tmp(env().getGrid()); + PropagatorField psi(env().getGrid()), tmp(env().getGrid()), + vector_WI(env().getGrid()); PropagatorField &q = *env().template getObject(par().q); - PropagatorField &q4d = *env().template getObject(par().q4d); FMat &act = *(env().template getObject(par().action)); Gamma g5(Gamma::Algebra::Gamma5); - LatticeComplex PP(env().getGrid()), PA(env().getGrid()), - c(env().getGrid()), PJ5q(env().getGrid()), - vector_WI(env().getGrid()), defect(env().getGrid()); - c = zero; PJ5q = zero; vector_WI = zero; defect = zero; - std::vector Vmu(Nd, c); - std::vector Amu(Nd, c); - - // Get PP, PA, V_mu, A_mu for 4D. - PP = trace(adj(q4d)*q4d); - PA = trace(adj(q4d)*g5*q4d); + + // Compute D_mu V_mu, D here is backward derivative. + vector_WI = zero; for (unsigned int mu = 0; mu < Nd; ++mu) { act.ContractConservedCurrent(q, q, tmp, Current::Vector, mu); - Vmu[mu] = trace(tmp); - act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu); - Amu[mu] = trace(g5*tmp); + tmp -= Cshift(tmp, mu, -1); + vector_WI += tmp; } - // Get PJ5q for 5D (zero for 4D). - if (Ls_ > 1) - { - ExtractSlice(psi, q, Ls_/2 - 1, 0); - psi = 0.5 * (psi + g5*psi); - ExtractSlice(tmp, q, Ls_/2, 0); - psi += 0.5 * (tmp - g5*tmp); - PJ5q = trace(adj(psi)*psi); - } - - // Test ward identities, D_mu V_mu = 0; D_mu A_mu = 2m + 2 PJ5q - for (unsigned int mu = 0; mu < Nd; ++mu) - { - vector_WI += Vmu[mu] - Cshift(Vmu[mu], mu, -1); - defect += Amu[mu] - Cshift(Amu[mu], mu, -1); - } - defect -= 2.*PJ5q; - defect -= 2.*(par().mass)*PP; - LOG(Message) << "Vector Ward Identity check Delta_mu V_mu = " << norm2(vector_WI) << std::endl; - LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = " - << norm2(defect) << std::endl; - LOG(Message) << "norm2(PP) = " << norm2(PP) << std::endl; - LOG(Message) << "norm2(PA) = " << norm2(PA) << std::endl; - LOG(Message) << "norm2(PJ5q) = " << norm2(PJ5q) << std::endl; + + if (par().test_axial) + { + LatticeComplex PP(env().getGrid()), axial_defect(env().getGrid()), + PJ5q(env().getGrid()); + + // Compute D_mu A_mu, D is backwards derivative. + axial_defect = zero; + for (unsigned int mu = 0; mu < Nd; ++mu) + { + act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu); + tmp -= Cshift(tmp, mu, -1); + axial_defect += trace(g5*tmp); + } + + // Get PJ5q for 5D (zero for 4D) and PP. + PJ5q = zero; + if (Ls_ > 1) + { + // PP + ExtractSlice(tmp, q, 0, 0); + psi = (tmp - g5*tmp); + ExtractSlice(tmp, q, Ls_ - 1, 0); + psi += (tmp + g5*tmp); + PP = trace(adj(psi)*psi); + + // P5Jq + ExtractSlice(tmp, q, Ls_/2 - 1, 0); + psi = 0.5 * (tmp + g5*tmp); + ExtractSlice(tmp, q, Ls_/2, 0); + psi += 0.5 * (tmp - g5*tmp); + PJ5q = trace(adj(psi)*psi); + } + else + { + PP = trace(adj(q)*q); + } + + // Test ward identities, D_mu V_mu = 0; D_mu A_mu = 2m + 2 PJ5q + axial_defect -= 2.*PJ5q; + axial_defect -= 2.*(par().mass)*PP; + LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = " + << norm2(axial_defect) << std::endl; + LOG(Message) << "norm2(PP) = " << norm2(PP) << std::endl; + LOG(Message) << "norm2(PJ5q) = " << norm2(PJ5q) << std::endl; + } } END_MODULE_NAMESPACE diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 1b038388..6dbe3425 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -513,26 +513,27 @@ inline void discLoopContraction(Application &application, * actionName - action used to compute quark propagator. * mass - mass of quark. * Ls - length of 5th dimension (default = 1). + * test_axial - whether or not to check PCAC relation. * Returns: None. ******************************************************************************/ inline void makeWITest(Application &application, std::string &modName, std::string &propName, std::string &actionName, - double mass, unsigned int Ls = 1) + double mass, unsigned int Ls = 1, bool test_axial = false) { if (!(Environment::getInstance().hasModule(modName))) { MContraction::WardIdentity::Par wiPar; if (Ls > 1) { - wiPar.q = LABEL_5D(propName); + wiPar.q = LABEL_5D(propName); } else { - wiPar.q = propName; + wiPar.q = propName; } - wiPar.q4d = propName; - wiPar.action = actionName; - wiPar.mass = mass; + wiPar.action = actionName; + wiPar.mass = mass; + wiPar.test_axial = test_axial; application.createModule(modName, wiPar); } } diff --git a/tests/hadrons/Test_hadrons_conserved_current.cc b/tests/hadrons/Test_hadrons_conserved_current.cc index 080fef73..37ef30d9 100644 --- a/tests/hadrons/Test_hadrons_conserved_current.cc +++ b/tests/hadrons/Test_hadrons_conserved_current.cc @@ -81,7 +81,8 @@ inline void setupWardIdentityTests(Application &application, std::string origin = "0 0 0 0"; std::string modName = actionName + " Ward Identity Test"; MAKE_POINT_PROP(origin, pointProp, solverName); - makeWITest(application, modName, pointProp, actionName, mass, Ls); + makeWITest(application, modName, pointProp, actionName, mass, Ls, + perform_axial_tests); /*************************************************************************** * Conserved current tests with sequential insertion of vector/axial From eec79e0a1e8cdaf58c55547d520e2b9e9a894898 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 5 Jun 2017 11:55:41 +0100 Subject: [PATCH 23/86] Ward Identity test improvements and conserved current bug fixes --- .../Modules/MContraction/WardIdentity.hpp | 35 ++++++++++++------- lib/qcd/action/fermion/WilsonFermion5D.cc | 10 ++++-- lib/qcd/action/fermion/WilsonKernels.cc | 21 +++++------ 3 files changed, 42 insertions(+), 24 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index fa51ce95..7fc7d15d 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -143,6 +143,7 @@ void TWardIdentity::execute(void) vector_WI += tmp; } + // Test ward identity D_mu V_mu = 0; LOG(Message) << "Vector Ward Identity check Delta_mu V_mu = " << norm2(vector_WI) << std::endl; @@ -150,28 +151,29 @@ void TWardIdentity::execute(void) { LatticeComplex PP(env().getGrid()), axial_defect(env().getGrid()), PJ5q(env().getGrid()); + std::vector axial_buf; - // Compute D_mu A_mu, D is backwards derivative. + // Compute , D is backwards derivative. axial_defect = zero; for (unsigned int mu = 0; mu < Nd; ++mu) { act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu); tmp -= Cshift(tmp, mu, -1); - axial_defect += trace(g5*tmp); + axial_defect += 2.*trace(g5*tmp); } - // Get PJ5q for 5D (zero for 4D) and PP. + // Get for 5D (zero for 4D) and . PJ5q = zero; if (Ls_ > 1) { - // PP + // ExtractSlice(tmp, q, 0, 0); - psi = (tmp - g5*tmp); + psi = 0.5 * (tmp - g5*tmp); ExtractSlice(tmp, q, Ls_ - 1, 0); - psi += (tmp + g5*tmp); + psi += 0.5 * (tmp + g5*tmp); PP = trace(adj(psi)*psi); - // P5Jq + // ExtractSlice(tmp, q, Ls_/2 - 1, 0); psi = 0.5 * (tmp + g5*tmp); ExtractSlice(tmp, q, Ls_/2, 0); @@ -183,13 +185,22 @@ void TWardIdentity::execute(void) PP = trace(adj(q)*q); } - // Test ward identities, D_mu V_mu = 0; D_mu A_mu = 2m + 2 PJ5q - axial_defect -= 2.*PJ5q; - axial_defect -= 2.*(par().mass)*PP; + // Test ward identity = 2m + 2 + LOG(Message) << "|D_mu A_mu|^2 = " << norm2(axial_defect) << std::endl; + LOG(Message) << "|PP|^2 = " << norm2(PP) << std::endl; + LOG(Message) << "|PJ5q|^2 = " << norm2(PJ5q) << std::endl; LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = " << norm2(axial_defect) << std::endl; - LOG(Message) << "norm2(PP) = " << norm2(PP) << std::endl; - LOG(Message) << "norm2(PJ5q) = " << norm2(PJ5q) << std::endl; + + // Axial defect by timeslice. + axial_defect -= 2.*(par().mass*PP + PJ5q); + LOG(Message) << "Check Axial defect by timeslice" << std::endl; + sliceSum(axial_defect, axial_buf, Tp); + for (int t = 0; t < axial_buf.size(); ++t) + { + LOG(Message) << "t = " << t << ": " + << TensorRemove(axial_buf[t]) << std::endl; + } } } diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index f616a080..3bbc03b4 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -700,8 +700,14 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, Kernels::ContractConservedCurrentInternal(q1_s, q2_s, tmp, Umu, curr_type, mu); // Axial current sign - Real G_s = (curr_type == Current::Axial) ? ((s < Ls/2) ? -1. : 1.) : 1.; - q_out += G_s*tmp; + if ((curr_type == Current::Axial) && (s < (Ls / 2))) + { + q_out -= tmp; + } + else + { + q_out += tmp; + } } } diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 8dc6bd8c..802c0940 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -286,8 +286,9 @@ void WilsonKernels::DhopDir( StencilImpl &st, DoubledGaugeField &U,SiteHal * to make a conserved current sink or inserting the conserved current * sequentially. Common to both 4D and 5D. ******************************************************************************/ -#define WilsonCurrentFwd(expr, mu) (0.5*(Gamma::gmu[mu]*expr - expr)) -#define WilsonCurrentBwd(expr, mu) (0.5*(Gamma::gmu[mu]*expr + expr)) +// N.B. Functions below assume a -1/2 factor within U. +#define WilsonCurrentFwd(expr, mu) ((expr - Gamma::gmu[mu]*expr)) +#define WilsonCurrentBwd(expr, mu) ((expr + Gamma::gmu[mu]*expr)) template void WilsonKernels::ContractConservedCurrentInternal(const PropagatorField &q_in_1, @@ -300,13 +301,13 @@ void WilsonKernels::ContractConservedCurrentInternal(const PropagatorField Gamma g5(Gamma::Algebra::Gamma5); PropagatorField tmp(q_out._grid); GaugeLinkField Umu(U._grid); - Umu = PeekIndex(U, mu); + Umu = PeekIndex(U, mu); tmp = this->CovShiftForward(Umu, mu, q_in_1); q_out = (g5*adj(q_in_2)*g5)*WilsonCurrentFwd(tmp, mu); - tmp = adj(Umu)*q_in_1; - q_out += (g5*adj(this->CovShiftForward(Umu, mu, q_in_2))*g5)*WilsonCurrentBwd(q_in_1, mu); + tmp = this->CovShiftForward(Umu, mu, q_in_2); + q_out -= (g5*adj(tmp)*g5)*WilsonCurrentBwd(q_in_1, mu); } @@ -320,21 +321,21 @@ void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_i unsigned int tmin, unsigned int tmax) { - int tshift = (mu == Nd - 1) ? 1 : 0; + int tshift = (mu == Tp) ? 1 : 0; Real G_T = (curr_type == Current::Tadpole) ? -1. : 1.; PropagatorField tmp(q_in._grid); GaugeLinkField Umu(U._grid); - Umu = PeekIndex(U, mu); + Umu = PeekIndex(U, mu); Lattice> t(q_in._grid); tmp = this->CovShiftForward(Umu, mu, q_in)*ph; - where((t >= tmin) and (t <= tmax), tmp, 0.*tmp); + tmp = where((t >= tmin) and (t <= tmax), tmp, 0.*tmp); q_out = G_T*WilsonCurrentFwd(tmp, mu); tmp = q_in*ph; tmp = this->CovShiftBackward(Umu, mu, tmp); - where((t >= tmin + tshift) and (t <= tmax + tshift), tmp, 0.*tmp); - q_out += WilsonCurrentBwd(tmp, mu); + tmp = where((t >= tmin + tshift) and (t <= tmax + tshift), tmp, 0.*tmp); + q_out -= WilsonCurrentBwd(tmp, mu); } From 622a21bec673ccf3a3b895584678afacd1f59c4b Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 5 Jun 2017 15:55:32 +0100 Subject: [PATCH 24/86] Improvements to sequential conserved current test and small bugfix. --- .../Modules/MUtilities/TestSeqConserved.hpp | 18 ++++++++++++------ lib/qcd/action/fermion/WilsonKernels.cc | 1 + 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index 3ae1b8b0..eccb00cc 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -140,7 +140,8 @@ void TTestSeqConserved::execute(void) Gamma g(gA); SitePropagator qSite; Complex test_S, test_V, check_S, check_V; - std::vector check_buf; + std::vector check_buf; + LatticeComplex c(env().getGrid()); // Check sequential insertion of current gives same result as conserved // current sink upon contraction. Assume q uses a point source. @@ -151,9 +152,14 @@ void TTestSeqConserved::execute(void) test_V = trace(qSite*g*Gamma::gmu[par().mu]); act.ContractConservedCurrent(q, q, tmp, par().curr, par().mu); - sliceSum(tmp, check_buf, Tp); - check_S = TensorRemove(trace(check_buf[par().t_J]*g)); - check_V = TensorRemove(trace(check_buf[par().t_J]*g*Gamma::gmu[par().mu])); + + c = trace(tmp*g); + sliceSum(c, check_buf, Tp); + check_S = TensorRemove(check_buf[par().t_J]); + + c = trace(tmp*g*Gamma::gmu[par().mu]); + sliceSum(c, check_buf, Tp); + check_V = TensorRemove(check_buf[par().t_J]); LOG(Message) << "Test S = " << abs(test_S) << std::endl; LOG(Message) << "Test V = " << abs(test_V) << std::endl; @@ -166,8 +172,8 @@ void TTestSeqConserved::execute(void) LOG(Message) << "Consistency check for sequential conserved " << par().curr << " current insertion: " << std::endl; - LOG(Message) << "Check S = " << abs(check_S) << std::endl; - LOG(Message) << "Check V = " << abs(check_V) << std::endl; + LOG(Message) << "Diff S = " << abs(check_S) << std::endl; + LOG(Message) << "Diff V = " << abs(check_V) << std::endl; } END_MODULE_NAMESPACE diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 802c0940..8d5406f4 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -327,6 +327,7 @@ void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_i GaugeLinkField Umu(U._grid); Umu = PeekIndex(U, mu); Lattice> t(q_in._grid); + LatticeCoordinate(t, mu); tmp = this->CovShiftForward(Umu, mu, q_in)*ph; tmp = where((t >= tmin) and (t <= tmax), tmp, 0.*tmp); From c504b4dbad611b8f36599fb5d6202a85b465134d Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 5 Jun 2017 15:56:43 +0100 Subject: [PATCH 25/86] Code cleaning --- extras/Hadrons/Modules/MContraction/WardIdentity.hpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 7fc7d15d..fb2ea173 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -128,12 +128,11 @@ void TWardIdentity::execute(void) LOG(Message) << "Performing Ward Identity checks for quark '" << par().q << "'." << std::endl; - PropagatorField psi(env().getGrid()), tmp(env().getGrid()), - vector_WI(env().getGrid()); + PropagatorField tmp(env().getGrid()), vector_WI(env().getGrid()); PropagatorField &q = *env().template getObject(par().q); FMat &act = *(env().template getObject(par().action)); Gamma g5(Gamma::Algebra::Gamma5); - + // Compute D_mu V_mu, D here is backward derivative. vector_WI = zero; for (unsigned int mu = 0; mu < Nd; ++mu) @@ -149,6 +148,7 @@ void TWardIdentity::execute(void) if (par().test_axial) { + PropagatorField psi(env().getGrid()); LatticeComplex PP(env().getGrid()), axial_defect(env().getGrid()), PJ5q(env().getGrid()); std::vector axial_buf; @@ -159,7 +159,7 @@ void TWardIdentity::execute(void) { act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu); tmp -= Cshift(tmp, mu, -1); - axial_defect += 2.*trace(g5*tmp); + axial_defect += trace(g5*tmp); } // Get for 5D (zero for 4D) and . @@ -191,7 +191,7 @@ void TWardIdentity::execute(void) LOG(Message) << "|PJ5q|^2 = " << norm2(PJ5q) << std::endl; LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = " << norm2(axial_defect) << std::endl; - + // Axial defect by timeslice. axial_defect -= 2.*(par().mass*PP + PJ5q); LOG(Message) << "Check Axial defect by timeslice" << std::endl; From e5c8b7369e2cb259379d987260cf21f2b96e404f Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Tue, 6 Jun 2017 14:19:10 +0100 Subject: [PATCH 26/86] Boundary condition option in quark actions for hadrons tests. --- tests/hadrons/Test_hadrons.hpp | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 6dbe3425..a554425d 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -107,16 +107,20 @@ using namespace Hadrons; * actionName - name of action module to create. * gaugeField - gauge field module. * mass - quark mass. + * boundary - fermion boundary conditions (default to periodic + * space, antiperiodic time). * Returns: None. ******************************************************************************/ inline void makeWilsonAction(Application &application, std::string actionName, - std::string &gaugeField, double mass) + std::string &gaugeField, double mass, + std::string boundary = "1 1 1 -1") { if (!(Environment::getInstance().hasModule(actionName))) { MAction::Wilson::Par actionPar; actionPar.gauge = gaugeField; actionPar.mass = mass; + actionPar.boundary = boundary; application.createModule(actionName, actionPar); } } @@ -129,11 +133,13 @@ inline void makeWilsonAction(Application &application, std::string actionName, * mass - quark mass. * M5 - domain wall height. * Ls - fifth dimension extent. + * boundary - fermion boundary conditions (default to periodic + * space, antiperiodic time). * Returns: None. ******************************************************************************/ inline void makeDWFAction(Application &application, std::string actionName, std::string &gaugeField, double mass, double M5, - unsigned int Ls) + unsigned int Ls, std::string boundary = "1 1 1 -1") { if (!(Environment::getInstance().hasModule(actionName))) { @@ -142,6 +148,7 @@ inline void makeDWFAction(Application &application, std::string actionName, actionPar.Ls = Ls; actionPar.M5 = M5; actionPar.mass = mass; + actionPar.boundary = boundary; application.createModule(actionName, actionPar); } } From 8d442b502dc59f7fe4407b02142677299ac63740 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Tue, 6 Jun 2017 17:06:40 +0100 Subject: [PATCH 27/86] Sequential current fix for spacial indices. --- lib/qcd/action/fermion/WilsonKernels.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 8d5406f4..62ae93fa 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -327,7 +327,7 @@ void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_i GaugeLinkField Umu(U._grid); Umu = PeekIndex(U, mu); Lattice> t(q_in._grid); - LatticeCoordinate(t, mu); + LatticeCoordinate(t, Tp); tmp = this->CovShiftForward(Umu, mu, q_in)*ph; tmp = where((t >= tmin) and (t <= tmax), tmp, 0.*tmp); From 60f11bfd72f2c74cfdb0b91eaa9f44d80dd9946c Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Wed, 7 Jun 2017 12:34:47 +0100 Subject: [PATCH 28/86] Removed redundant test module --- extras/Hadrons/Modules.hpp | 1 - .../Modules/MContraction/WardIdentitySeq.hpp | 145 ------------------ extras/Hadrons/modules.inc | 1 - 3 files changed, 147 deletions(-) delete mode 100644 extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index dd6a6010..53ec346c 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -33,7 +33,6 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include #include -#include #include #include #include diff --git a/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp b/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp deleted file mode 100644 index 31409925..00000000 --- a/extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp +++ /dev/null @@ -1,145 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: extras/Hadrons/Modules/MContraction/WardIdentitySeq.hpp - -Copyright (C) 2017 - -Author: Andrew Lawson - -This program 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 2 of the License, or -(at your option) any later version. - -This program 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 this program; if not, write to the Free Software Foundation, Inc., -51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - -See the full license in the file "LICENSE" in the top level distribution directory -*************************************************************************************/ -/* END LEGAL */ - -#ifndef Hadrons_WardIdentitySeq_hpp_ -#define Hadrons_WardIdentitySeq_hpp_ - -#include -#include -#include - -BEGIN_HADRONS_NAMESPACE - -/* - Ward Identity contractions using sequential propagators. - ----------------------------- - - * options: - - q_x: propagator, mu = x current insertion (string). - - q_y: propagator, mu = y current insertion (string). - - q_z: propagator, mu = z current insertion (string). - - q_t: propagator, mu = t current insertion (string). -*/ - -/****************************************************************************** - * WardIdentitySeq * - ******************************************************************************/ -BEGIN_MODULE_NAMESPACE(MContraction) - -class WardIdentitySeqPar: Serializable -{ -public: - GRID_SERIALIZABLE_CLASS_MEMBERS(WardIdentitySeqPar, - std::string, q_x, - std::string, q_y, - std::string, q_z, - std::string, q_t); -}; - -template -class TWardIdentitySeq: public Module -{ -public: - TYPE_ALIASES(FImpl,); -public: - // constructor - TWardIdentitySeq(const std::string name); - // destructor - virtual ~TWardIdentitySeq(void) = default; - // dependency relation - virtual std::vector getInput(void); - virtual std::vector getOutput(void); - // setup - virtual void setup(void); - // execution - virtual void execute(void); -}; - -MODULE_REGISTER_NS(WardIdentitySeq, TWardIdentitySeq, MContraction); - -/****************************************************************************** - * TWardIdentitySeq implementation * - ******************************************************************************/ -// constructor ///////////////////////////////////////////////////////////////// -template -TWardIdentitySeq::TWardIdentitySeq(const std::string name) -: Module(name) -{} - -// dependencies/products /////////////////////////////////////////////////////// -template -std::vector TWardIdentitySeq::getInput(void) -{ - std::vector in = {par().q_x, par().q_y, par().q_z, par().q_t}; - - return in; -} - -template -std::vector TWardIdentitySeq::getOutput(void) -{ - std::vector out = {getName()}; - - return out; -} - -// setup /////////////////////////////////////////////////////////////////////// -template -void TWardIdentitySeq::setup(void) -{ - -} - -// execution /////////////////////////////////////////////////////////////////// -template -void TWardIdentitySeq::execute(void) -{ - LatticeComplex vector_WI(env().getGrid()), c(env().getGrid()); - PropagatorField q_x = *env().template getObject(par().q_x); - PropagatorField q_y = *env().template getObject(par().q_y); - PropagatorField q_z = *env().template getObject(par().q_z); - PropagatorField q_t = *env().template getObject(par().q_t); - PropagatorField *q[Nd] = {&q_x, &q_y, &q_z, &q_t}; - Gamma g5(Gamma::Algebra::Gamma5); - - // Check D_mu V_mu = 0 - for (unsigned int mu = 0; mu < Nd; ++mu) - { - c = trace(g5*(*q[mu])); - vector_WI += c - Cshift(c, mu, -1); - } - - LOG(Message) << "Ward Identity checks for sequential vector current " - << "insertion = " << norm2(vector_WI) << std::endl; -} - -END_MODULE_NAMESPACE - -END_HADRONS_NAMESPACE - -#endif // Hadrons_WardIdentitySeq_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 0364502a..b57aa577 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -14,7 +14,6 @@ modules_hpp =\ Modules/MContraction/Gamma3pt.hpp \ Modules/MContraction/Meson.hpp \ Modules/MContraction/WardIdentity.hpp \ - Modules/MContraction/WardIdentitySeq.hpp \ Modules/MContraction/WeakHamiltonian.hpp \ Modules/MContraction/WeakHamiltonianEye.hpp \ Modules/MContraction/WeakHamiltonianNonEye.hpp \ From b8e45ae490729a9ed79983974e1eeec1778a1e8d Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Wed, 7 Jun 2017 16:26:22 +0100 Subject: [PATCH 29/86] Fixed remaining fermion type aliases after merge. --- extras/Hadrons/Modules/MContraction/WardIdentity.hpp | 2 +- extras/Hadrons/Modules/MSource/SeqConserved.hpp | 2 +- extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp | 2 +- extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index fb2ea173..82b0317a 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -65,7 +65,7 @@ template class TWardIdentity: public Module { public: - TYPE_ALIASES(FImpl,); + FERM_TYPE_ALIASES(FImpl,); public: // constructor TWardIdentity(const std::string name); diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index 6e5fb197..67086f11 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -74,7 +74,7 @@ template class TSeqConserved: public Module { public: - TYPE_ALIASES(FImpl,); + FERM_TYPE_ALIASES(FImpl,); public: // constructor TSeqConserved(const std::string name); diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index eccb00cc..faebab0a 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -71,7 +71,7 @@ template class TTestSeqConserved: public Module { public: - TYPE_ALIASES(FImpl,); + FERM_TYPE_ALIASES(FImpl,); public: // constructor TTestSeqConserved(const std::string name); diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp index b3e99617..1b057c29 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -27,7 +27,7 @@ template class TTestSeqGamma: public Module { public: - TYPE_ALIASES(FImpl,); + FERM_TYPE_ALIASES(FImpl,); public: // constructor TTestSeqGamma(const std::string name); From 2d433ba30720f621b4d0a1bae91434aa4a42fe36 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 12 Jun 2017 10:32:14 +0100 Subject: [PATCH 30/86] Changed header include guards to match new convention --- extras/Hadrons/Modules/MContraction/WardIdentity.hpp | 4 ++-- extras/Hadrons/Modules/MSource/SeqConserved.hpp | 4 ++-- extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp | 4 ++-- extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp | 4 ++-- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 82b0317a..8a56e0eb 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -26,8 +26,8 @@ See the full license in the file "LICENSE" in the top level distribution directo *************************************************************************************/ /* END LEGAL */ -#ifndef Hadrons_WardIdentity_hpp_ -#define Hadrons_WardIdentity_hpp_ +#ifndef Hadrons_MContraction_WardIdentity_hpp_ +#define Hadrons_MContraction_WardIdentity_hpp_ #include #include diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index 67086f11..86a7dfb9 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -26,8 +26,8 @@ See the full license in the file "LICENSE" in the top level distribution directo *************************************************************************************/ /* END LEGAL */ -#ifndef Hadrons_SeqConserved_hpp_ -#define Hadrons_SeqConserved_hpp_ +#ifndef Hadrons_MSource_SeqConserved_hpp_ +#define Hadrons_MSource_SeqConserved_hpp_ #include #include diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index faebab0a..b085eb8c 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -26,8 +26,8 @@ See the full license in the file "LICENSE" in the top level distribution directo *************************************************************************************/ /* END LEGAL */ -#ifndef Hadrons_TestSeqConserved_hpp_ -#define Hadrons_TestSeqConserved_hpp_ +#ifndef Hadrons_MUtilities_TestSeqConserved_hpp_ +#define Hadrons_MUtilities_TestSeqConserved_hpp_ #include #include diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp index 1b057c29..3dbd7d63 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -1,5 +1,5 @@ -#ifndef Hadrons_TestSeqGamma_hpp_ -#define Hadrons_TestSeqGamma_hpp_ +#ifndef Hadrons_MUtilities_TestSeqGamma_hpp_ +#define Hadrons_MUtilities_TestSeqGamma_hpp_ #include #include From 5633a2db20e99cec2b5f11906632beb20eaadb31 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 12 Jun 2017 10:41:02 +0100 Subject: [PATCH 31/86] Faster implementation of conserved current site contraction. Added 5D vectorised support, but not G-parity. --- lib/qcd/action/fermion/FermionOperatorImpl.h | 29 ++++- lib/qcd/action/fermion/WilsonFermion.cc | 20 ++- lib/qcd/action/fermion/WilsonFermion5D.cc | 48 ++++--- lib/qcd/action/fermion/WilsonKernels.cc | 124 +++++++++++++++---- lib/qcd/action/fermion/WilsonKernels.h | 26 +++- 5 files changed, 198 insertions(+), 49 deletions(-) diff --git a/lib/qcd/action/fermion/FermionOperatorImpl.h b/lib/qcd/action/fermion/FermionOperatorImpl.h index 20458b6d..f330fb0d 100644 --- a/lib/qcd/action/fermion/FermionOperatorImpl.h +++ b/lib/qcd/action/fermion/FermionOperatorImpl.h @@ -212,6 +212,13 @@ namespace QCD { StencilImpl &St) { mult(&phi(), &U(mu), &chi()); } + + inline void multLinkProp(SitePropagator &phi, + const SiteDoubledGaugeField &U, + const SitePropagator &chi, + int mu) { + mult(&phi(), &U(mu), &chi()); + } template inline void loadLinkElement(Simd ®, ref &memory) { @@ -340,7 +347,20 @@ class DomainWallVec5dImpl : public PeriodicGaugeImpl< GaugeImplTypes< S,Nrepres } mult(&phi(), &UU(), &chi()); } - + + inline void multLinkProp(SitePropagator &phi, + const SiteDoubledGaugeField &U, + const SitePropagator &chi, + int mu) { + SiteGaugeLink UU; + for (int i = 0; i < Nrepresentation; i++) { + for (int j = 0; j < Nrepresentation; j++) { + vsplat(UU()()(i, j), U(mu)()(i, j)); + } + } + mult(&phi(), &UU(), &chi()); + } + inline void DoubleStore(GridBase *GaugeGrid, DoubledGaugeField &Uds,const GaugeField &Umu) { SiteScalarGaugeField ScalarUmu; @@ -538,6 +558,13 @@ class GparityWilsonImpl : public ConjugateGaugeImpl::ContractConservedCurrent(PropagatorField &q_in_1, conformable(_grid, q_in_1._grid); conformable(_grid, q_in_2._grid); conformable(_grid, q_out._grid); - Kernels::ContractConservedCurrentInternal(q_in_1, q_in_2, q_out, - Umu, curr_type, mu); + PropagatorField tmp(_grid); + q_out = zero; + + // Forward, need q1(x + mu), q2(x) + tmp = Cshift(q_in_1, mu, 1); + parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) + { + Kernels::ContractConservedCurrentSiteFwd(tmp, q_in_2, q_out, Umu, + mu, sU, sU, sU, sU); + } + + // Backward, need q1(x), q2(x + mu) + tmp = Cshift(q_in_2, mu, 1); + parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) + { + Kernels::ContractConservedCurrentSiteBwd(q_in_1, tmp, q_out, Umu, + mu, sU, sU, sU, sU); + } } template diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index 3bbc03b4..b69a18ba 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -687,26 +687,44 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, conformable(q_in_1._grid, q_in_2._grid); conformable(_FourDimGrid, q_out._grid); - PropagatorField q1_s(_FourDimGrid); - PropagatorField q2_s(_FourDimGrid); - PropagatorField tmp(_FourDimGrid); - - // Contract across 5th dimension. + PropagatorField tmp(FermionGrid()); q_out = zero; - for (int s = 0; s < Ls; ++s) - { - ExtractSlice(q1_s, q_in_1, s, 0); - ExtractSlice(q2_s, q_in_2, Ls - s - 1, 0); - Kernels::ContractConservedCurrentInternal(q1_s, q2_s, tmp, Umu, curr_type, mu); - // Axial current sign - if ((curr_type == Current::Axial) && (s < (Ls / 2))) + // Forward, need q1(x + mu, s), q2(x, Ls - 1 - s). 5D lattice so shift + // 4D coordinate mu by one. + tmp = Cshift(q_in_1, mu + 1, 1); + parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) + { + unsigned int sF1 = sU * Ls; + unsigned int sF2 = (sU + 1) * Ls - 1; + for (int s = 0; s < Ls; ++s) { - q_out -= tmp; + bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ + true : false; + Kernels::ContractConservedCurrentSiteFwd(tmp, q_in_2, q_out, Umu, + mu, sF1, sF2, sU, sU, + axial_sign); + sF1++; + sF2--; } - else + } + + // Backward, need q1(x, s), q2(x + mu, Ls - 1 - s). 5D lattice so shift + // 4D coordinate mu by one. + tmp = Cshift(q_in_2, mu + 1, 1); + parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) + { + unsigned int sF1 = sU * Ls; + unsigned int sF2 = (sU + 1) * Ls - 1; + for (int s = 0; s < Ls; ++s) { - q_out += tmp; + bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ + true : false; + Kernels::ContractConservedCurrentSiteBwd(q_in_1, tmp, q_out, Umu, + mu, sF1, sF2, sU, sU, + axial_sign); + sF1++; + sF2--; } } } diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 62ae93fa..c519dc56 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -290,26 +290,110 @@ void WilsonKernels::DhopDir( StencilImpl &st, DoubledGaugeField &U,SiteHal #define WilsonCurrentFwd(expr, mu) ((expr - Gamma::gmu[mu]*expr)) #define WilsonCurrentBwd(expr, mu) ((expr + Gamma::gmu[mu]*expr)) +/******************************************************************************* + * Name: ContractConservedCurrentSiteFwd + * Operation: (1/2) * q2[x] * U(x) * (g[mu] - 1) * q1[x + mu] + * Notes: - DoubledGaugeField U assumed to contain -1/2 factor. + * - Pass in q_in_1 shifted in +ve mu direction. + ******************************************************************************/ template -void WilsonKernels::ContractConservedCurrentInternal(const PropagatorField &q_in_1, - const PropagatorField &q_in_2, - PropagatorField &q_out, - DoubledGaugeField &U, - Current curr_type, - unsigned int mu) +void WilsonKernels::ContractConservedCurrentSiteFwd( + const PropagatorField &q_in_1, + const PropagatorField &q_in_2, + PropagatorField &q_out, + DoubledGaugeField &U, + unsigned int mu, + unsigned int sF_in_1, + unsigned int sF_in_2, + unsigned int sF_out, + unsigned int sU, + bool switch_sign) { + SitePropagator result, tmp; Gamma g5(Gamma::Algebra::Gamma5); - PropagatorField tmp(q_out._grid); - GaugeLinkField Umu(U._grid); - Umu = PeekIndex(U, mu); - - tmp = this->CovShiftForward(Umu, mu, q_in_1); - q_out = (g5*adj(q_in_2)*g5)*WilsonCurrentFwd(tmp, mu); - - tmp = this->CovShiftForward(Umu, mu, q_in_2); - q_out -= (g5*adj(tmp)*g5)*WilsonCurrentBwd(q_in_1, mu); + multLinkProp(tmp, U._odata[sU], q_in_1._odata[sF_in_1], mu); + result = g5 * adj(q_in_2._odata[sF_in_2]) * g5 * WilsonCurrentFwd(tmp, mu); + if (switch_sign) + { + q_out._odata[sF_out] -= result; + } + else + { + q_out._odata[sF_out] += result; + } } +/******************************************************************************* + * Name: ContractConservedCurrentSiteBwd + * Operation: (1/2) * q2[x + mu] * U^dag(x) * (g[mu] + 1) * q1[x] + * Notes: - DoubledGaugeField U assumed to contain -1/2 factor. + * - Pass in q_in_2 shifted in +ve mu direction. + ******************************************************************************/ +template +void WilsonKernels::ContractConservedCurrentSiteBwd( + const PropagatorField &q_in_1, + const PropagatorField &q_in_2, + PropagatorField &q_out, + DoubledGaugeField &U, + unsigned int mu, + unsigned int sF_in_1, + unsigned int sF_in_2, + unsigned int sF_out, + unsigned int sU, + bool switch_sign) +{ + SitePropagator result, tmp; + Gamma g5(Gamma::Algebra::Gamma5); + multLinkProp(tmp, U._odata[sU], q_in_1._odata[sF_in_1], mu + Nd); + result = g5 * adj(q_in_2._odata[sF_in_2]) * g5 * WilsonCurrentBwd(tmp, mu); + if (switch_sign) + { + q_out._odata[sF_out] += result; + } + else + { + q_out._odata[sF_out] -= result; + } +} + +// G-parity requires more specialised implementation. +#define NO_CURR_SITE(Impl) \ +template <> \ +void WilsonKernels::ContractConservedCurrentSiteFwd( \ + const PropagatorField &q_in_1, \ + const PropagatorField &q_in_2, \ + PropagatorField &q_out, \ + DoubledGaugeField &U, \ + unsigned int mu, \ + unsigned int sF_in_1, \ + unsigned int sF_in_2, \ + unsigned int sF_out, \ + unsigned int sU, \ + bool switch_sign) \ +{ \ + assert(0); \ +} \ +template <> \ +void WilsonKernels::ContractConservedCurrentSiteBwd( \ + const PropagatorField &q_in_1, \ + const PropagatorField &q_in_2, \ + PropagatorField &q_out, \ + DoubledGaugeField &U, \ + unsigned int mu, \ + unsigned int sF_in_1, \ + unsigned int sF_in_2, \ + unsigned int sF_out, \ + unsigned int sU, \ + bool switch_sign) \ +{ \ + assert(0); \ +} + +NO_CURR_SITE(GparityWilsonImplF); +NO_CURR_SITE(GparityWilsonImplD); +NO_CURR_SITE(GparityWilsonImplFH); +NO_CURR_SITE(GparityWilsonImplDF); + template void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, @@ -342,16 +426,6 @@ void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_i // GParity, (Z)DomainWallVec5D -> require special implementation #define NO_CURR(Impl) \ -template <> void \ -WilsonKernels::ContractConservedCurrentInternal(const PropagatorField &q_in_1, \ - const PropagatorField &q_in_2, \ - PropagatorField &q_out, \ - DoubledGaugeField &U, \ - Current curr_type, \ - unsigned int mu) \ -{ \ - assert(0); \ -} \ template <> void \ WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, \ PropagatorField &q_out, \ diff --git a/lib/qcd/action/fermion/WilsonKernels.h b/lib/qcd/action/fermion/WilsonKernels.h index 25c956ef..95155ccc 100644 --- a/lib/qcd/action/fermion/WilsonKernels.h +++ b/lib/qcd/action/fermion/WilsonKernels.h @@ -183,12 +183,26 @@ public: ////////////////////////////////////////////////////////////////////////////// // Utilities for inserting Wilson conserved current. ////////////////////////////////////////////////////////////////////////////// - void ContractConservedCurrentInternal(const PropagatorField &q_in_1, - const PropagatorField &q_in_2, - PropagatorField &q_out, - DoubledGaugeField &U, - Current curr_type, - unsigned int mu); + void ContractConservedCurrentSiteFwd(const PropagatorField &q_in_1, + const PropagatorField &q_in_2, + PropagatorField &q_out, + DoubledGaugeField &U, + unsigned int mu, + unsigned int sF_in_1, + unsigned int sF_in_2, + unsigned int sF_out, + unsigned int sU, + bool switch_sign = false); + void ContractConservedCurrentSiteBwd(const PropagatorField &q_in_1, + const PropagatorField &q_in_2, + PropagatorField &q_out, + DoubledGaugeField &U, + unsigned int mu, + unsigned int sF_in_1, + unsigned int sF_in_2, + unsigned int sF_out, + unsigned int sU, + bool switch_sign = false); void SeqConservedCurrentInternal(const PropagatorField &q_in, PropagatorField &q_out, DoubledGaugeField &U, From 41af8c12d70145320a1f2fd924464802f26cffff Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 16 Jun 2017 16:38:59 +0100 Subject: [PATCH 32/86] Code cleaning for conserved current contractions. Will now be easier to implement mobius conserved current. --- lib/qcd/action/fermion/WilsonFermion.cc | 26 ++++---- lib/qcd/action/fermion/WilsonFermion5D.cc | 40 ++++--------- lib/qcd/action/fermion/WilsonKernels.cc | 72 ++++++++++------------- lib/qcd/action/fermion/WilsonKernels.h | 22 +++---- 4 files changed, 64 insertions(+), 96 deletions(-) diff --git a/lib/qcd/action/fermion/WilsonFermion.cc b/lib/qcd/action/fermion/WilsonFermion.cc index 28842cdd..eff7d958 100644 --- a/lib/qcd/action/fermion/WilsonFermion.cc +++ b/lib/qcd/action/fermion/WilsonFermion.cc @@ -361,23 +361,23 @@ void WilsonFermion::ContractConservedCurrent(PropagatorField &q_in_1, conformable(_grid, q_in_1._grid); conformable(_grid, q_in_2._grid); conformable(_grid, q_out._grid); - PropagatorField tmp(_grid); + PropagatorField tmp1(_grid), tmp2(_grid); q_out = zero; - // Forward, need q1(x + mu), q2(x) - tmp = Cshift(q_in_1, mu, 1); + // Forward, need q1(x + mu), q2(x). Backward, need q1(x), q2(x + mu). + // Inefficient comms method but not performance critical. + tmp1 = Cshift(q_in_1, mu, 1); + tmp2 = Cshift(q_in_2, mu, 1); parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) { - Kernels::ContractConservedCurrentSiteFwd(tmp, q_in_2, q_out, Umu, - mu, sU, sU, sU, sU); - } - - // Backward, need q1(x), q2(x + mu) - tmp = Cshift(q_in_2, mu, 1); - parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) - { - Kernels::ContractConservedCurrentSiteBwd(q_in_1, tmp, q_out, Umu, - mu, sU, sU, sU, sU); + Kernels::ContractConservedCurrentSiteFwd(tmp1._odata[sU], + q_in_2._odata[sU], + q_out._odata[sU], + Umu, sU, mu); + Kernels::ContractConservedCurrentSiteBwd(q_in_1._odata[sU], + tmp2._odata[sU], + q_out._odata[sU], + Umu, sU, mu); } } diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index b69a18ba..76218098 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -686,13 +686,13 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, conformable(q_in_1._grid, FermionGrid()); conformable(q_in_1._grid, q_in_2._grid); conformable(_FourDimGrid, q_out._grid); - - PropagatorField tmp(FermionGrid()); + PropagatorField tmp1(FermionGrid()), tmp2(FermionGrid()); q_out = zero; - // Forward, need q1(x + mu, s), q2(x, Ls - 1 - s). 5D lattice so shift - // 4D coordinate mu by one. - tmp = Cshift(q_in_1, mu + 1, 1); + // Forward, need q1(x + mu, s), q2(x, Ls - 1 - s). Backward, need q1(x, s), + // q2(x + mu, Ls - 1 - s). 5D lattice so shift 4D coordinate mu by one. + tmp1 = Cshift(q_in_1, mu + 1, 1); + tmp2 = Cshift(q_in_2, mu + 1, 1); parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) { unsigned int sF1 = sU * Ls; @@ -701,28 +701,14 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, { bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ true : false; - Kernels::ContractConservedCurrentSiteFwd(tmp, q_in_2, q_out, Umu, - mu, sF1, sF2, sU, sU, - axial_sign); - sF1++; - sF2--; - } - } - - // Backward, need q1(x, s), q2(x + mu, Ls - 1 - s). 5D lattice so shift - // 4D coordinate mu by one. - tmp = Cshift(q_in_2, mu + 1, 1); - parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) - { - unsigned int sF1 = sU * Ls; - unsigned int sF2 = (sU + 1) * Ls - 1; - for (int s = 0; s < Ls; ++s) - { - bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ - true : false; - Kernels::ContractConservedCurrentSiteBwd(q_in_1, tmp, q_out, Umu, - mu, sF1, sF2, sU, sU, - axial_sign); + Kernels::ContractConservedCurrentSiteFwd(tmp1._odata[sF1], + q_in_2._odata[sF2], + q_out._odata[sU], + Umu, sU, mu, axial_sign); + Kernels::ContractConservedCurrentSiteBwd(q_in_1._odata[sF1], + tmp2._odata[sF2], + q_out._odata[sU], + Umu, sU, mu, axial_sign); sF1++; sF2--; } diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index c519dc56..6b193766 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -298,28 +298,25 @@ void WilsonKernels::DhopDir( StencilImpl &st, DoubledGaugeField &U,SiteHal ******************************************************************************/ template void WilsonKernels::ContractConservedCurrentSiteFwd( - const PropagatorField &q_in_1, - const PropagatorField &q_in_2, - PropagatorField &q_out, + const SitePropagator &q_in_1, + const SitePropagator &q_in_2, + SitePropagator &q_out, DoubledGaugeField &U, - unsigned int mu, - unsigned int sF_in_1, - unsigned int sF_in_2, - unsigned int sF_out, unsigned int sU, + unsigned int mu, bool switch_sign) { SitePropagator result, tmp; Gamma g5(Gamma::Algebra::Gamma5); - multLinkProp(tmp, U._odata[sU], q_in_1._odata[sF_in_1], mu); - result = g5 * adj(q_in_2._odata[sF_in_2]) * g5 * WilsonCurrentFwd(tmp, mu); + Impl::multLinkProp(tmp, U._odata[sU], q_in_1, mu); + result = g5 * adj(q_in_2) * g5 * WilsonCurrentFwd(tmp, mu); if (switch_sign) { - q_out._odata[sF_out] -= result; + q_out -= result; } else { - q_out._odata[sF_out] += result; + q_out += result; } } @@ -331,28 +328,25 @@ void WilsonKernels::ContractConservedCurrentSiteFwd( ******************************************************************************/ template void WilsonKernels::ContractConservedCurrentSiteBwd( - const PropagatorField &q_in_1, - const PropagatorField &q_in_2, - PropagatorField &q_out, + const SitePropagator &q_in_1, + const SitePropagator &q_in_2, + SitePropagator &q_out, DoubledGaugeField &U, - unsigned int mu, - unsigned int sF_in_1, - unsigned int sF_in_2, - unsigned int sF_out, unsigned int sU, + unsigned int mu, bool switch_sign) { SitePropagator result, tmp; Gamma g5(Gamma::Algebra::Gamma5); - multLinkProp(tmp, U._odata[sU], q_in_1._odata[sF_in_1], mu + Nd); - result = g5 * adj(q_in_2._odata[sF_in_2]) * g5 * WilsonCurrentBwd(tmp, mu); + Impl::multLinkProp(tmp, U._odata[sU], q_in_1, mu + Nd); + result = g5 * adj(q_in_2) * g5 * WilsonCurrentBwd(tmp, mu); if (switch_sign) { - q_out._odata[sF_out] += result; + q_out += result; } else { - q_out._odata[sF_out] -= result; + q_out -= result; } } @@ -360,31 +354,25 @@ void WilsonKernels::ContractConservedCurrentSiteBwd( #define NO_CURR_SITE(Impl) \ template <> \ void WilsonKernels::ContractConservedCurrentSiteFwd( \ - const PropagatorField &q_in_1, \ - const PropagatorField &q_in_2, \ - PropagatorField &q_out, \ - DoubledGaugeField &U, \ - unsigned int mu, \ - unsigned int sF_in_1, \ - unsigned int sF_in_2, \ - unsigned int sF_out, \ - unsigned int sU, \ - bool switch_sign) \ + const SitePropagator &q_in_1, \ + const SitePropagator &q_in_2, \ + SitePropagator &q_out, \ + DoubledGaugeField &U, \ + unsigned int sU, \ + unsigned int mu, \ + bool switch_sign) \ { \ assert(0); \ } \ template <> \ void WilsonKernels::ContractConservedCurrentSiteBwd( \ - const PropagatorField &q_in_1, \ - const PropagatorField &q_in_2, \ - PropagatorField &q_out, \ - DoubledGaugeField &U, \ - unsigned int mu, \ - unsigned int sF_in_1, \ - unsigned int sF_in_2, \ - unsigned int sF_out, \ - unsigned int sU, \ - bool switch_sign) \ + const SitePropagator &q_in_1, \ + const SitePropagator &q_in_2, \ + SitePropagator &q_out, \ + DoubledGaugeField &U, \ + unsigned int mu, \ + unsigned int sU, \ + bool switch_sign) \ { \ assert(0); \ } diff --git a/lib/qcd/action/fermion/WilsonKernels.h b/lib/qcd/action/fermion/WilsonKernels.h index 95155ccc..0294c740 100644 --- a/lib/qcd/action/fermion/WilsonKernels.h +++ b/lib/qcd/action/fermion/WilsonKernels.h @@ -183,25 +183,19 @@ public: ////////////////////////////////////////////////////////////////////////////// // Utilities for inserting Wilson conserved current. ////////////////////////////////////////////////////////////////////////////// - void ContractConservedCurrentSiteFwd(const PropagatorField &q_in_1, - const PropagatorField &q_in_2, - PropagatorField &q_out, + void ContractConservedCurrentSiteFwd(const SitePropagator &q_in_1, + const SitePropagator &q_in_2, + SitePropagator &q_out, DoubledGaugeField &U, - unsigned int mu, - unsigned int sF_in_1, - unsigned int sF_in_2, - unsigned int sF_out, unsigned int sU, + unsigned int mu, bool switch_sign = false); - void ContractConservedCurrentSiteBwd(const PropagatorField &q_in_1, - const PropagatorField &q_in_2, - PropagatorField &q_out, + void ContractConservedCurrentSiteBwd(const SitePropagator &q_in_1, + const SitePropagator &q_in_2, + SitePropagator &q_out, DoubledGaugeField &U, - unsigned int mu, - unsigned int sF_in_1, - unsigned int sF_in_2, - unsigned int sF_out, unsigned int sU, + unsigned int mu, bool switch_sign = false); void SeqConservedCurrentInternal(const PropagatorField &q_in, PropagatorField &q_out, From 1bd311ba9ccd8506d13064cb6f6829515a0f0240 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Fri, 16 Jun 2017 16:43:15 +0100 Subject: [PATCH 33/86] Faster sequential conserved current implementation, now compatible with 5D vectorisation & G-parity. --- lib/qcd/action/fermion/WilsonFermion.cc | 41 ++++++++- lib/qcd/action/fermion/WilsonFermion5D.cc | 68 +++++++++++--- lib/qcd/action/fermion/WilsonKernels.cc | 105 ++++++++++++---------- lib/qcd/action/fermion/WilsonKernels.h | 22 +++-- 4 files changed, 164 insertions(+), 72 deletions(-) diff --git a/lib/qcd/action/fermion/WilsonFermion.cc b/lib/qcd/action/fermion/WilsonFermion.cc index eff7d958..b986edd7 100644 --- a/lib/qcd/action/fermion/WilsonFermion.cc +++ b/lib/qcd/action/fermion/WilsonFermion.cc @@ -394,6 +394,8 @@ void WilsonFermion::SeqConservedCurrent(PropagatorField &q_in, conformable(_grid, q_out._grid); Lattice> ph(_grid), coor(_grid); Complex i(0.0,1.0); + PropagatorField tmpFwd(_grid), tmpBwd(_grid), tmp(_grid); + int tshift = (mu == Tp) ? 1 : 0; // Momentum projection ph = zero; @@ -404,8 +406,43 @@ void WilsonFermion::SeqConservedCurrent(PropagatorField &q_in, } ph = exp((Real)(2*M_PI)*i*ph); - Kernels::SeqConservedCurrentInternal(q_in, q_out, Umu, curr_type, mu, ph, - tmin, tmax); + q_out = zero; + LatticeInteger coords(_grid); + LatticeCoordinate(coords, Tp); + + // Need q(x + mu) and q(x - mu). + tmp = Cshift(q_in, mu, 1); + tmpFwd = tmp*ph; + tmp = ph*q_in; + tmpBwd = Cshift(tmp, mu, -1); + + parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) + { + // Compute the sequential conserved current insertion only if our simd + // object contains a timeslice we need. + vInteger t_mask = ((coords._odata[sU] >= tmin) && + (coords._odata[sU] <= tmax)); + Integer timeSlices = Reduce(t_mask); + + if (timeSlices > 0) + { + Kernels::SeqConservedCurrentSiteFwd(tmpFwd._odata[sU], + q_out._odata[sU], + Umu, sU, mu, t_mask); + } + + // Repeat for backward direction. + t_mask = ((coords._odata[sU] >= (tmin + tshift)) && + (coords._odata[sU] <= (tmax + tshift))); + timeSlices = Reduce(t_mask); + + if (timeSlices > 0) + { + Kernels::SeqConservedCurrentSiteBwd(tmpBwd._odata[sU], + q_out._odata[sU], + Umu, sU, mu, t_mask); + } + } } FermOpTemplateInstantiate(WilsonFermion); diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index 76218098..5daed3de 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -727,31 +727,73 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, { conformable(q_in._grid, FermionGrid()); conformable(q_in._grid, q_out._grid); - Lattice> ph(_FourDimGrid), coor(_FourDimGrid); - PropagatorField q_in_s(_FourDimGrid); - PropagatorField q_out_s(_FourDimGrid); + Lattice> ph(FermionGrid()), coor(FermionGrid()); + PropagatorField tmpFwd(FermionGrid()), tmpBwd(FermionGrid()), + tmp(FermionGrid()); Complex i(0.0, 1.0); + int tshift = (mu == Tp) ? 1 : 0; - // Momentum projection + // Momentum projection. ph = zero; for(unsigned int nu = 0; nu < Nd - 1; nu++) { - LatticeCoordinate(coor, nu); + // Shift coordinate lattice index by 1 to account for 5th dimension. + LatticeCoordinate(coor, nu + 1); ph = ph + mom[nu]*coor*((1./(_FourDimGrid->_fdimensions[nu]))); } ph = exp((Real)(2*M_PI)*i*ph); - // Sequential insertion across 5th dimension - for (int s = 0; s < Ls; s++) + q_out = zero; + LatticeInteger coords(_FourDimGrid); + LatticeCoordinate(coords, Tp); + + // Need q(x + mu, s) and q(x - mu, s). 5D lattice so shift 4D coordinate mu + // by one. + tmp = Cshift(q_in, mu + 1, 1); + tmpFwd = tmp*ph; + tmp = ph*q_in; + tmpBwd = Cshift(tmp, mu + 1, -1); + + parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) { - ExtractSlice(q_in_s, q_in, s, 0); - Kernels::SeqConservedCurrentInternal(q_in_s, q_out_s, Umu, curr_type, - mu, ph, tmin, tmax); - if ((curr_type == Current::Axial) && (s < Ls/2)) + // Compute the sequential conserved current insertion only if our simd + // object contains a timeslice we need. + vInteger t_mask = ((coords._odata[sU] >= tmin) && + (coords._odata[sU] <= tmax)); + Integer timeSlices = Reduce(t_mask); + + if (timeSlices > 0) { - q_out_s = -q_out_s; + unsigned int sF = sU * Ls; + for (unsigned int s = 0; s < Ls; ++s) + { + bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ + true : false; + Kernels::SeqConservedCurrentSiteFwd(tmpFwd._odata[sF], + q_out._odata[sF], Umu, sU, + mu, t_mask, axial_sign); + ++sF; + } + } + + // Repeat for backward direction. + t_mask = ((coords._odata[sU] >= (tmin + tshift)) && + (coords._odata[sU] <= (tmax + tshift))); + timeSlices = Reduce(t_mask); + + if (timeSlices > 0) + { + unsigned int sF = sU * Ls; + for (unsigned int s = 0; s < Ls; ++s) + { + bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ + true : false; + Kernels::SeqConservedCurrentSiteBwd(tmpBwd._odata[sF], + q_out._odata[sF], Umu, sU, + mu, t_mask, axial_sign); + ++sF; + } } - InsertSlice(q_out_s, q_out, s, 0); } } diff --git a/lib/qcd/action/fermion/WilsonKernels.cc b/lib/qcd/action/fermion/WilsonKernels.cc index 6b193766..dc66db23 100644 --- a/lib/qcd/action/fermion/WilsonKernels.cc +++ b/lib/qcd/action/fermion/WilsonKernels.cc @@ -383,63 +383,70 @@ NO_CURR_SITE(GparityWilsonImplFH); NO_CURR_SITE(GparityWilsonImplDF); -template -void WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, - PropagatorField &q_out, - DoubledGaugeField &U, - Current curr_type, - unsigned int mu, - Lattice> &ph, - unsigned int tmin, - unsigned int tmax) +/******************************************************************************* + * Name: SeqConservedCurrentSiteFwd + * Operation: (1/2) * U(x) * (g[mu] - 1) * q[x + mu] + * Notes: - DoubledGaugeField U assumed to contain -1/2 factor. + * - Pass in q_in shifted in +ve mu direction. + ******************************************************************************/ +template +void WilsonKernels::SeqConservedCurrentSiteFwd(const SitePropagator &q_in, + SitePropagator &q_out, + DoubledGaugeField &U, + unsigned int sU, + unsigned int mu, + vInteger t_mask, + bool switch_sign) { - int tshift = (mu == Tp) ? 1 : 0; - Real G_T = (curr_type == Current::Tadpole) ? -1. : 1.; - PropagatorField tmp(q_in._grid); - GaugeLinkField Umu(U._grid); - Umu = PeekIndex(U, mu); - Lattice> t(q_in._grid); - LatticeCoordinate(t, Tp); + SitePropagator result; + Impl::multLinkProp(result, U._odata[sU], q_in, mu); + result = WilsonCurrentFwd(result, mu); - tmp = this->CovShiftForward(Umu, mu, q_in)*ph; - tmp = where((t >= tmin) and (t <= tmax), tmp, 0.*tmp); - q_out = G_T*WilsonCurrentFwd(tmp, mu); + // Zero any unwanted timeslice entries. + result = predicatedWhere(t_mask, result, 0.*result); - tmp = q_in*ph; - tmp = this->CovShiftBackward(Umu, mu, tmp); - tmp = where((t >= tmin + tshift) and (t <= tmax + tshift), tmp, 0.*tmp); - q_out -= WilsonCurrentBwd(tmp, mu); + if (switch_sign) + { + q_out -= result; + } + else + { + q_out += result; + } } +/******************************************************************************* + * Name: SeqConservedCurrentSiteFwd + * Operation: (1/2) * U^dag(x) * (g[mu] + 1) * q[x - mu] + * Notes: - DoubledGaugeField U assumed to contain -1/2 factor. + * - Pass in q_in shifted in -ve mu direction. + ******************************************************************************/ +template +void WilsonKernels::SeqConservedCurrentSiteBwd(const SitePropagator &q_in, + SitePropagator &q_out, + DoubledGaugeField &U, + unsigned int sU, + unsigned int mu, + vInteger t_mask, + bool switch_sign) +{ + SitePropagator result; + Impl::multLinkProp(result, U._odata[sU], q_in, mu + Nd); + result = WilsonCurrentBwd(result, mu); -// GParity, (Z)DomainWallVec5D -> require special implementation -#define NO_CURR(Impl) \ -template <> void \ -WilsonKernels::SeqConservedCurrentInternal(const PropagatorField &q_in, \ - PropagatorField &q_out, \ - DoubledGaugeField &U, \ - Current curr_type, \ - unsigned int mu, \ - Lattice> &ph, \ - unsigned int tmin, \ - unsigned int tmax) \ -{ \ - assert(0); \ + // Zero any unwanted timeslice entries. + result = predicatedWhere(t_mask, result, 0.*result); + + if (switch_sign) + { + q_out += result; + } + else + { + q_out -= result; + } } -NO_CURR(GparityWilsonImplF); -NO_CURR(GparityWilsonImplD); -NO_CURR(GparityWilsonImplFH); -NO_CURR(GparityWilsonImplDF); -NO_CURR(DomainWallVec5dImplF); -NO_CURR(DomainWallVec5dImplD); -NO_CURR(DomainWallVec5dImplFH); -NO_CURR(DomainWallVec5dImplDF); -NO_CURR(ZDomainWallVec5dImplF); -NO_CURR(ZDomainWallVec5dImplD); -NO_CURR(ZDomainWallVec5dImplFH); -NO_CURR(ZDomainWallVec5dImplDF); - FermOpTemplateInstantiate(WilsonKernels); AdjointFermOpTemplateInstantiate(WilsonKernels); TwoIndexFermOpTemplateInstantiate(WilsonKernels); diff --git a/lib/qcd/action/fermion/WilsonKernels.h b/lib/qcd/action/fermion/WilsonKernels.h index 0294c740..ed8d6be9 100644 --- a/lib/qcd/action/fermion/WilsonKernels.h +++ b/lib/qcd/action/fermion/WilsonKernels.h @@ -197,14 +197,20 @@ public: unsigned int sU, unsigned int mu, bool switch_sign = false); - void SeqConservedCurrentInternal(const PropagatorField &q_in, - PropagatorField &q_out, - DoubledGaugeField &U, - Current curr_type, - unsigned int mu, - Lattice> &ph, - unsigned int tmin, - unsigned int tmax); + void SeqConservedCurrentSiteFwd(const SitePropagator &q_in, + SitePropagator &q_out, + DoubledGaugeField &U, + unsigned int sU, + unsigned int mu, + vInteger t_mask, + bool switch_sign = false); + void SeqConservedCurrentSiteBwd(const SitePropagator &q_in, + SitePropagator &q_out, + DoubledGaugeField &U, + unsigned int sU, + unsigned int mu, + vInteger t_mask, + bool switch_sign = false); private: // Specialised variants From 863bb2ad1007d7a00c8aedac932571d56d64a75f Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Thu, 22 Jun 2017 16:02:15 +0200 Subject: [PATCH 34/86] Moving overly-specialised code out of Grid --- tests/hadrons/Test_hadrons_rarekaon.cc | 321 ------------------------- 1 file changed, 321 deletions(-) delete mode 100644 tests/hadrons/Test_hadrons_rarekaon.cc diff --git a/tests/hadrons/Test_hadrons_rarekaon.cc b/tests/hadrons/Test_hadrons_rarekaon.cc deleted file mode 100644 index a85beead..00000000 --- a/tests/hadrons/Test_hadrons_rarekaon.cc +++ /dev/null @@ -1,321 +0,0 @@ -/******************************************************************************* - Grid physics library, www.github.com/paboyle/Grid - - Source file: tests/hadrons/Test_hadrons_rarekaon.cc - - Copyright (C) 2017 - - Author: Andrew Lawson - - This program 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 2 of the License, or - (at your option) any later version. - - This program 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 this program; if not, write to the Free Software Foundation, Inc., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - - See the full license in the file "LICENSE" in the top level distribution - directory. - *******************************************************************************/ - -#include "Test_hadrons.hpp" - -using namespace Grid; -using namespace Hadrons; - -enum quarks -{ - light = 0, - strange = 1, - charm = 2 -}; - -int main(int argc, char *argv[]) -{ - // parse command line ////////////////////////////////////////////////////// - std::string configStem; - - if (argc < 2) - { - std::cerr << "usage: " << argv[0] << " [Grid options]"; - std::cerr << std::endl; - std::exit(EXIT_FAILURE); - } - configStem = argv[1]; - - // initialization ////////////////////////////////////////////////////////// - HADRONS_DEFAULT_INIT; - - // run setup /////////////////////////////////////////////////////////////// - Application application; - std::vector mass = {.01, .04, .2}; - std::vector flavour = {"l", "s", "c"}; - std::vector solvers = {"CG_l", "CG_s", "CG_c"}; - std::string kmom = "0. 0. 0. 0."; - std::string pmom = "1. 0. 0. 0."; - std::string qmom = "-1. 0. 0. 0."; - std::string mqmom = "1. 0. 0. 0."; - std::vector tKs = {0}; - unsigned int dt_pi = 16; - std::vector tJs = {8}; - unsigned int n_noise = 1; - unsigned int nt = 32; - bool do_disconnected(false); - Gamma::Algebra gT = Gamma::Algebra::GammaT; - unsigned int Ls = 16; - double M5 = 1.8; - - // Global parameters. - HADRONS_DEFAULT_GLOBALS(application); - - // gauge field - std::string gaugeField = "gauge"; - if (configStem == "None") - { - application.createModule(gaugeField); - } - else - { - MGauge::Load::Par gaugePar; - gaugePar.file = configStem; - application.createModule(gaugeField, gaugePar); - } - - // set fermion boundary conditions to be periodic space, antiperiodic time. - std::string boundary = "1 1 1 -1"; - - for (unsigned int i = 0; i < flavour.size(); ++i) - { - // actions - std::string actionName = "DWF_" + flavour[i]; - makeDWFAction(application, actionName, gaugeField, mass[i], M5, Ls); - - // solvers - makeRBPrecCGSolver(application, solvers[i], actionName); - } - - // Create noise propagators for loops. - std::vector noiseSrcs; - std::vector> noiseRes; - std::vector> noiseProps; - if (n_noise > 0) - { - MSource::Z2::Par noisePar; - noisePar.tA = 0; - noisePar.tB = nt - 1; - std::string loop_stem = "loop_"; - - noiseRes.resize(flavour.size()); - noiseProps.resize(flavour.size()); - for (unsigned int nn = 0; nn < n_noise; ++nn) - { - std::string eta = INIT_INDEX("noise", nn); - application.createModule(eta, noisePar); - noiseSrcs.push_back(eta); - - for (unsigned int f = 0; f < flavour.size(); ++f) - { - std::string loop_prop = INIT_INDEX(loop_stem + flavour[f], nn); - std::string loop_res = loop_prop + "_res"; - makePropagator(application, loop_res, eta, solvers[f]); - makeLoop(application, loop_prop, eta, loop_res); - noiseRes[f].push_back(loop_res); - noiseProps[f].push_back(loop_prop); - } - } - } - - // Translate rare kaon decay across specified timeslices. - for (unsigned int i = 0; i < tKs.size(); ++i) - { - // Zero-momentum wall source propagators for kaon and pion. - unsigned int tK = tKs[i]; - unsigned int tpi = (tK + dt_pi) % nt; - std::string q_Kl_0 = INIT_INDEX("Q_l_0", tK); - std::string q_pil_0 = INIT_INDEX("Q_l_0", tpi); - MAKE_WALL_PROP(tK, q_Kl_0, solvers[light]); - MAKE_WALL_PROP(tpi, q_pil_0, solvers[light]); - - // Wall sources for kaon and pion with momentum insertion. If either - // p or k are zero, or p = k, re-use the existing name to avoid - // duplicating a propagator. - std::string q_Ks_k = INIT_INDEX("Q_Ks_k", tK); - std::string q_Ks_p = INIT_INDEX((kmom == pmom) ? "Q_Ks_k" : "Q_Ks_p", tK); - std::string q_pil_k = INIT_INDEX((kmom == ZERO_MOM) ? "Q_l_0" : "Q_l_k", tpi); - std::string q_pil_p = INIT_INDEX((pmom == kmom) ? q_pil_k : ((pmom == ZERO_MOM) ? "Q_l_0" : "Q_l_p"), tpi); - MAKE_3MOM_WALL_PROP(tK, kmom, q_Ks_k, solvers[strange]); - MAKE_3MOM_WALL_PROP(tK, pmom, q_Ks_p, solvers[strange]); - MAKE_3MOM_WALL_PROP(tpi, kmom, q_pil_k, solvers[light]); - MAKE_3MOM_WALL_PROP(tpi, pmom, q_pil_p, solvers[light]); - - /*********************************************************************** - * CONTRACTIONS: pi and K 2pt contractions with mom = p, k. - **********************************************************************/ - // Wall-Point - std::string PW_K_k = INIT_INDEX("PW_K_k", tK); - std::string PW_K_p = INIT_INDEX("PW_K_p", tK); - std::string PW_pi_k = INIT_INDEX("PW_pi_k", tpi); - std::string PW_pi_p = INIT_INDEX("PW_pi_p", tpi); - mesonContraction(application, 2, q_Kl_0, q_Ks_k, PW_K_k, kmom); - mesonContraction(application, 2, q_Kl_0, q_Ks_p, PW_K_p, pmom); - mesonContraction(application, 2, q_pil_k, q_pil_0, PW_pi_k, kmom); - mesonContraction(application, 2, q_pil_p, q_pil_0, PW_pi_p, pmom); - // Wall-Wall, to be done - requires modification of meson module. - - /*********************************************************************** - * CONTRACTIONS: 3pt Weak Hamiltonian, C & W (non-Eye type) classes. - **********************************************************************/ - std::string HW_CW_k = LABEL_3PT("HW_CW_k", tK, tpi); - std::string HW_CW_p = LABEL_3PT("HW_CW_p", tK, tpi); - weakContractionNonEye(application, 3, q_Kl_0, q_Ks_k, q_pil_k, q_pil_0, HW_CW_k); - weakContractionNonEye(application, 3, q_Kl_0, q_Ks_p, q_pil_p, q_pil_0, HW_CW_p); - - /*********************************************************************** - * CONTRACTIONS: 3pt sd insertion. - **********************************************************************/ - // Note: eventually will use wall sink smeared q_Kl_0 instead. - std::string sd_k = LABEL_3PT("sd_k", tK, tpi); - std::string sd_p = LABEL_3PT("sd_p", tK, tpi); - gamma3ptContraction(application, 3, q_Kl_0, q_Ks_k, q_pil_k, sd_k); - gamma3ptContraction(application, 3, q_Kl_0, q_Ks_p, q_pil_p, sd_p); - - for (unsigned int nn = 0; nn < n_noise; ++nn) - { - /******************************************************************* - * CONTRACTIONS: 3pt Weak Hamiltonian, S and E (Eye type) classes. - ******************************************************************/ - // Note: eventually will use wall sink smeared q_Kl_0 instead. - for (unsigned int f = 0; f < flavour.size(); ++f) - { - if ((f != strange) || do_disconnected) - { - std::string HW_SE_k = LABEL_3PT("HW_SE_k_" + flavour[f], tK, tpi); - std::string HW_SE_p = LABEL_3PT("HW_SE_p_" + flavour[f], tK, tpi); - std::string loop_q = noiseProps[f][nn]; - weakContractionEye(application, 3, q_Kl_0, q_Ks_k, q_pil_k, loop_q, HW_CW_k); - weakContractionEye(application, 3, q_Kl_0, q_Ks_p, q_pil_p, loop_q, HW_CW_p); - } - } - } - - // Perform separate contractions for each t_J position. - for (unsigned int j = 0; j < tJs.size(); ++j) - { - // Sequential sources for current insertions. Local for now, - // gamma_0 only. - unsigned int tJ = (tJs[j] + tK) % nt; - MSource::SeqGamma::Par seqPar; - std::string q_KlCl_q = LABEL_3PT("Q_KlCl_q", tK, tJ); - std::string q_KsCs_mq = LABEL_3PT("Q_KsCs_mq", tK, tJ); - std::string q_pilCl_q = LABEL_3PT("Q_pilCl_q", tpi, tJ); - std::string q_pilCl_mq = LABEL_3PT("Q_pilCl_mq", tpi, tJ); - MAKE_SEQUENTIAL_PROP(tJ, q_Kl_0, qmom, q_KlCl_q, solvers[light], gT); - MAKE_SEQUENTIAL_PROP(tJ, q_Ks_k, mqmom, q_KsCs_mq, solvers[strange], gT); - MAKE_SEQUENTIAL_PROP(tJ, q_pil_p, qmom, q_pilCl_q, solvers[light], gT); - MAKE_SEQUENTIAL_PROP(tJ, q_pil_0, mqmom, q_pilCl_mq, solvers[light], gT); - - /******************************************************************* - * CONTRACTIONS: pi and K 3pt contractions with current insertion. - ******************************************************************/ - // Wall-Point - std::string C_PW_Kl = LABEL_3PT("C_PW_Kl", tK, tJ); - std::string C_PW_Ksb = LABEL_3PT("C_PW_Ksb", tK, tJ); - std::string C_PW_pilb = LABEL_3PT("C_PW_pilb", tK, tJ); - std::string C_PW_pil = LABEL_3PT("C_PW_pil", tK, tJ); - mesonContraction(application, 3, q_KlCl_q, q_Ks_k, C_PW_Kl, pmom); - mesonContraction(application, 3, q_Kl_0, q_KsCs_mq, C_PW_Ksb, pmom); - mesonContraction(application, 3, q_pil_0, q_pilCl_q, C_PW_pilb, kmom); - mesonContraction(application, 3, q_pilCl_mq, q_pil_p, C_PW_pil, kmom); - // Wall-Wall, to be done. - - /******************************************************************* - * CONTRACTIONS: 4pt contractions, C & W classes. - ******************************************************************/ - std::string CW_Kl = LABEL_4PT("CW_Kl", tK, tJ, tpi); - std::string CW_Ksb = LABEL_4PT("CW_Ksb", tK, tJ, tpi); - std::string CW_pilb = LABEL_4PT("CW_pilb", tK, tJ, tpi); - std::string CW_pil = LABEL_4PT("CW_pil", tK, tJ, tpi); - weakContractionNonEye(application, 4, q_KlCl_q, q_Ks_k, q_pil_p, q_pil_0, CW_Kl); - weakContractionNonEye(application, 4, q_Kl_0, q_KsCs_mq, q_pil_p, q_pil_0, CW_Ksb); - weakContractionNonEye(application, 4, q_Kl_0, q_Ks_k, q_pilCl_q, q_pil_0, CW_pilb); - weakContractionNonEye(application, 4, q_Kl_0, q_Ks_k, q_pil_p, q_pilCl_mq, CW_pil); - - /******************************************************************* - * CONTRACTIONS: 4pt contractions, sd insertions. - ******************************************************************/ - // Note: eventually will use wall sink smeared q_Kl_0/q_KlCl_q instead. - std::string sd_Kl = LABEL_4PT("sd_Kl", tK, tJ, tpi); - std::string sd_Ksb = LABEL_4PT("sd_Ksb", tK, tJ, tpi); - std::string sd_pilb = LABEL_4PT("sd_pilb", tK, tJ, tpi); - gamma3ptContraction(application, 4, q_KlCl_q, q_Ks_k, q_pil_p, sd_Kl); - gamma3ptContraction(application, 4, q_Kl_0, q_KsCs_mq, q_pil_p, sd_Ksb); - gamma3ptContraction(application, 4, q_Kl_0, q_Ks_k, q_pilCl_q, sd_pilb); - - // Sequential sources for each noise propagator. - for (unsigned int nn = 0; nn < n_noise; ++nn) - { - std::string loop_stem = "loop_"; - - // Contraction required for each quark flavour - alternatively - // drop the strange loop if not performing disconnected - // contractions or neglecting H_W operators Q_3 -> Q_10. - for (unsigned int f = 0; f < flavour.size(); ++f) - { - if ((f != strange) || do_disconnected) - { - std::string eta = noiseSrcs[nn]; - std::string loop_q = noiseProps[f][nn]; - std::string loop_qCq = LABEL_3PT(loop_stem + flavour[f], tJ, nn); - std::string loop_qCq_res = loop_qCq + "_res"; - MAKE_SEQUENTIAL_PROP(tJ, noiseRes[f][nn], qmom, - loop_qCq_res, solvers[f], gT); - makeLoop(application, loop_qCq, eta, loop_qCq_res); - - /******************************************************* - * CONTRACTIONS: 4pt contractions, S & E classes. - ******************************************************/ - // Note: eventually will use wall sink smeared q_Kl_0/q_KlCl_q instead. - std::string SE_Kl = LABEL_4PT_NOISE("SE_Kl", tK, tJ, tpi, nn); - std::string SE_Ksb = LABEL_4PT_NOISE("SE_Ksb", tK, tJ, tpi, nn); - std::string SE_pilb = LABEL_4PT_NOISE("SE_pilb", tK, tJ, tpi, nn); - std::string SE_loop = LABEL_4PT_NOISE("SE_loop", tK, tJ, tpi, nn); - weakContractionEye(application, 4, q_KlCl_q, q_Ks_k, q_pil_p, loop_q, SE_Kl); - weakContractionEye(application, 4, q_Kl_0, q_KsCs_mq, q_pil_p, loop_q, SE_Ksb); - weakContractionEye(application, 4, q_Kl_0, q_Ks_k, q_pilCl_q, loop_q, SE_pilb); - weakContractionEye(application, 4, q_Kl_0, q_Ks_k, q_pil_p, loop_qCq, SE_loop); - - /******************************************************* - * CONTRACTIONS: 4pt contractions, pi0 disconnected - * loop. - ******************************************************/ - std::string disc0 = LABEL_4PT_NOISE("disc0", tK, tJ, tpi, nn); - disc0Contraction(application, q_Kl_0, q_Ks_k, q_pilCl_q, loop_q, disc0); - - /******************************************************* - * CONTRACTIONS: Disconnected loop. - ******************************************************/ - std::string discLoop = "disc_" + loop_qCq; - discLoopContraction(application, loop_qCq, discLoop); - } - } - } - } - } - // execution - std::string par_file_name = "rarekaon_000_100_tK0_tpi16_tJ8_noloop_mc0.2.xml"; - application.saveParameterFile(par_file_name); - application.run(); - - // epilogue - LOG(Message) << "Grid is finalizing now" << std::endl; - Grid_finalize(); - - return EXIT_SUCCESS; -} From 18211eb5b13fa2738061b4c48a7518c7368c2645 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Thu, 22 Jun 2017 16:03:59 +0200 Subject: [PATCH 35/86] Hadrons: Fixed test to use new implementation of meson module. --- tests/hadrons/Test_hadrons.hpp | 20 ++++++----- tests/hadrons/Test_hadrons_meson_3pt.cc | 47 ++++++++++--------------- 2 files changed, 30 insertions(+), 37 deletions(-) diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index a554425d..3492816d 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -71,6 +71,9 @@ using namespace Hadrons; #define NAME_WALL_SOURCE(t) NAME_3MOM_WALL_SOURCE(t, ZERO_MOM) #define NAME_POINT_SOURCE(pos) ("point_" + pos) +// Meson module "gammas" special values +#define ALL_GAMMAS "all" + #define MAKE_3MOM_WALL_PROP(tW, mom, propName, solver)\ {\ std::string srcName = NAME_3MOM_WALL_SOURCE(tW, mom);\ @@ -364,28 +367,27 @@ inline void makeLoop(Application &application, std::string &propName, * Name: mesonContraction * Purpose: Create meson contraction module and add to application module. * Parameters: application - main application that stores modules. - * npt - specify n-point correlator (for labelling). + * modName - unique module name. + * output - name of output files. * q1 - quark propagator 1. * q2 - quark propagator 2. - * label - unique label to construct module name. - * mom - momentum to project (default is zero) + * sink - sink smearing module. * gammas - gamma insertions at source and sink. * Returns: None. ******************************************************************************/ -inline void mesonContraction(Application &application, unsigned int npt, +inline void mesonContraction(Application &application, + std::string &modName, std::string &output, std::string &q1, std::string &q2, - std::string &label, - std::string mom = ZERO_MOM, + std::string &sink, std::string gammas = "") { - std::string modName = std::to_string(npt) + "pt_" + label; if (!(Environment::getInstance().hasModule(modName))) { MContraction::Meson::Par mesPar; - mesPar.output = std::to_string(npt) + "pt/" + label; + mesPar.output = output; mesPar.q1 = q1; mesPar.q2 = q2; - mesPar.mom = mom; + mesPar.sink = sink; mesPar.gammas = gammas; application.createModule(modName, mesPar); } diff --git a/tests/hadrons/Test_hadrons_meson_3pt.cc b/tests/hadrons/Test_hadrons_meson_3pt.cc index 7e487153..1cbb866d 100644 --- a/tests/hadrons/Test_hadrons_meson_3pt.cc +++ b/tests/hadrons/Test_hadrons_meson_3pt.cc @@ -25,7 +25,7 @@ directory. *******************************************************************************/ -#include +#include "Test_hadrons.hpp" using namespace Grid; using namespace Hadrons; @@ -127,43 +127,34 @@ int main(int argc, char *argv[]) } } + // Point sink. + std::string sink = "sink"; + MSink::Point::Par sinkPar; + sinkPar.mom = ZERO_MOM; + application.createModule(sink, sinkPar); + // contractions MContraction::Meson::Par mesPar; for (unsigned int i = 0; i < flavour.size(); ++i) for (unsigned int j = i; j < flavour.size(); ++j) { - mesPar.output = "mesons/Z2_" + flavour[i] + flavour[j]; - mesPar.q1 = qName[i]; - mesPar.q2 = qName[j]; - mesPar.gammas = "all"; - mesPar.mom = "0. 0. 0. 0."; - application.createModule("meson_Z2_" - + std::to_string(t) - + "_" - + flavour[i] - + flavour[j], - mesPar); + std::string modName = "meson_Z2_" + std::to_string(t) + "_" + \ + flavour[i] + flavour[j]; + std::string output = "mesons/Z2_" + flavour[i] + flavour[j]; + mesonContraction(application, modName, output, qName[i], qName[j], + sink, ALL_GAMMAS); } for (unsigned int i = 0; i < flavour.size(); ++i) for (unsigned int j = 0; j < flavour.size(); ++j) for (unsigned int mu = 0; mu < Nd; ++mu) { - MContraction::Meson::Par mesPar; - - mesPar.output = "3pt/Z2_" + flavour[i] + flavour[j] + "_" - + std::to_string(mu); - mesPar.q1 = qName[i]; - mesPar.q2 = seqName[j][mu]; - mesPar.gammas = "all"; - mesPar.mom = "0. 0. 0. 0."; - application.createModule("3pt_Z2_" - + std::to_string(t) - + "_" - + flavour[i] - + flavour[j] - + "_" - + std::to_string(mu), - mesPar); + std::string modName = "3pt_Z2_" + std::to_string(t) + "_" + \ + flavour[i] + flavour[j] + "_" + \ + std::to_string(mu); + std::string output = "3pt/Z2_" + flavour[i] + \ + flavour[j] + "_" + std::to_string(mu); + mesonContraction(application, modName, output, + qName[i], seqName[j][mu], sink, ALL_GAMMAS); } } From 7a3bd5c66c3e1f125801f17fcb0b3b4f1de5d274 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Thu, 22 Jun 2017 16:06:15 +0200 Subject: [PATCH 36/86] Hadrons: new conserved current contraction test (for regression testing) --- .../Test_hadrons_meson_conserved_3pt.cc | 115 ++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 tests/hadrons/Test_hadrons_meson_conserved_3pt.cc diff --git a/tests/hadrons/Test_hadrons_meson_conserved_3pt.cc b/tests/hadrons/Test_hadrons_meson_conserved_3pt.cc new file mode 100644 index 00000000..c9aeb2cc --- /dev/null +++ b/tests/hadrons/Test_hadrons_meson_conserved_3pt.cc @@ -0,0 +1,115 @@ +/******************************************************************************* + Grid physics library, www.github.com/paboyle/Grid + + Source file: tests/hadrons/Test_hadrons_meson_conserved_3pt.cc + + Copyright (C) 2017 + + Author: Andrew Lawson + + This program 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 2 of the License, or + (at your option) any later version. + + This program 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + + See the full license in the file "LICENSE" in the top level distribution + directory. + *******************************************************************************/ + +#include "Test_hadrons.hpp" + +using namespace Grid; +using namespace Hadrons; + +int main(int argc, char *argv[]) +{ + // initialization ////////////////////////////////////////////////////////// + HADRONS_DEFAULT_INIT; + + // run setup /////////////////////////////////////////////////////////////// + Application application; + + // actions parameters + double mass = 0.04; + unsigned int Ls = 16; + double M5 = 1.8; + + // kinematics + unsigned int nt = GridDefaultLatt()[Tp]; + unsigned int tSrc = 0; + unsigned int tJ = nt / 4; + std::string kmom = "0. 0. 0. 0."; + std::string pmom = "1. 0. 0. 0."; + + // Global parameters. + HADRONS_DEFAULT_GLOBALS(application); + + // Unit gauge field. + std::string gaugeField = "Unit gauge"; + application.createModule(gaugeField); + + // DWF action + std::string actionName = "DWF"; + makeDWFAction(application, actionName, gaugeField, mass, M5, Ls); + + // Solver + std::string solver = "CG"; + makeRBPrecCGSolver(application, solver, actionName); + + // main test body ////////////////////////////////////////////////////////// + // Point sink modules. + std::string sink_0 = "sink_0"; + std::string sink_p = "sink_p"; + MSink::Point::Par sinkPar; + sinkPar.mom = kmom; + application.createModule(sink_0, sinkPar); + sinkPar.mom = pmom; + application.createModule(sink_p, sinkPar); + + // 2pt pion contraction, zero momentum. + std::string q_0 = "Q_0"; + MAKE_WALL_PROP(tSrc, q_0, solver); + std::string modName = INIT_INDEX("2pt_pion_WP", tSrc); + std::string output = "2pt/pion_WP_0"; + mesonContraction(application, modName, output, q_0, q_0, sink_0); + + // 2pt pion contraction, with momentum p. + std::string q_p = "Q_p"; + MAKE_3MOM_WALL_PROP(tSrc, pmom, q_p, solver); + modName = INIT_INDEX("2pt_pion_WP_p", tSrc); + output = "2pt/pion_WP_p"; + mesonContraction(application, modName, output, q_0, q_p, sink_p); + + // 3pt pion(0) -> pion(p), with sequentially inserted vector current in + // time direction. + std::string qSeq = q_0 + INIT_INDEX("_seq_Vc3", tJ); + std::string q5d = LABEL_5D(q_0); // Need 5D prop for DWF conserved current. + std::string srcName = qSeq + "_src"; + modName = LABEL_3PT("3pt_pion_Vc3", tSrc, tJ); + output = "3pt/pion_Vc3_p"; + makeConservedSequentialSource(application, srcName, q5d, actionName, + tJ, Current::Vector, Tp, pmom); + makePropagator(application, qSeq, srcName, solver); + mesonContraction(application, modName, output, q_0, qSeq, sink_p); + + std::string par_file_name = "conserved_3pt.xml"; + application.saveParameterFile(par_file_name); + application.run(); + + // epilogue + LOG(Message) << "Grid is finalizing now" << std::endl; + Grid_finalize(); + + return EXIT_SUCCESS; +} + + \ No newline at end of file From dc6b2d30d2dea8ede405aef3f1a753eb7f5127f1 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Thu, 22 Jun 2017 16:09:45 +0200 Subject: [PATCH 37/86] Documentation fix --- extras/Hadrons/Modules/MContraction/Meson.hpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 7810326a..b71f7c08 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -51,8 +51,7 @@ BEGIN_HADRONS_NAMESPACE in a sequence (e.g. ""). Special values: "all" - perform all possible contractions. - - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0."), - given as multiples of (2*pi) / L. + - sink: module to compute the sink to use in contraction (string). */ /****************************************************************************** From 08b0e472aa46eb0cef6ad00eaab46cce35357781 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Thu, 22 Jun 2017 16:34:33 +0200 Subject: [PATCH 38/86] Fixed hadrons tests after merge --- tests/hadrons/Test_hadrons.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 3492816d..6ea51d72 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -329,10 +329,10 @@ inline void makePropagator(Application &application, std::string &propName, // If the propagator already exists, don't make the module again. if (!(Environment::getInstance().hasModule(propName))) { - Quark::Par quarkPar; + MFermion::GaugeProp::Par quarkPar; quarkPar.source = srcName; quarkPar.solver = solver; - application.createModule(propName, quarkPar); + application.createModule(propName, quarkPar); } } From 852ade029a64c6376d391205e607ae655c6d1c80 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Sun, 16 Jul 2017 13:41:47 +0100 Subject: [PATCH 39/86] Hadrons: Added module to sink a propagator --- extras/Hadrons/Modules.hpp | 1 + extras/Hadrons/Modules/MSink/Smear.hpp | 99 ++++++++++++++++++++++++++ extras/Hadrons/modules.inc | 1 + 3 files changed, 101 insertions(+) create mode 100644 extras/Hadrons/Modules/MSink/Smear.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 6e1b8823..d0d0d80d 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include diff --git a/extras/Hadrons/Modules/MSink/Smear.hpp b/extras/Hadrons/Modules/MSink/Smear.hpp new file mode 100644 index 00000000..9327001f --- /dev/null +++ b/extras/Hadrons/Modules/MSink/Smear.hpp @@ -0,0 +1,99 @@ +#ifndef Hadrons_MSink_Smear_hpp_ +#define Hadrons_MSink_Smear_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * Smear * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MSink) + +class SmearPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(SmearPar, + std::string, q, + std::string, sink); +}; + +template +class TSmear: public Module +{ +public: + FERM_TYPE_ALIASES(FImpl,); + SINK_TYPE_ALIASES(); +public: + // constructor + TSmear(const std::string name); + // destructor + virtual ~TSmear(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(Smear, TSmear, MSink); + +/****************************************************************************** + * TSmear implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TSmear::TSmear(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TSmear::getInput(void) +{ + std::vector in = {par().q, par().sink}; + + return in; +} + +template +std::vector TSmear::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TSmear::setup(void) +{ + unsigned int nt = env().getDim(Tp); + unsigned int size = nt * sizeof(SitePropagator); + env().registerObject(getName(), size); +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TSmear::execute(void) +{ + LOG(Message) << "Sink smearing propagator '" << par().q + << "' using sink function '" << par().sink << "'." + << std::endl; + + SinkFn &sink = *env().template getObject(par().sink); + PropagatorField &q = *env().template getObject(par().q); + SlicedPropagator *out = new SlicedPropagator(env().getDim(Tp)); + *out = sink(q); + env().setObject(getName(), out); +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_MSink_Smear_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 91d0bbe1..fbbb2eb9 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -31,6 +31,7 @@ modules_hpp =\ Modules/MScalar/FreeProp.hpp \ Modules/MScalar/Scalar.hpp \ Modules/MSink/Point.hpp \ + Modules/MSink/Smear.hpp \ Modules/MSolver/RBPrecCG.hpp \ Modules/MSource/Point.hpp \ Modules/MSource/SeqConserved.hpp \ From 6293d438cd6ff2201300298ba29b985962991202 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Sun, 16 Jul 2017 13:43:25 +0100 Subject: [PATCH 40/86] Hadrons: sink smearing compatibility for 3pt contraction modules. --- .../Hadrons/Modules/MContraction/Gamma3pt.hpp | 22 +++++++++++++--- .../Modules/MContraction/WeakHamiltonian.hpp | 1 + .../MContraction/WeakHamiltonianEye.cc | 25 +++++++++++-------- 3 files changed, 34 insertions(+), 14 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp index 7f643d49..162ab786 100644 --- a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp +++ b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp @@ -51,6 +51,14 @@ BEGIN_HADRONS_NAMESPACE * q1 * * trace(g5*q1*adj(q2)*g5*gamma*q3) + * + * options: + * - q1: sink smeared propagator, source at i + * - q2: propagator, source at i + * - q3: propagator, source at f + * - gamma: gamma matrix to insert + * - tSnk: sink position for propagator q1. + * */ /****************************************************************************** @@ -66,6 +74,7 @@ public: std::string, q2, std::string, q3, Gamma::Algebra, gamma, + unsigned int, tSnk, std::string, output); }; @@ -140,17 +149,22 @@ void TGamma3pt::execute(void) << par().q3 << "', with " << par().gamma << " insertion." << std::endl; + // Initialise variables. q2 and q3 are normal propagators, q1 may be + // sink smeared. CorrWriter writer(par().output); - PropagatorField1 &q1 = *env().template getObject(par().q1); + SlicedPropagator1 &q1 = *env().template getObject(par().q1); PropagatorField2 &q2 = *env().template getObject(par().q2); - PropagatorField3 &q3 = *env().template getObject(par().q3); + PropagatorField3 &q3 = *env().template getObject(par().q3); LatticeComplex c(env().getGrid()); Gamma g5(Gamma::Algebra::Gamma5); Gamma gamma(par().gamma); std::vector buf; Result result; - - c = trace(g5*q1*adj(q2)*(g5*gamma)*q3); + + // Extract relevant timeslice of sinked propagator q1, then contract & + // sum over all spacial positions of gamma insertion. + SitePropagator1 q1Snk = q1[par().tSnk]; + c = trace(g5*q1Snk*adj(q2)*(g5*gamma)*q3); sliceSum(c, buf, Tp); result.gamma = par().gamma; diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp index 0a3c2e31..302b207e 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp @@ -76,6 +76,7 @@ public: std::string, q2, std::string, q3, std::string, q4, + unsigned int, tSnk, std::string, output); }; diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc b/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc index a44c2534..314b080a 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc @@ -54,6 +54,8 @@ using namespace MContraction; * * S: trace(q3*g5*q1*adj(q2)*g5*gL[mu][p_1]*q4*gL[mu][p_2]) * E: trace(q3*g5*q1*adj(q2)*g5*gL[mu][p_1])*trace(q4*gL[mu][p_2]) + * + * Note q1 must be sink smeared. */ /****************************************************************************** @@ -94,15 +96,15 @@ void TWeakHamiltonianEye::execute(void) << "'." << std::endl; CorrWriter writer(par().output); - PropagatorField &q1 = *env().template getObject(par().q1); - PropagatorField &q2 = *env().template getObject(par().q2); - PropagatorField &q3 = *env().template getObject(par().q3); - PropagatorField &q4 = *env().template getObject(par().q4); - Gamma g5 = Gamma(Gamma::Algebra::Gamma5); - LatticeComplex expbuf(env().getGrid()); - std::vector corrbuf; - std::vector result(n_eye_diag); - unsigned int ndim = env().getNd(); + SlicedPropagator &q1 = *env().template getObject(par().q1); + PropagatorField &q2 = *env().template getObject(par().q2); + PropagatorField &q3 = *env().template getObject(par().q3); + PropagatorField &q4 = *env().template getObject(par().q4); + Gamma g5 = Gamma(Gamma::Algebra::Gamma5); + LatticeComplex expbuf(env().getGrid()); + std::vector corrbuf; + std::vector result(n_eye_diag); + unsigned int ndim = env().getNd(); PropagatorField tmp1(env().getGrid()); LatticeComplex tmp2(env().getGrid()); @@ -111,10 +113,13 @@ void TWeakHamiltonianEye::execute(void) std::vector E_body(ndim, tmp2); std::vector E_loop(ndim, tmp2); + // Get sink timeslice of q1. + SitePropagator q1Snk = q1[par().tSnk]; + // Setup for S-type contractions. for (int mu = 0; mu < ndim; ++mu) { - S_body[mu] = MAKE_SE_BODY(q1, q2, q3, GammaL(Gamma::gmu[mu])); + S_body[mu] = MAKE_SE_BODY(q1Snk, q2, q3, GammaL(Gamma::gmu[mu])); S_loop[mu] = MAKE_SE_LOOP(q4, GammaL(Gamma::gmu[mu])); } From 0366288b1c8a42ff15eacb0f5e23eee2e89fb50f Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Sun, 16 Jul 2017 13:45:55 +0100 Subject: [PATCH 41/86] Hadrons: added tests for 3pt contractions. --- tests/hadrons/Test_hadrons.hpp | 75 ++++++++--- .../hadrons/Test_hadrons_3pt_contractions.cc | 122 ++++++++++++++++++ 2 files changed, 182 insertions(+), 15 deletions(-) create mode 100644 tests/hadrons/Test_hadrons_3pt_contractions.cc diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 6ea51d72..9bd3ee0a 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -269,6 +269,26 @@ inline void makeConservedSequentialSource(Application &application, } } +/******************************************************************************* + * Name: makeNoiseSource + * Parameters: application - main application that stores modules. + * srcName - name of source module to create. + * tA - lower source timeslice limit. + * tB - upper source timeslice limit. + * Returns: None. + ******************************************************************************/ +inline void makeNoiseSource(Application &application, std::string &srcName, + unsigned int tA, unsigned int tB) +{ + if (!(Environment::getInstance().hasModule(srcName))) + { + MSource::Z2::Par noisePar; + noisePar.tA = tA; + noisePar.tB = tB; + application.createModule(srcName, noisePar); + } + } + /******************************************************************************* * Name: makeWallSource * Purpose: Construct wall source and add to application module. @@ -292,26 +312,46 @@ inline void makeWallSource(Application &application, std::string &srcName, } /******************************************************************************* - * Name: makeWallSink - * Purpose: Wall sink smearing of a propagator. + * Name: makePointSink + * Purpose: Create function for point sink smearing of a propagator. * Parameters: application - main application that stores modules. * propName - name of input propagator. - * wallName - name of smeared propagator. + * sinkFnct - name of output sink smearing module. * mom - momentum insertion (default is zero). * Returns: None. ******************************************************************************/ -inline void makeWallSink(Application &application, std::string &propName, - std::string &wallName, std::string mom = ZERO_MOM) +inline void makePointSink(Application &application, std::string &sinkFnct, + std::string mom = ZERO_MOM) +{ + // If the sink function already exists, don't make it again. + if (!(Environment::getInstance().hasModule(sinkFnct))) + { + MSink::Point::Par pointPar; + pointPar.mom = mom; + application.createModule(sinkFnct, pointPar); + } +} + +/******************************************************************************* + * Name: sinkSmear + * Purpose: Perform sink smearing of a propagator. + * Parameters: application - main application that stores modules. + * sinkFnct - sink smearing module. + * propName - propagator to smear. + * smearedProp - name of output smeared propagator. + * Returns: None. + ******************************************************************************/ +inline void sinkSmear(Application &application, std::string &sinkFnct, + std::string &propName, std::string &smearedProp) { // If the propagator has already been smeared, don't smear it again. - // Temporarily removed, strategy for sink smearing likely to change. - /*if (!(Environment::getInstance().hasModule(wallName))) + if (!(Environment::getInstance().hasModule(smearedProp))) { - MSink::Wall::Par wallPar; - wallPar.q = propName; - wallPar.mom = mom; - application.createModule(wallName, wallPar); - }*/ + MSink::Smear::Par smearPar; + smearPar.q = propName; + smearPar.sink = sinkFnct; + application.createModule(smearedProp, smearPar); + } } /******************************************************************************* @@ -398,16 +438,18 @@ inline void mesonContraction(Application &application, * Purpose: Create gamma3pt contraction module and add to application module. * Parameters: application - main application that stores modules. * npt - specify n-point correlator (for labelling). - * q1 - quark propagator 1. + * q1 - quark propagator 1, sink smeared. * q2 - quark propagator 2. * q3 - quark propagator 3. * label - unique label to construct module name. + * tSnk - sink position of sink for q1. * gamma - gamma insertions between q2 and q3. * Returns: None. ******************************************************************************/ inline void gamma3ptContraction(Application &application, unsigned int npt, std::string &q1, std::string &q2, - std::string &q3, std::string &label, + std::string &q3, std::string &label, + unsigned int tSnk = 0, Gamma::Algebra gamma = Gamma::Algebra::Identity) { std::string modName = std::to_string(npt) + "pt_" + label; @@ -418,6 +460,7 @@ inline void gamma3ptContraction(Application &application, unsigned int npt, gamma3ptPar.q1 = q1; gamma3ptPar.q2 = q2; gamma3ptPar.q3 = q3; + gamma3ptPar.tSnk = tSnk; gamma3ptPar.gamma = gamma; application.createModule(modName, gamma3ptPar); } @@ -434,13 +477,14 @@ inline void gamma3ptContraction(Application &application, unsigned int npt, * q3 - quark propagator 3. * q4 - quark propagator 4. * label - unique label to construct module name. + * tSnk - time position of sink (for sink smearing). * Returns: None. ******************************************************************************/ #define HW_CONTRACTION(top) \ inline void weakContraction##top(Application &application, unsigned int npt,\ std::string &q1, std::string &q2, \ std::string &q3, std::string &q4, \ - std::string &label)\ + std::string &label, unsigned int tSnk = 0)\ {\ std::string modName = std::to_string(npt) + "pt_" + label;\ if (!(Environment::getInstance().hasModule(modName)))\ @@ -451,6 +495,7 @@ inline void weakContraction##top(Application &application, unsigned int npt,\ weakPar.q2 = q2;\ weakPar.q3 = q3;\ weakPar.q4 = q4;\ + weakPar.tSnk = tSnk;\ application.createModule(modName, weakPar);\ }\ } diff --git a/tests/hadrons/Test_hadrons_3pt_contractions.cc b/tests/hadrons/Test_hadrons_3pt_contractions.cc new file mode 100644 index 00000000..452fc34d --- /dev/null +++ b/tests/hadrons/Test_hadrons_3pt_contractions.cc @@ -0,0 +1,122 @@ +/******************************************************************************* + Grid physics library, www.github.com/paboyle/Grid + + Source file: tests/hadrons/Test_hadrons_3pt_contractions.cc + + Copyright (C) 2017 + + Author: Andrew Lawson + + This program 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 2 of the License, or + (at your option) any later version. + + This program 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + + See the full license in the file "LICENSE" in the top level distribution + directory. + *******************************************************************************/ + +#include "Test_hadrons.hpp" + +using namespace Grid; +using namespace Hadrons; + +int main(int argc, char *argv[]) +{ + // initialization ////////////////////////////////////////////////////////// + HADRONS_DEFAULT_INIT; + + // run setup /////////////////////////////////////////////////////////////// + Application application; + double mass = 0.04; + double M5 = 1.8; + unsigned int Ls = 12; + unsigned int nt = GridDefaultLatt()[Tp]; + unsigned int t_i = 0; + unsigned int t_f = nt / 2; + std::string mom = "1. 0. 0. 0."; + + // global parameters + HADRONS_DEFAULT_GLOBALS(application); + + // gauge field + std::string gaugeField = "gauge"; + application.createModule(gaugeField); + + // Action & solver setup. + std::string action = "DWF"; + std::string solver = "CG"; + makeDWFAction(application, action, gaugeField, mass, M5, Ls); + makeRBPrecCGSolver(application, solver, action); + + /*************************************************************************** + * Weak Contraction test: Non-Eye class. + **************************************************************************/ + // Make wall source propagators for each leg of 4-quark vertex. + std::string q_i_0 = "q_i_0"; + std::string q_i_p = "q_i_p"; + std::string q_f_0 = "q_f_0"; + std::string q_f_p = "q_f_p"; + MAKE_WALL_PROP(t_i, q_i_0, solver); + MAKE_WALL_PROP(t_f, q_f_0, solver); + MAKE_3MOM_WALL_PROP(t_i, mom, q_i_p, solver); + MAKE_3MOM_WALL_PROP(t_f, mom, q_f_p, solver); + + // Perform contractions, zero and non-zero momentum. + std::string HW_CW_0 = LABEL_3PT("HW_CW_0", t_i, t_f); + std::string HW_CW_p = LABEL_3PT("HW_CW_p", t_i, t_f); + weakContractionNonEye(application, 3, q_i_0, q_i_0, q_f_0, q_f_0, HW_CW_0); + weakContractionNonEye(application, 3, q_i_0, q_i_p, q_f_p, q_f_0, HW_CW_p); + + /*************************************************************************** + * Weak Contraction test: Eye-class. + **************************************************************************/ + // Create random propagator for loop. + std::string eta = "noise_source"; + makeNoiseSource(application, eta, 0, nt - 1); + std::string loopProp = "loop"; + std::string loopRes = loopProp + "_res"; + makePropagator(application, loopRes, eta, solver); + makeLoop(application, loopProp, eta, loopRes); + + // Wall sink smear the propagator directly connecting the source & sink. + // (i.e. make point sink but smear before the contraction) + std::string wallSink = "wall_sink"; + std::string qWall = "q_wall"; + makePointSink(application, wallSink); + sinkSmear(application, wallSink, q_i_0, qWall); + + // Perform contractions, zero and non-zero momentum. + std::string HW_SE_0 = LABEL_3PT("HW_SE_0", t_i, t_f); + std::string HW_SE_p = LABEL_3PT("HW_SE_p", t_i, t_f); + weakContractionEye(application, 3, qWall, q_i_0, q_f_p, loopProp, HW_SE_0, t_f); + weakContractionEye(application, 3, qWall, q_i_p, q_f_p, loopProp, HW_SE_p, t_f); + + /*************************************************************************** + * Gamma insertion test. + **************************************************************************/ + Gamma::Algebra gamma = Gamma::Algebra::GammaT; + std::string sd_0 = LABEL_3PT("sd_0", t_i, t_f); + std::string sd_p = LABEL_3PT("sd_p", t_i, t_f); + gamma3ptContraction(application, 3, qWall, q_i_0, q_f_0, sd_0, t_f, gamma); + gamma3ptContraction(application, 3, qWall, q_i_p, q_f_p, sd_p, t_f, gamma); + + // execution + application.saveParameterFile("ContractionTest3pt.xml"); + application.run(); + + // epilogue + LOG(Message) << "Grid is finalizing now" << std::endl; + Grid_finalize(); + + return EXIT_SUCCESS; +} \ No newline at end of file From 875e1a841f24166084cc26e16aea363c1200070c Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Sun, 16 Jul 2017 13:47:00 +0100 Subject: [PATCH 42/86] Hadrons: updated Quark -> MFermion/GaugeProp module name in test. --- tests/hadrons/Test_hadrons_quark.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/hadrons/Test_hadrons_quark.cc b/tests/hadrons/Test_hadrons_quark.cc index 5b9d0ce1..eac065e9 100644 --- a/tests/hadrons/Test_hadrons_quark.cc +++ b/tests/hadrons/Test_hadrons_quark.cc @@ -26,7 +26,7 @@ *******************************************************************************/ #include "Test_hadrons.hpp" -#include +#include using namespace Grid; using namespace QCD; From 67b34e5789aec1b39d34c2cdbedb156ff9509e11 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 31 Jul 2017 11:35:01 +0100 Subject: [PATCH 43/86] Modified conserved current 5th dimension loop for compatibility with 5D vectorisation. --- lib/qcd/action/fermion/WilsonFermion5D.cc | 61 +++++++++++++++++------ 1 file changed, 46 insertions(+), 15 deletions(-) diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index 5daed3de..5ddfde9a 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -12,6 +12,7 @@ Author: Peter Boyle Author: Peter Boyle Author: paboyle Author: Guido Cossu +Author: Andrew Lawson This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -676,6 +677,21 @@ void WilsonFermion5D::MomentumSpacePropagatorHw(FermionField &out,const Fe * to make a conserved current sink or inserting the conserved current * sequentially. ******************************************************************************/ + +// Helper macro to reverse Simd vector. Fixme: slow, generic implementation. +#define REVERSE_LS(qSite, qSiteRev, Nsimd) \ +{ \ + std::vector qSiteVec(Nsimd); \ + extract(qSite, qSiteVec); \ + for (int i = 0; i < Nsimd / 2; ++i) \ + { \ + typename SitePropagator::scalar_object tmp = qSiteVec[i]; \ + qSiteVec[i] = qSiteVec[Nsimd - i - 1]; \ + qSiteVec[Nsimd - i - 1] = tmp; \ + } \ + merge(qSiteRev, qSiteVec); \ +} + template void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, PropagatorField &q_in_2, @@ -687,6 +703,7 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, conformable(q_in_1._grid, q_in_2._grid); conformable(_FourDimGrid, q_out._grid); PropagatorField tmp1(FermionGrid()), tmp2(FermionGrid()); + unsigned int LLs = q_in_1._grid->_rdimensions[0]; q_out = zero; // Forward, need q1(x + mu, s), q2(x, Ls - 1 - s). Backward, need q1(x, s), @@ -695,18 +712,33 @@ void WilsonFermion5D::ContractConservedCurrent(PropagatorField &q_in_1, tmp2 = Cshift(q_in_2, mu + 1, 1); parallel_for (unsigned int sU = 0; sU < Umu._grid->oSites(); ++sU) { - unsigned int sF1 = sU * Ls; - unsigned int sF2 = (sU + 1) * Ls - 1; - for (int s = 0; s < Ls; ++s) + unsigned int sF1 = sU * LLs; + unsigned int sF2 = (sU + 1) * LLs - 1; + + for (unsigned int s = 0; s < LLs; ++s) { - bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ - true : false; + bool axial_sign = ((curr_type == Current::Axial) && \ + (s < (LLs / 2))); + SitePropagator qSite2, qmuSite2; + + // If vectorised in 5th dimension, reverse q2 vector to match up + // sites correctly. + if (Impl::LsVectorised) + { + REVERSE_LS(q_in_2._odata[sF2], qSite2, Ls / LLs); + REVERSE_LS(tmp2._odata[sF2], qmuSite2, Ls / LLs); + } + else + { + qSite2 = q_in_2._odata[sF2]; + qmuSite2 = tmp2._odata[sF2]; + } Kernels::ContractConservedCurrentSiteFwd(tmp1._odata[sF1], - q_in_2._odata[sF2], + qSite2, q_out._odata[sU], Umu, sU, mu, axial_sign); Kernels::ContractConservedCurrentSiteBwd(q_in_1._odata[sF1], - tmp2._odata[sF2], + qmuSite2, q_out._odata[sU], Umu, sU, mu, axial_sign); sF1++; @@ -732,6 +764,7 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, tmp(FermionGrid()); Complex i(0.0, 1.0); int tshift = (mu == Tp) ? 1 : 0; + unsigned int LLs = q_in._grid->_rdimensions[0]; // Momentum projection. ph = zero; @@ -764,11 +797,10 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, if (timeSlices > 0) { - unsigned int sF = sU * Ls; - for (unsigned int s = 0; s < Ls; ++s) + unsigned int sF = sU * LLs; + for (unsigned int s = 0; s < LLs; ++s) { - bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ - true : false; + bool axial_sign = ((curr_type == Current::Axial) && (s < (LLs / 2))); Kernels::SeqConservedCurrentSiteFwd(tmpFwd._odata[sF], q_out._odata[sF], Umu, sU, mu, t_mask, axial_sign); @@ -783,11 +815,10 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, if (timeSlices > 0) { - unsigned int sF = sU * Ls; - for (unsigned int s = 0; s < Ls; ++s) + unsigned int sF = sU * LLs; + for (unsigned int s = 0; s < LLs; ++s) { - bool axial_sign = ((curr_type == Current::Axial) && (s < (Ls / 2))) ? \ - true : false; + bool axial_sign = ((curr_type == Current::Axial) && (s < (LLs / 2))); Kernels::SeqConservedCurrentSiteBwd(tmpBwd._odata[sF], q_out._odata[sF], Umu, sU, mu, t_mask, axial_sign); From 323e9c439ab0889d69c60b4736e1bd07d7724c06 Mon Sep 17 00:00:00 2001 From: Lanny91 Date: Mon, 31 Jul 2017 12:26:34 +0100 Subject: [PATCH 44/86] Hadrons: Legal banner fixes --- extras/Hadrons/Modules.hpp | 30 ++++++++++++++++++ extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 31 +++++++++++++++++++ extras/Hadrons/Modules/MSink/Point.hpp | 28 +++++++++++++++++ extras/Hadrons/Modules/MSink/Smear.hpp | 28 +++++++++++++++++ .../Modules/MUtilities/TestSeqGamma.hpp | 28 +++++++++++++++++ 5 files changed, 145 insertions(+) diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index d0d0d80d..e1f06f32 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -1,3 +1,33 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules.hpp + +Copyright (C) 2015 +Copyright (C) 2016 +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #include #include #include diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index 050f8381..8add9a00 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -1,3 +1,34 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MFermion/GaugeProp.hpp + +Copyright (C) 2015 +Copyright (C) 2016 +Copyright (C) 2017 + +Author: Antonin Portelli + Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_MFermion_GaugeProp_hpp_ #define Hadrons_MFermion_GaugeProp_hpp_ diff --git a/extras/Hadrons/Modules/MSink/Point.hpp b/extras/Hadrons/Modules/MSink/Point.hpp index 7b3aa9de..0761c4c4 100644 --- a/extras/Hadrons/Modules/MSink/Point.hpp +++ b/extras/Hadrons/Modules/MSink/Point.hpp @@ -1,3 +1,31 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MSink/Point.hpp + +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_MSink_Point_hpp_ #define Hadrons_MSink_Point_hpp_ diff --git a/extras/Hadrons/Modules/MSink/Smear.hpp b/extras/Hadrons/Modules/MSink/Smear.hpp index 9327001f..c3973d2b 100644 --- a/extras/Hadrons/Modules/MSink/Smear.hpp +++ b/extras/Hadrons/Modules/MSink/Smear.hpp @@ -1,3 +1,31 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MSink/Smear.hpp + +Copyright (C) 2017 + +Author: Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_MSink_Smear_hpp_ #define Hadrons_MSink_Smear_hpp_ diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp index 3dbd7d63..2799e5d0 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -1,3 +1,31 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp + +Copyright (C) 2017 + +Author: Andrew Lawson + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + #ifndef Hadrons_MUtilities_TestSeqGamma_hpp_ #define Hadrons_MUtilities_TestSeqGamma_hpp_ From df21668f2c6d25b2c8c79e353514956517ed7682 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Fri, 22 Sep 2017 14:21:18 +0100 Subject: [PATCH 45/86] memory profiler update --- lib/allocator/AlignedAllocator.cc | 4 +- lib/allocator/AlignedAllocator.h | 72 +++++++++++++++++++++++++++---- 2 files changed, 66 insertions(+), 10 deletions(-) diff --git a/lib/allocator/AlignedAllocator.cc b/lib/allocator/AlignedAllocator.cc index 967b2571..944e287f 100644 --- a/lib/allocator/AlignedAllocator.cc +++ b/lib/allocator/AlignedAllocator.cc @@ -3,9 +3,11 @@ namespace Grid { +MemoryStats *MemoryProfiler::stats = nullptr; + int PointerCache::victim; - PointerCache::PointerCacheEntry PointerCache::Entries[PointerCache::Ncache]; +PointerCache::PointerCacheEntry PointerCache::Entries[PointerCache::Ncache]; void *PointerCache::Insert(void *ptr,size_t bytes) { diff --git a/lib/allocator/AlignedAllocator.h b/lib/allocator/AlignedAllocator.h index e64a5949..68fad0d2 100644 --- a/lib/allocator/AlignedAllocator.h +++ b/lib/allocator/AlignedAllocator.h @@ -63,6 +63,18 @@ namespace Grid { static void *Lookup(size_t bytes) ; }; + + struct MemoryStats + { + size_t totalAllocated{0}, maxAllocated{0}, + currentlyAllocated{0}, totalFreed{0}; + }; + + class MemoryProfiler + { + public: + static MemoryStats *stats; + }; void check_huge_pages(void *Buf,uint64_t BYTES); @@ -93,6 +105,13 @@ public: { size_type bytes = __n*sizeof(_Tp); + if (auto s = MemoryProfiler::stats) + { + s->totalAllocated += bytes; + s->currentlyAllocated += bytes; + s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated); + } + _Tp *ptr = (_Tp *) PointerCache::Lookup(bytes); // if ( ptr != NULL ) // std::cout << "alignedAllocator "<<__n << " cache hit "<< std::hex << ptr <totalFreed += bytes; + s->currentlyAllocated -= bytes; + } + pointer __freeme = (pointer)PointerCache::Insert((void *)__p,bytes); #ifdef HAVE_MM_MALLOC_H @@ -172,10 +197,18 @@ public: #ifdef GRID_COMMS_SHMEM pointer allocate(size_type __n, const void* _p= 0) { + size_type bytes = __n*sizeof(_Tp); + + if (auto s = MemoryProfiler::stats) + { + s->totalAllocated += bytes; + s->currentlyAllocated += bytes; + s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated); + } #ifdef CRAY - _Tp *ptr = (_Tp *) shmem_align(__n*sizeof(_Tp),64); + _Tp *ptr = (_Tp *) shmem_align(bytes,64); #else - _Tp *ptr = (_Tp *) shmem_align(64,__n*sizeof(_Tp)); + _Tp *ptr = (_Tp *) shmem_align(64,bytes); #endif #ifdef PARANOID_SYMMETRIC_HEAP static void * bcast; @@ -193,18 +226,32 @@ public: #endif return ptr; } - void deallocate(pointer __p, size_type) { + void deallocate(pointer __p, size_type __n) { + size_type bytes = __n*sizeof(_Tp); + + if (auto s = MemoryProfiler::stats) + { + s->totalFreed += bytes; + s->currentlyAllocated -= bytes; + } shmem_free((void *)__p); } #else pointer allocate(size_type __n, const void* _p= 0) { -#ifdef HAVE_MM_MALLOC_H - _Tp * ptr = (_Tp *) _mm_malloc(__n*sizeof(_Tp),GRID_ALLOC_ALIGN); -#else - _Tp * ptr = (_Tp *) memalign(GRID_ALLOC_ALIGN,__n*sizeof(_Tp)); -#endif size_type bytes = __n*sizeof(_Tp); + + if (auto s = MemoryProfiler::stats) + { + s->totalAllocated += bytes; + s->currentlyAllocated += bytes; + s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated); + } +#ifdef HAVE_MM_MALLOC_H + _Tp * ptr = (_Tp *) _mm_malloc(bytes, GRID_ALLOC_ALIGN); +#else + _Tp * ptr = (_Tp *) memalign(GRID_ALLOC_ALIGN, bytes); +#endif uint8_t *cp = (uint8_t *)ptr; // One touch per 4k page, static OMP loop to catch same loop order #pragma omp parallel for schedule(static) @@ -213,7 +260,14 @@ public: } return ptr; } - void deallocate(pointer __p, size_type) { + void deallocate(pointer __p, size_type __n) { + size_type bytes = __n*sizeof(_Tp); + + if (auto s = MemoryProfiler::stats) + { + s->totalFreed += bytes; + s->currentlyAllocated -= bytes; + } #ifdef HAVE_MM_MALLOC_H _mm_free((void *)__p); #else From 94b8fb56862289c0663453c0e2d82fa6da310f38 Mon Sep 17 00:00:00 2001 From: paboyle Date: Sun, 19 Nov 2017 01:39:04 +0000 Subject: [PATCH 46/86] Debug in progress --- lib/communicator/Communicator_base.cc | 47 ++++++++++++------- lib/communicator/Communicator_mpi3.cc | 2 +- lib/lattice/Lattice_transfer.h | 67 +++++++++++++++++++++++++++ tests/solver/Test_dwf_mrhs_cg_mpi.cc | 6 +-- 4 files changed, 102 insertions(+), 20 deletions(-) diff --git a/lib/communicator/Communicator_base.cc b/lib/communicator/Communicator_base.cc index 531dd358..223b07fd 100644 --- a/lib/communicator/Communicator_base.cc +++ b/lib/communicator/Communicator_base.cc @@ -134,8 +134,18 @@ void CartesianCommunicator::AllToAll(void *in,void *out,uint64_t words,uint64_t CartesianCommunicator::CartesianCommunicator(const std::vector &processors,const CartesianCommunicator &parent,int &srank) { _ndimension = processors.size(); - assert(_ndimension = parent._ndimension); - + + int parent_ndimension = parent._ndimension; assert(_ndimension >= parent._ndimension); + std::vector parent_processor_coor(_ndimension,0); + std::vector parent_processors (_ndimension,1); + + // Can make 5d grid from 4d etc... + int pad = _ndimension-parent_ndimension; + for(int d=0;d &processors, std::vector ssize(_ndimension); // coor of split within parent for(int d=0;d<_ndimension;d++){ - ccoor[d] = parent._processor_coor[d] % processors[d]; - scoor[d] = parent._processor_coor[d] / processors[d]; - ssize[d] = parent._processors[d] / processors[d]; + ccoor[d] = parent_processor_coor[d] % processors[d]; + scoor[d] = parent_processor_coor[d] / processors[d]; + ssize[d] = parent_processors[d] / processors[d]; } int crank; // rank within subcomm ; srank is rank of subcomm within blocks of subcomms // Mpi uses the reverse Lexico convention to us @@ -166,38 +176,34 @@ CartesianCommunicator::CartesianCommunicator(const std::vector &processors, MPI_Comm comm_split; if ( Nchild > 1 ) { - /* std::cout << GridLogMessage<<"Child communicator of "<< std::hex << parent.communicator << std::dec< &processors, // Set up from the new split communicator ////////////////////////////////////////////////////////////////////////////////////////////////////// InitFromMPICommunicator(processors,comm_split); + + std::cout << " ndim " <<_ndimension<<" " << parent._ndimension << std::endl; + for(int d=0;d &out, const Lattice &in){ // NB: Easiest to programme if keep in lex order. // ///////////////////////////////////////////////////////// +/* +[0,0,0,0,0] S {V<4>{V<3>{(0,0),(0,0),(0,0)},V<3>{(0,0),(0,0),(0,0)},V<3>{(0,0),(0,0),(0,0)},V<3>{(0,0),(0,0),(0,0)}}} +[0,0,0,0,1] S {V<4>{V<3>{(1,0),(1,0),(1,0)},V<3>{(1,0),(1,0),(1,0)},V<3>{(1,0),(1,0),(1,0)},V<3>{(1,0),(1,0),(1,0)}}} +[0,0,0,0,2] S {V<4>{V<3>{(4,0),(4,0),(4,0)},V<3>{(4,0),(4,0),(4,0)},V<3>{(4,0),(4,0),(4,0)},V<3>{(4,0),(4,0),(4,0)}}} +[0,0,0,0,3] S {V<4>{V<3>{(5,0),(5,0),(5,0)},V<3>{(5,0),(5,0),(5,0)},V<3>{(5,0),(5,0),(5,0)},V<3>{(5,0),(5,0),(5,0)}}} +[0,0,0,0,4] S {V<4>{V<3>{(2,0),(2,0),(2,0)},V<3>{(2,0),(2,0),(2,0)},V<3>{(2,0),(2,0),(2,0)},V<3>{(2,0),(2,0),(2,0)}}} +[0,0,0,0,5] S {V<4>{V<3>{(3,0),(3,0),(3,0)},V<3>{(3,0),(3,0),(3,0)},V<3>{(3,0),(3,0),(3,0)},V<3>{(3,0),(3,0),(3,0)}}} +[0,0,0,0,6] S {V<4>{V<3>{(6,0),(6,0),(6,0)},V<3>{(6,0),(6,0),(6,0)},V<3>{(6,0),(6,0),(6,0)},V<3>{(6,0),(6,0),(6,0)}}} +[0,0,0,0,7] S {V<4>{V<3>{(7,0),(7,0),(7,0)},V<3>{(7,0),(7,0),(7,0)},V<3>{(7,0),(7,0),(7,0)},V<3>{(7,0),(7,0),(7,0)}}} +[0,0,0,0,8] S {V<4>{V<3>{(8,0),(8,0),(8,0)},V<3>{(8,0),(8,0),(8,0)},V<3>{(8,0),(8,0),(8,0)},V<3>{(8,0),(8,0),(8,0)}}} +[0,0,0,0,9] S {V<4>{V<3>{(9,0),(9,0),(9,0)},V<3>{(9,0),(9,0),(9,0)},V<3>{(9,0),(9,0),(9,0)},V<3>{(9,0),(9,0),(9,0)}}} +[0,0,0,0,10] S {V<4>{V<3>{(12,0),(12,0),(12,0)},V<3>{(12,0),(12,0),(12,0)},V<3>{(12,0),(12,0),(12,0)},V<3>{(12,0),(12,0),(12,0)}}} +[0,0,0,0,11] S {V<4>{V<3>{(13,0),(13,0),(13,0)},V<3>{(13,0),(13,0),(13,0)},V<3>{(13,0),(13,0),(13,0)},V<3>{(13,0),(13,0),(13,0)}}} +[0,0,0,0,12] S {V<4>{V<3>{(10,0),(10,0),(10,0)},V<3>{(10,0),(10,0),(10,0)},V<3>{(10,0),(10,0),(10,0)},V<3>{(10,0),(10,0),(10,0)}}} +[0,0,0,0,13] S {V<4>{V<3>{(11,0),(11,0),(11,0)},V<3>{(11,0),(11,0),(11,0)},V<3>{(11,0),(11,0),(11,0)},V<3>{(11,0),(11,0),(11,0)}}} +[0,0,0,0,14] S {V<4>{V<3>{(14,0),(14,0),(14,0)},V<3>{(14,0),(14,0),(14,0)},V<3>{(14,0),(14,0),(14,0)},V<3>{(14,0),(14,0),(14,0)}}} +[0,0,0,0,15] S {V<4>{V<3>{(15,0),(15,0),(15,0)},V<3>{(15,0),(15,0),(15,0)},V<3>{(15,0),(15,0),(15,0)},V<3>{(15,0),(15,0),(15,0)}}} + + +Process decomp +[A(0 1) A(2 3) B(0 1) B(2 3)] [ A(4 5) A(6 7) B(4 5) B(6 7)] [ A(8 9) A(10 11) B(8 9) B(10 11)] [A(12 13) A(14 15) B(12 13) B(14 15)] + +A2A(Full) + -- divides M*fL into fP segments of size M*fL/fP = fL/sP + -- total is fP * fL/sP = M * fL + A(0 1) A(4 5) A(8 9) A(12 13) + A(2 3) A(6 7) A(10 11) A(14 15) + B(0 1) B(4 5) B(8 9) B(12 13) + B(2 3) B(6 7) B(10 11) B(14 15) + + +A2A(Split) + A(0 1) A(4 5) A(2 3) A(6 7) + A(8 9) A(12 13) A(10 11) A(14 15) + B(0 1) B(2 3) B(4 5) B(6 7) + B(8 9) B(10 11) B(12 13) B(14 15) + +-------------------- +-- General case +-------------------- +G global lattice +fP - procs +sP - Procs in split grid +M - subdivisions/vectors - M*sP = fP ** constraint 1 +fL = G/fP per node (full) +sL = G/sP per node split + +[ G * M ] total = G*fP/sP. +[ Subdivide fL*M by fP => fL *M / fP = fL/fP *fP/sP = fL/sP ] +-------------------- +-- 1st A2A chunk is fL*M/fP = G/fP *fP/sP /fP = fL/sP +-- Let cL = fL/sP chunk. ( Divide into fP/sP = M chunks ) + +-- node 0 1st cL of node 0,1,... fP-1 ; vector 0 +-- node 1 2nd cL of node 0,1,... fP-1 +-- node 2 3nd cL of node 0,1,... fP-1 +-- node 3 4th cL of node 0,1,... fP-1 +... when node > sP get vector 1 etc... + +-- 2nd A2A (over sP nodes; subdivide the fP into sP chunks of M) +-- node 0 1st cL of node 0M..(1M-1); 2nd cL of node 0M..(1M-1)).. +-- node 1 1st cL of node 1M..(2M-1); 2nd cL of node 1M..(2M-1).. +-- node 2 1st cL of node 2M..(3M-1); 2nd cL of node 2M..(3M-1).. +-- node 3 1st cL of node 3M..(3M-1); 2nd cL of node 2M..(3M-1).. +-- +-- Insert correctly + */ template void Grid_split(std::vector > & full,Lattice & split) { diff --git a/tests/solver/Test_dwf_mrhs_cg_mpi.cc b/tests/solver/Test_dwf_mrhs_cg_mpi.cc index f640edff..d380f91e 100644 --- a/tests/solver/Test_dwf_mrhs_cg_mpi.cc +++ b/tests/solver/Test_dwf_mrhs_cg_mpi.cc @@ -95,7 +95,7 @@ int main (int argc, char ** argv) FermionField tmp(FGrid); for(int s=0;s HermOp(Ddwf); MdagMLinearOperator HermOpCk(Dchk); - ConjugateGradient CG((1.0e-5),10000); + ConjugateGradient CG((1.0e-2),10000); s_res = zero; CG(HermOp,s_src,s_res); From f403ab01336b6ec2cdc4260f698a0f5001bb0a3d Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 22 Nov 2017 17:13:09 +0000 Subject: [PATCH 47/86] gitignore update --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index d743ee06..399f2f6b 100644 --- a/.gitignore +++ b/.gitignore @@ -93,6 +93,7 @@ build*/* *.xcodeproj/* build.sh .vscode +*.code-workspace # Eigen source # ################ @@ -122,4 +123,3 @@ make-bin-BUCK.sh ##################### lib/qcd/spin/gamma-gen/*.h lib/qcd/spin/gamma-gen/*.cc - From a3fe874a5ba649fecec0a273e4f5a0dd52995a03 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 22 Nov 2017 23:27:19 +0000 Subject: [PATCH 48/86] Hadrons: everything is broken, repairing while implementing the new memory model --- extras/Hadrons/Application.cc | 14 +++ extras/Hadrons/Application.hpp | 2 + extras/Hadrons/Environment.cc | 106 ++++-------------- extras/Hadrons/Environment.hpp | 118 ++++++-------------- extras/Hadrons/Module.hpp | 6 + extras/Hadrons/Modules.hpp | 52 ++++----- extras/Hadrons/Modules/MAction/DWF.hpp | 25 ++--- extras/Hadrons/Modules/MAction/Wilson.hpp | 30 ++--- extras/Hadrons/Modules/MGauge/Unit.cc | 4 +- extras/Hadrons/Modules/MSolver/RBPrecCG.hpp | 27 ++--- extras/Hadrons/modules.inc | 74 ++++++------ 11 files changed, 174 insertions(+), 284 deletions(-) diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index 90ebcfd7..a94b617c 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -316,3 +316,17 @@ void Application::configLoop(void) LOG(Message) << BIG_SEP << " End of measurement " << BIG_SEP << std::endl; env().freeAll(); } + +// memory profile ////////////////////////////////////////////////////////////// +void Application::memoryProfile(void) +{ + auto graph = env().makeModuleGraph(); + auto program = graph.topoSort(); + bool msg; + + msg = HadronsLogMessage.isActive(); + HadronsLogMessage.Active(false); + + HadronsLogMessage.Active(msg); +} + diff --git a/extras/Hadrons/Application.hpp b/extras/Hadrons/Application.hpp index fce9b6eb..8b11b0c7 100644 --- a/extras/Hadrons/Application.hpp +++ b/extras/Hadrons/Application.hpp @@ -101,6 +101,8 @@ public: private: // environment shortcut Environment & env(void) const; + // memory profile + void memoryProfile(void); private: long unsigned int locVol_; std::string parameterFileName_{""}; diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index 0e7a4326..eb0a6f70 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -67,6 +67,16 @@ bool Environment::isDryRun(void) const return dryRun_; } +void Environment::memoryProfile(const bool doMemoryProfile) +{ + memoryProfile_ = doMemoryProfile; +} + +bool Environment::doMemoryProfile(void) const +{ + return memoryProfile_; +} + // trajectory number /////////////////////////////////////////////////////////// void Environment::setTrajectory(const unsigned int traj) { @@ -349,10 +359,10 @@ Environment::executeProgram(const std::vector &p) auto it = std::find_if(p.rbegin(), p.rend(), pred); if (it != p.rend()) { - freeProg[p.rend() - it - 1].insert(i); + freeProg[std::distance(p.rend(), it) - 1].insert(i); } } - + // program execution for (unsigned int i = 0; i < p.size(); ++i) { @@ -448,6 +458,7 @@ void Environment::addObject(const std::string name, const int moduleAddress) info.name = name; info.module = moduleAddress; + info.data = nullptr; object_.push_back(std::move(info)); objectAddress_[name] = static_cast(object_.size() - 1); } @@ -457,39 +468,6 @@ void Environment::addObject(const std::string name, const int moduleAddress) } } -void Environment::registerObject(const unsigned int address, - const unsigned int size, const unsigned int Ls) -{ - if (!hasRegisteredObject(address)) - { - if (hasObject(address)) - { - object_[address].size = size; - object_[address].Ls = Ls; - object_[address].isRegistered = true; - } - else - { - HADRON_ERROR("no object with address " + std::to_string(address)); - } - } - else - { - HADRON_ERROR("object with address " + std::to_string(address) - + " already registered"); - } -} - -void Environment::registerObject(const std::string name, - const unsigned int size, const unsigned int Ls) -{ - if (!hasObject(name)) - { - addObject(name); - } - registerObject(getObjectAddress(name), size, Ls); -} - unsigned int Environment::getObjectAddress(const std::string name) const { if (hasObject(name)) @@ -516,7 +494,7 @@ std::string Environment::getObjectName(const unsigned int address) const std::string Environment::getObjectType(const unsigned int address) const { - if (hasRegisteredObject(address)) + if (hasObject(address)) { if (object_[address].type) { @@ -527,11 +505,6 @@ std::string Environment::getObjectType(const unsigned int address) const return ""; } } - else if (hasObject(address)) - { - HADRON_ERROR("object with address " + std::to_string(address) - + " exists but is not registered"); - } else { HADRON_ERROR("no object with address " + std::to_string(address)); @@ -545,15 +518,10 @@ std::string Environment::getObjectType(const std::string name) const Environment::Size Environment::getObjectSize(const unsigned int address) const { - if (hasRegisteredObject(address)) + if (hasObject(address)) { return object_[address].size; } - else if (hasObject(address)) - { - HADRON_ERROR("object with address " + std::to_string(address) - + " exists but is not registered"); - } else { HADRON_ERROR("no object with address " + std::to_string(address)); @@ -584,15 +552,10 @@ unsigned int Environment::getObjectModule(const std::string name) const unsigned int Environment::getObjectLs(const unsigned int address) const { - if (hasRegisteredObject(address)) + if (hasObject(address)) { return object_[address].Ls; } - else if (hasObject(address)) - { - HADRON_ERROR("object with address " + std::to_string(address) - + " exists but is not registered"); - } else { HADRON_ERROR("no object with address " + std::to_string(address)); @@ -616,30 +579,6 @@ bool Environment::hasObject(const std::string name) const return ((it != objectAddress_.end()) and hasObject(it->second)); } -bool Environment::hasRegisteredObject(const unsigned int address) const -{ - if (hasObject(address)) - { - return object_[address].isRegistered; - } - else - { - return false; - } -} - -bool Environment::hasRegisteredObject(const std::string name) const -{ - if (hasObject(name)) - { - return hasRegisteredObject(getObjectAddress(name)); - } - else - { - return false; - } -} - bool Environment::hasCreatedObject(const unsigned int address) const { if (hasObject(address)) @@ -680,10 +619,7 @@ Environment::Size Environment::getTotalSize(void) const for (auto &o: object_) { - if (o.isRegistered) - { - size += o.size; - } + size += o.size; } return size; @@ -738,7 +674,7 @@ bool Environment::freeObject(const unsigned int address) { if (!hasOwners(address)) { - if (!isDryRun() and object_[address].isRegistered) + if (!isDryRun()) { LOG(Message) << "Destroying object '" << object_[address].name << "'" << std::endl; @@ -747,10 +683,8 @@ bool Environment::freeObject(const unsigned int address) { object_[p].owners.erase(address); } - object_[address].size = 0; - object_[address].Ls = 0; - object_[address].isRegistered = false; - object_[address].type = nullptr; + object_[address].size = 0; + object_[address].type = nullptr; object_[address].owners.clear(); object_[address].properties.clear(); object_[address].data.reset(nullptr); diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 13264bd5..b426fb27 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -83,12 +83,12 @@ private: std::string name; ModPt data{nullptr}; std::vector input; + size_t maxAllocated; }; struct ObjInfo { Size size{0}; unsigned int Ls{0}; - bool isRegistered{false}; const std::type_info *type{nullptr}; std::string name; int module{-1}; @@ -99,6 +99,8 @@ public: // dry run void dryRun(const bool isDry); bool isDryRun(void) const; + void memoryProfile(const bool doMemoryProfile); + bool doMemoryProfile(void) const; // trajectory number void setTrajectory(const unsigned int traj); unsigned int getTrajectory(void) const; @@ -143,32 +145,17 @@ public: // general memory management void addObject(const std::string name, const int moduleAddress = -1); - void registerObject(const unsigned int address, - const unsigned int size, - const unsigned int Ls = 1); - void registerObject(const std::string name, - const unsigned int size, - const unsigned int Ls = 1); + template + void createObject(const std::string name, + const unsigned int Ls, + Ts ... args); template - unsigned int lattice4dSize(void) const; - template - void registerLattice(const unsigned int address, - const unsigned int Ls = 1); - template - void registerLattice(const std::string name, - const unsigned int Ls = 1); - template - void setObject(const unsigned int address, T *object); - template - void setObject(const std::string name, T *object); + void createLattice(const std::string name, + const unsigned int Ls = 1); template T * getObject(const unsigned int address) const; template T * getObject(const std::string name) const; - template - T * createLattice(const unsigned int address); - template - T * createLattice(const std::string name); unsigned int getObjectAddress(const std::string name) const; std::string getObjectName(const unsigned int address) const; std::string getObjectType(const unsigned int address) const; @@ -181,8 +168,6 @@ public: unsigned int getObjectLs(const std::string name) const; bool hasObject(const unsigned int address) const; bool hasObject(const std::string name) const; - bool hasRegisteredObject(const unsigned int address) const; - bool hasRegisteredObject(const std::string name) const; bool hasCreatedObject(const unsigned int address) const; bool hasCreatedObject(const std::string name) const; bool isObject5d(const unsigned int address) const; @@ -204,7 +189,7 @@ public: void printContent(void); private: // general - bool dryRun_{false}; + bool dryRun_{false}, memoryProfile_{false}; unsigned int traj_, locVol_; // grids std::vector dim_; @@ -296,56 +281,45 @@ M * Environment::getModule(const std::string name) const return getModule(getModuleAddress(name)); } -template -unsigned int Environment::lattice4dSize(void) const +template +void Environment::createObject(const std::string name, const unsigned int Ls, + Ts ... args) { - return sizeof(typename T::vector_object)/getGrid()->Nsimd(); -} - -template -void Environment::registerLattice(const unsigned int address, - const unsigned int Ls) -{ - createGrid(Ls); - registerObject(address, Ls*lattice4dSize(), Ls); -} - -template -void Environment::registerLattice(const std::string name, const unsigned int Ls) -{ - createGrid(Ls); - registerObject(name, Ls*lattice4dSize(), Ls); -} - -template -void Environment::setObject(const unsigned int address, T *object) -{ - if (hasRegisteredObject(address)) + if (!hasObject(name)) { - object_[address].data.reset(new Holder(object)); - object_[address].type = &typeid(T); + addObject(name); } - else if (hasObject(address)) + + unsigned int address = getObjectAddress(name); + + if (!object_[address].data) { - HADRON_ERROR("object with address " + std::to_string(address) + - " exists but is not registered"); + MemoryStats memStats; + + MemoryProfiler::stats = &memStats; + object_[address].Ls = Ls; + object_[address].data.reset(new Holder(new T(args...))); + object_[address].size = memStats.totalAllocated; + object_[address].type = &typeid(T); } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + HADRON_ERROR("object '" + name + "' already allocated"); } } template -void Environment::setObject(const std::string name, T *object) +void Environment::createLattice(const std::string name, const unsigned int Ls) { - setObject(getObjectAddress(name), object); + GridCartesian *g = getGrid(Ls); + + createObject(name, Ls, g); } template T * Environment::getObject(const unsigned int address) const { - if (hasRegisteredObject(address)) + if (hasObject(address)) { if (auto h = dynamic_cast *>(object_[address].data.get())) { @@ -358,11 +332,6 @@ T * Environment::getObject(const unsigned int address) const "' (has type '" + getObjectType(address) + "')"); } } - else if (hasObject(address)) - { - HADRON_ERROR("object with address " + std::to_string(address) + - " exists but is not registered"); - } else { HADRON_ERROR("no object with address " + std::to_string(address)); @@ -375,26 +344,10 @@ T * Environment::getObject(const std::string name) const return getObject(getObjectAddress(name)); } -template -T * Environment::createLattice(const unsigned int address) -{ - GridCartesian *g = getGrid(getObjectLs(address)); - - setObject(address, new T(g)); - - return getObject(address); -} - -template -T * Environment::createLattice(const std::string name) -{ - return createLattice(getObjectAddress(name)); -} - template bool Environment::isObjectOfType(const unsigned int address) const { - if (hasRegisteredObject(address)) + if (hasObject(address)) { if (auto h = dynamic_cast *>(object_[address].data.get())) { @@ -405,11 +358,6 @@ bool Environment::isObjectOfType(const unsigned int address) const return false; } } - else if (hasObject(address)) - { - HADRON_ERROR("object with address " + std::to_string(address) + - " exists but is not registered"); - } else { HADRON_ERROR("no object with address " + std::to_string(address)); diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index 071e254a..5500bf36 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -88,6 +88,12 @@ static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance; #define ARG(...) __VA_ARGS__ +#define mCreateObj(type, name, Ls, ...)\ +env().template createObject(name, Ls, __VA_ARGS__) + +#define mGetObj(type, name)\ +*env().template getObject(name) + /****************************************************************************** * Module class * ******************************************************************************/ diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index e1f06f32..08678671 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -30,31 +30,31 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include +// #include #include -#include -#include -#include -#include -#include -#include +// #include +// #include +// #include +// #include +// #include +// #include #include -#include -#include -#include -#include -#include -#include -#include +// #include +// #include +// #include +// #include +// #include +// #include +// #include diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index 78e0916c..a2ed063b 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -102,37 +102,30 @@ std::vector TDWF::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// template void TDWF::setup(void) -{ - unsigned int size; - - size = 2*env().template lattice4dSize(); - env().registerObject(getName(), size, par().Ls); -} - -// execution /////////////////////////////////////////////////////////////////// -template -void TDWF::execute(void) { LOG(Message) << "Setting up domain wall fermion matrix with m= " << par().mass << ", M5= " << par().M5 << " and Ls= " << par().Ls << " using gauge field '" << par().gauge << "'" << std::endl; - LOG(Message) << "Fermion boundary conditions: " << par().boundary + LOG(Message) << "Fermion boundary conditions: " << par().boundary << std::endl; env().createGrid(par().Ls); - auto &U = *env().template getObject(par().gauge); + auto &U = mGetObj(LatticeGaugeField, par().gauge); auto &g4 = *env().getGrid(); auto &grb4 = *env().getRbGrid(); auto &g5 = *env().getGrid(par().Ls); auto &grb5 = *env().getRbGrid(par().Ls); std::vector boundary = strToVec(par().boundary); typename DomainWallFermion::ImplParams implParams(boundary); - FMat *fMatPt = new DomainWallFermion(U, g5, grb5, g4, grb4, - par().mass, par().M5, - implParams); - env().setObject(getName(), fMatPt); + mCreateObj(DomainWallFermion, getName(), par().Ls, + U, g5, grb5, g4, grb4, par().mass, par().M5, implParams); } +// execution /////////////////////////////////////////////////////////////////// +template +void TDWF::execute(void) +{} + END_MODULE_NAMESPACE END_HADRONS_NAMESPACE diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index aab54245..bc892daf 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -101,29 +101,23 @@ std::vector TWilson::getOutput(void) template void TWilson::setup(void) { - unsigned int size; - - size = 2*env().template lattice4dSize(); - env().registerObject(getName(), size); + LOG(Message) << "Setting up TWilson fermion matrix with m= " << par().mass + << " using gauge field '" << par().gauge << "'" << std::endl; + LOG(Message) << "Fermion boundary conditions: " << par().boundary + << std::endl; + auto &U = mGetObj(LatticeGaugeField, par().gauge); + auto &grid = *env().getGrid(); + auto &gridRb = *env().getRbGrid(); + std::vector boundary = strToVec(par().boundary); + typename WilsonFermion::ImplParams implParams(boundary); + mCreateObj(WilsonFermion, getName(), 1, U, grid, gridRb, par().mass, + implParams); } // execution /////////////////////////////////////////////////////////////////// template void TWilson::execute() -{ - LOG(Message) << "Setting up TWilson fermion matrix with m= " << par().mass - << " using gauge field '" << par().gauge << "'" << std::endl; - LOG(Message) << "Fermion boundary conditions: " << par().boundary - << std::endl; - auto &U = *env().template getObject(par().gauge); - auto &grid = *env().getGrid(); - auto &gridRb = *env().getRbGrid(); - std::vector boundary = strToVec(par().boundary); - typename WilsonFermion::ImplParams implParams(boundary); - FMat *fMatPt = new WilsonFermion(U, grid, gridRb, par().mass, - implParams); - env().setObject(getName(), fMatPt); -} +{} END_MODULE_NAMESPACE diff --git a/extras/Hadrons/Modules/MGauge/Unit.cc b/extras/Hadrons/Modules/MGauge/Unit.cc index 18d75c59..b259b7d5 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.cc +++ b/extras/Hadrons/Modules/MGauge/Unit.cc @@ -57,13 +57,13 @@ std::vector TUnit::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TUnit::setup(void) { - env().registerLattice(getName()); + mCreateObj(LatticeGaugeField, getName(), 1, env().getGrid()); } // execution /////////////////////////////////////////////////////////////////// void TUnit::execute(void) { LOG(Message) << "Creating unit gauge configuration" << std::endl; - LatticeGaugeField &U = *env().createLattice(getName()); + auto &U = mGetObj(LatticeGaugeField, getName()); SU3::ColdConfiguration(*env().get4dRng(), U); } diff --git a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp index b1f63a5d..fe6992fc 100644 --- a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp +++ b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp @@ -100,17 +100,12 @@ std::vector TRBPrecCG::getOutput(void) template void TRBPrecCG::setup(void) { - auto Ls = env().getObjectLs(par().action); - - env().registerObject(getName(), 0, Ls); - env().addOwnership(getName(), par().action); -} + LOG(Message) << "setting up Schur red-black preconditioned CG for" + << " action '" << par().action << "' with residual " + << par().residual << std::endl; -// execution /////////////////////////////////////////////////////////////////// -template -void TRBPrecCG::execute(void) -{ - auto &mat = *(env().template getObject(par().action)); + auto Ls = env().getObjectLs(par().action); + auto &mat = mGetObj(FMat, par().action); auto solver = [&mat, this](FermionField &sol, const FermionField &source) { ConjugateGradient cg(par().residual, 10000); @@ -118,13 +113,15 @@ void TRBPrecCG::execute(void) schurSolver(mat, source, sol); }; - - LOG(Message) << "setting up Schur red-black preconditioned CG for" - << " action '" << par().action << "' with residual " - << par().residual << std::endl; - env().setObject(getName(), new SolverFn(solver)); + mCreateObj(SolverFn, getName(), Ls, solver); + env().addOwnership(getName(), par().action); } +// execution /////////////////////////////////////////////////////////////////// +template +void TRBPrecCG::execute(void) +{} + END_MODULE_NAMESPACE END_HADRONS_NAMESPACE diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index fbbb2eb9..63745baf 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -1,42 +1,44 @@ modules_cc =\ - Modules/MContraction/WeakHamiltonianEye.cc \ - Modules/MContraction/WeakHamiltonianNonEye.cc \ - Modules/MContraction/WeakNeutral4ptDisc.cc \ - Modules/MGauge/Load.cc \ - Modules/MGauge/Random.cc \ - Modules/MGauge/StochEm.cc \ - Modules/MGauge/Unit.cc \ - Modules/MScalar/ChargedProp.cc \ - Modules/MScalar/FreeProp.cc + Modules/MGauge/Unit.cc + # Modules/MContraction/WeakHamiltonianEye.cc \ + # Modules/MContraction/WeakHamiltonianNonEye.cc \ + # Modules/MContraction/WeakNeutral4ptDisc.cc \ + # Modules/MGauge/Load.cc \ + # Modules/MGauge/Random.cc \ + # Modules/MGauge/StochEm.cc \ + # Modules/MScalar/ChargedProp.cc \ + # Modules/MScalar/FreeProp.cc modules_hpp =\ Modules/MAction/DWF.hpp \ Modules/MAction/Wilson.hpp \ - Modules/MContraction/Baryon.hpp \ - Modules/MContraction/DiscLoop.hpp \ - Modules/MContraction/Gamma3pt.hpp \ - Modules/MContraction/Meson.hpp \ - Modules/MContraction/WardIdentity.hpp \ - Modules/MContraction/WeakHamiltonian.hpp \ - Modules/MContraction/WeakHamiltonianEye.hpp \ - Modules/MContraction/WeakHamiltonianNonEye.hpp \ - Modules/MContraction/WeakNeutral4ptDisc.hpp \ - Modules/MFermion/GaugeProp.hpp \ - Modules/MGauge/Load.hpp \ - Modules/MGauge/Random.hpp \ - Modules/MGauge/StochEm.hpp \ Modules/MGauge/Unit.hpp \ - Modules/MLoop/NoiseLoop.hpp \ - Modules/MScalar/ChargedProp.hpp \ - Modules/MScalar/FreeProp.hpp \ - Modules/MScalar/Scalar.hpp \ - Modules/MSink/Point.hpp \ - Modules/MSink/Smear.hpp \ - Modules/MSolver/RBPrecCG.hpp \ - Modules/MSource/Point.hpp \ - Modules/MSource/SeqConserved.hpp \ - Modules/MSource/SeqGamma.hpp \ - Modules/MSource/Wall.hpp \ - Modules/MSource/Z2.hpp \ - Modules/MUtilities/TestSeqConserved.hpp \ - Modules/MUtilities/TestSeqGamma.hpp + Modules/MSolver/RBPrecCG.hpp + + # Modules/MContraction/Baryon.hpp \ + # Modules/MContraction/DiscLoop.hpp \ + # Modules/MContraction/Gamma3pt.hpp \ + # Modules/MContraction/Meson.hpp \ + # Modules/MContraction/WardIdentity.hpp \ + # Modules/MContraction/WeakHamiltonian.hpp \ + # Modules/MContraction/WeakHamiltonianEye.hpp \ + # Modules/MContraction/WeakHamiltonianNonEye.hpp \ + # Modules/MContraction/WeakNeutral4ptDisc.hpp \ + # Modules/MFermion/GaugeProp.hpp \ + # Modules/MGauge/Load.hpp \ + # Modules/MGauge/Random.hpp \ + # Modules/MGauge/StochEm.hpp \ + # Modules/MLoop/NoiseLoop.hpp \ + # Modules/MScalar/ChargedProp.hpp \ + # Modules/MScalar/FreeProp.hpp \ + # Modules/MScalar/Scalar.hpp \ + # Modules/MSink/Point.hpp \ + # Modules/MSink/Smear.hpp \ + # Modules/MSolver/RBPrecCG.hpp \ + # Modules/MSource/Point.hpp \ + # Modules/MSource/SeqConserved.hpp \ + # Modules/MSource/SeqGamma.hpp \ + # Modules/MSource/Wall.hpp \ + # Modules/MSource/Z2.hpp \ + # Modules/MUtilities/TestSeqConserved.hpp \ + # Modules/MUtilities/TestSeqGamma.hpp From e55397bc134ead26dbac8e2ef244406a8b9d6a3b Mon Sep 17 00:00:00 2001 From: azusayamaguchi Date: Fri, 24 Nov 2017 14:18:30 +0000 Subject: [PATCH 49/86] Staggerd cg --- lib/algorithms/LinearOperator.h | 20 +++++++++++--------- lib/algorithms/iterative/SchurRedBlack.h | 9 +++++++-- lib/lattice/Lattice_transfer.h | 16 ++++++---------- tests/solver/Test_staggered_cg_schur.cc | 14 ++++++++++++++ 4 files changed, 38 insertions(+), 21 deletions(-) diff --git a/lib/algorithms/LinearOperator.h b/lib/algorithms/LinearOperator.h index 0fa039c8..26746e6e 100644 --- a/lib/algorithms/LinearOperator.h +++ b/lib/algorithms/LinearOperator.h @@ -308,32 +308,34 @@ namespace Grid { public: SchurStaggeredOperator (Matrix &Mat): _Mat(Mat){}; virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){ + GridLogIterative.TimingMode(1); + std::cout << GridLogIterative << " HermOpAndNorm "< inline void pickCheckerboard(int cb,Lattice &half,const Lattice &full){ half.checkerboard = cb; - int ssh=0; - //parallel_for - for(int ss=0;ssoSites();ss++){ - std::vector coor; + + parallel_for(int ss=0;ssoSites();ss++){ int cbos; - + std::vector coor; full._grid->oCoorFromOindex(coor,ss); cbos=half._grid->CheckerBoard(coor); if (cbos==cb) { + int ssh=half._grid->oIndex(coor); half._odata[ssh] = full._odata[ss]; - ssh++; } } } template inline void setCheckerboard(Lattice &full,const Lattice &half){ int cb = half.checkerboard; - int ssh=0; - //parallel_for - for(int ss=0;ssoSites();ss++){ + parallel_for(int ss=0;ssoSites();ss++){ std::vector coor; int cbos; @@ -77,8 +73,8 @@ inline void subdivides(GridBase *coarse,GridBase *fine) cbos=half._grid->CheckerBoard(coor); if (cbos==cb) { + int ssh=half._grid->oIndex(coor); full._odata[ss]=half._odata[ssh]; - ssh++; } } } diff --git a/tests/solver/Test_staggered_cg_schur.cc b/tests/solver/Test_staggered_cg_schur.cc index 09044995..a5c25b85 100644 --- a/tests/solver/Test_staggered_cg_schur.cc +++ b/tests/solver/Test_staggered_cg_schur.cc @@ -70,7 +70,21 @@ int main (int argc, char ** argv) ConjugateGradient CG(1.0e-8,10000); SchurRedBlackStaggeredSolve SchurSolver(CG); + double volume=1.0; + for(int mu=0;mu volume * 1146 + double ncall=CG.IterationsToComplete; + double flops=(16*(3*(6+8+8)) + 15*3*2)*volume*ncall; // == 66*16 + == 1146 + + std::cout< &processors, ////////////////////////////////////////////////////////////////////////////////////////////////////// InitFromMPICommunicator(processors,comm_split); - std::cout << " ndim " <<_ndimension<<" " << parent._ndimension << std::endl; - for(int d=0;d &proc MPI_Comm_rank(communicator,&_processor); MPI_Cart_coords(communicator,_processor,_ndimension,&_processor_coor[0]); - if ( communicator_base != communicator_world ) { + if ( 0 && (communicator_base != communicator_world) ) { std::cout << "InitFromMPICommunicator Cartesian communicator created with a non-world communicator"< Date: Mon, 27 Nov 2017 12:33:08 +0000 Subject: [PATCH 51/86] Believe split/unsplit works, but need to make pretty --- lib/lattice/Lattice_transfer.h | 201 ++++++++++++++++++++++----------- 1 file changed, 133 insertions(+), 68 deletions(-) diff --git a/lib/lattice/Lattice_transfer.h b/lib/lattice/Lattice_transfer.h index dd03fb4f..3d9289d6 100644 --- a/lib/lattice/Lattice_transfer.h +++ b/lib/lattice/Lattice_transfer.h @@ -890,50 +890,85 @@ void Grid_split(std::vector > & full,Lattice & split) if ( ratio[d] != 1 ) { full_grid ->AllToAll(d,alldata,tmpdata); - // std::cout << GridLogMessage << "Grid_split: dim " <_processors[d]<_processors[d] > 1 ) { + alldata=tmpdata; + split_grid->AllToAll(d,alldata,tmpdata); + } - auto rdims = ldims; rdims[d] *= ratio[d]; - auto rsites= lsites*ratio[d]; - for(int v=0;v_processors[d]; + int fP = full_grid->_processors[d]; - for(int r=0;r_processors[d] > 1 ) { - tmpdata = alldata; - split_grid->AllToAll(d,tmpdata,alldata); - } } } vectorizeFromLexOrdArray(alldata,split); @@ -1008,55 +1043,84 @@ void Grid_unsplit(std::vector > & full,Lattice & split) std::vector rcoor(ndim); int nvec = 1; - lsites = split_grid->lSites(); - std::vector ldims = split_grid->_ldimensions; + uint64_t rsites = split_grid->lSites(); + std::vector rdims = split_grid->_ldimensions; - // for(int d=ndim-1;d>=0;d--){ for(int d=0;d_processors[d]; + int fP = full_grid->_processors[d]; - if ( split_grid->_processors[d] > 1 ) { - tmpdata = alldata; - split_grid->AllToAll(d,tmpdata,alldata); - } + int M = ratio[d]; + auto ldims = rdims; ldims[d] /= M; // Decrease local dims by same factor + auto lsites= rsites/M; // Decreases rsites by M - ////////////////////////////////////////// - //Local volume for this dimension is expanded by ratio of processor extents - // Number of vectors is decreased by same factor - // Rearrange to lexico for bigger volume - ////////////////////////////////////////// - auto rsites= lsites/ratio[d]; - auto rdims = ldims; rdims[d]/=ratio[d]; + int fvol = lsites; + int svol = rsites; + int chunk = (nvec*fvol)/sP; + int cL = (nvec*ldims[d])/sP; + + for(int c=0;c= tmpdata.size() ) { - // rsite, rcoor --> smaller local volume - // lsite, lcoor --> bigger original (single node?) volume - // For loop over each site within smaller subvol - for(int rsite=0;rsiteAllToAll(d,tmpdata,alldata); + if ( split_grid->_processors[d] > 1 ) { + split_grid->AllToAll(d,tmpdata,alldata); + tmpdata=alldata; + } + full_grid ->AllToAll(d,tmpdata,alldata); + + rdims[d]/= M; + rsites /= M; + nvec *= M; // Increase nvec by subdivision factor + } } } @@ -1064,12 +1128,13 @@ void Grid_unsplit(std::vector > & full,Lattice & split) for(int v=0;v Date: Mon, 27 Nov 2017 12:34:25 +0000 Subject: [PATCH 52/86] Clean on multinode target after split 1 1 2 4 -> 1 1 2 2 --- tests/solver/Test_dwf_mrhs_cg_mpi.cc | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tests/solver/Test_dwf_mrhs_cg_mpi.cc b/tests/solver/Test_dwf_mrhs_cg_mpi.cc index d380f91e..b3611e01 100644 --- a/tests/solver/Test_dwf_mrhs_cg_mpi.cc +++ b/tests/solver/Test_dwf_mrhs_cg_mpi.cc @@ -121,12 +121,12 @@ int main (int argc, char ** argv) random(pRNG5,src[s]); tmp = 100.0*s; src[s] = (src[s] * 0.1) + tmp; - std::cout << " src ["< Date: Mon, 27 Nov 2017 15:10:22 +0000 Subject: [PATCH 53/86] Debug --- tests/solver/Test_dwf_mrhs_cg_mpi.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/solver/Test_dwf_mrhs_cg_mpi.cc b/tests/solver/Test_dwf_mrhs_cg_mpi.cc index b3611e01..06df58c6 100644 --- a/tests/solver/Test_dwf_mrhs_cg_mpi.cc +++ b/tests/solver/Test_dwf_mrhs_cg_mpi.cc @@ -173,6 +173,7 @@ int main (int argc, char ** argv) // std::cout << " s_src \n" << s_src << std::endl; // std::cout << " s_src_tmp \n" << s_src_tmp << std::endl; // std::cout << " s_src_diff \n" << s_src_diff << std::endl; + // exit(0); #endif /////////////////////////////////////////////////////////////// From 28ceacec45e052578cf6b4fa1f394c87f417d1d2 Mon Sep 17 00:00:00 2001 From: paboyle Date: Mon, 27 Nov 2017 15:13:29 +0000 Subject: [PATCH 54/86] Split/Unsplit working --- lib/lattice/Lattice_transfer.h | 275 ++++++++------------------------- 1 file changed, 65 insertions(+), 210 deletions(-) diff --git a/lib/lattice/Lattice_transfer.h b/lib/lattice/Lattice_transfer.h index 78b80ba4..c7e2a507 100644 --- a/lib/lattice/Lattice_transfer.h +++ b/lib/lattice/Lattice_transfer.h @@ -694,30 +694,6 @@ void precisionChange(Lattice &out, const Lattice &in){ //////////////////////////////////////////////////////////////////////////////// // Communicate between grids //////////////////////////////////////////////////////////////////////////////// -// -// All to all plan -// -// Subvolume on fine grid is v. Vectors a,b,c,d -// -/////////////////////////////////////////////////////////////////////////////////////////////////////////// -// SIMPLEST CASE: -/////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Mesh of nodes (2) ; subdivide to 1 subdivisions -// -// Lex ord: -// N0 va0 vb0 N1 va1 vb1 -// -// For each dimension do an all to all -// -// full AllToAll(0) -// N0 va0 va1 N1 vb0 vb1 -// -// REARRANGE -// N0 va01 N1 vb01 -// -// Must also rearrange data to get into the NEW lex order of grid at each stage. Some kind of "insert/extract". -// NB: Easiest to programme if keep in lex order. -// /////////////////////////////////////////////////////////////////////////////////////////////////////////// // SIMPLE CASE: /////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -751,75 +727,16 @@ void precisionChange(Lattice &out, const Lattice &in){ // // Must also rearrange data to get into the NEW lex order of grid at each stage. Some kind of "insert/extract". // NB: Easiest to programme if keep in lex order. -// -///////////////////////////////////////////////////////// /* - -[0,0,0,0,0] S {V<4>{V<3>{(0,0),(0,0),(0,0)},V<3>{(0,0),(0,0),(0,0)},V<3>{(0,0),(0,0),(0,0)},V<3>{(0,0),(0,0),(0,0)}}} -[0,0,0,0,1] S {V<4>{V<3>{(1,0),(1,0),(1,0)},V<3>{(1,0),(1,0),(1,0)},V<3>{(1,0),(1,0),(1,0)},V<3>{(1,0),(1,0),(1,0)}}} -[0,0,0,0,2] S {V<4>{V<3>{(4,0),(4,0),(4,0)},V<3>{(4,0),(4,0),(4,0)},V<3>{(4,0),(4,0),(4,0)},V<3>{(4,0),(4,0),(4,0)}}} -[0,0,0,0,3] S {V<4>{V<3>{(5,0),(5,0),(5,0)},V<3>{(5,0),(5,0),(5,0)},V<3>{(5,0),(5,0),(5,0)},V<3>{(5,0),(5,0),(5,0)}}} -[0,0,0,0,4] S {V<4>{V<3>{(2,0),(2,0),(2,0)},V<3>{(2,0),(2,0),(2,0)},V<3>{(2,0),(2,0),(2,0)},V<3>{(2,0),(2,0),(2,0)}}} -[0,0,0,0,5] S {V<4>{V<3>{(3,0),(3,0),(3,0)},V<3>{(3,0),(3,0),(3,0)},V<3>{(3,0),(3,0),(3,0)},V<3>{(3,0),(3,0),(3,0)}}} -[0,0,0,0,6] S {V<4>{V<3>{(6,0),(6,0),(6,0)},V<3>{(6,0),(6,0),(6,0)},V<3>{(6,0),(6,0),(6,0)},V<3>{(6,0),(6,0),(6,0)}}} -[0,0,0,0,7] S {V<4>{V<3>{(7,0),(7,0),(7,0)},V<3>{(7,0),(7,0),(7,0)},V<3>{(7,0),(7,0),(7,0)},V<3>{(7,0),(7,0),(7,0)}}} -[0,0,0,0,8] S {V<4>{V<3>{(8,0),(8,0),(8,0)},V<3>{(8,0),(8,0),(8,0)},V<3>{(8,0),(8,0),(8,0)},V<3>{(8,0),(8,0),(8,0)}}} -[0,0,0,0,9] S {V<4>{V<3>{(9,0),(9,0),(9,0)},V<3>{(9,0),(9,0),(9,0)},V<3>{(9,0),(9,0),(9,0)},V<3>{(9,0),(9,0),(9,0)}}} -[0,0,0,0,10] S {V<4>{V<3>{(12,0),(12,0),(12,0)},V<3>{(12,0),(12,0),(12,0)},V<3>{(12,0),(12,0),(12,0)},V<3>{(12,0),(12,0),(12,0)}}} -[0,0,0,0,11] S {V<4>{V<3>{(13,0),(13,0),(13,0)},V<3>{(13,0),(13,0),(13,0)},V<3>{(13,0),(13,0),(13,0)},V<3>{(13,0),(13,0),(13,0)}}} -[0,0,0,0,12] S {V<4>{V<3>{(10,0),(10,0),(10,0)},V<3>{(10,0),(10,0),(10,0)},V<3>{(10,0),(10,0),(10,0)},V<3>{(10,0),(10,0),(10,0)}}} -[0,0,0,0,13] S {V<4>{V<3>{(11,0),(11,0),(11,0)},V<3>{(11,0),(11,0),(11,0)},V<3>{(11,0),(11,0),(11,0)},V<3>{(11,0),(11,0),(11,0)}}} -[0,0,0,0,14] S {V<4>{V<3>{(14,0),(14,0),(14,0)},V<3>{(14,0),(14,0),(14,0)},V<3>{(14,0),(14,0),(14,0)},V<3>{(14,0),(14,0),(14,0)}}} -[0,0,0,0,15] S {V<4>{V<3>{(15,0),(15,0),(15,0)},V<3>{(15,0),(15,0),(15,0)},V<3>{(15,0),(15,0),(15,0)},V<3>{(15,0),(15,0),(15,0)}}} - - -Process decomp -[A(0 1) A(2 3) B(0 1) B(2 3)] [ A(4 5) A(6 7) B(4 5) B(6 7)] [ A(8 9) A(10 11) B(8 9) B(10 11)] [A(12 13) A(14 15) B(12 13) B(14 15)] - -A2A(Full) - -- divides M*fL into fP segments of size M*fL/fP = fL/sP - -- total is fP * fL/sP = M * fL - A(0 1) A(4 5) A(8 9) A(12 13) - A(2 3) A(6 7) A(10 11) A(14 15) - B(0 1) B(4 5) B(8 9) B(12 13) - B(2 3) B(6 7) B(10 11) B(14 15) - - -A2A(Split) - A(0 1) A(4 5) A(2 3) A(6 7) - A(8 9) A(12 13) A(10 11) A(14 15) - B(0 1) B(2 3) B(4 5) B(6 7) - B(8 9) B(10 11) B(12 13) B(14 15) - --------------------- --- General case --------------------- -G global lattice -fP - procs -sP - Procs in split grid -M - subdivisions/vectors - M*sP = fP ** constraint 1 -fL = G/fP per node (full) -sL = G/sP per node split - -[ G * M ] total = G*fP/sP. -[ Subdivide fL*M by fP => fL *M / fP = fL/fP *fP/sP = fL/sP ] --------------------- --- 1st A2A chunk is fL*M/fP = G/fP *fP/sP /fP = fL/sP --- Let cL = fL/sP chunk. ( Divide into fP/sP = M chunks ) - --- node 0 1st cL of node 0,1,... fP-1 ; vector 0 --- node 1 2nd cL of node 0,1,... fP-1 --- node 2 3nd cL of node 0,1,... fP-1 --- node 3 4th cL of node 0,1,... fP-1 -... when node > sP get vector 1 etc... - --- 2nd A2A (over sP nodes; subdivide the fP into sP chunks of M) --- node 0 1st cL of node 0M..(1M-1); 2nd cL of node 0M..(1M-1)).. --- node 1 1st cL of node 1M..(2M-1); 2nd cL of node 1M..(2M-1).. --- node 2 1st cL of node 2M..(3M-1); 2nd cL of node 2M..(3M-1).. --- node 3 1st cL of node 3M..(3M-1); 2nd cL of node 2M..(3M-1).. --- --- Insert correctly + * Let chunk = (fvol*nvec)/sP be size of a chunk. ( Divide lexico vol * nvec into fP/sP = M chunks ) + * + * 2nd A2A (over sP nodes; subdivide the fP into sP chunks of M) + * + * node 0 1st chunk of node 0M..(1M-1); 2nd chunk of node 0M..(1M-1).. data chunk x M x sP = fL / sP * M * sP = fL * M growth + * node 1 1st chunk of node 1M..(2M-1); 2nd chunk of node 1M..(2M-1).. + * node 2 1st chunk of node 2M..(3M-1); 2nd chunk of node 2M..(3M-1).. + * node 3 1st chunk of node 3M..(3M-1); 2nd chunk of node 2M..(3M-1).. + * etc... */ template void Grid_split(std::vector > & full,Lattice & split) @@ -879,7 +796,6 @@ void Grid_split(std::vector > & full,Lattice & split) int nvec = nvector; // Counts down to 1 as we collapse dims std::vector ldims = full_grid->_ldimensions; - std::vector lcoor(ndim); for(int d=ndim-1;d>=0;d--){ @@ -891,73 +807,40 @@ void Grid_split(std::vector > & full,Lattice & split) split_grid->AllToAll(d,alldata,tmpdata); } - /* --- Let chunk = (fL*nvec)/sP chunk. ( Divide into fP/sP = M chunks ) --- --- 2nd A2A (over sP nodes; subdivide the fP into sP chunks of M) --- --- node 0 1st chunk of node 0M..(1M-1); 2nd chunk of node 0M..(1M-1).. data chunk x M x sP = fL / sP * M * sP = fL * M growth --- node 1 1st chunk of node 1M..(2M-1); 2nd chunk of node 1M..(2M-1).. --- node 2 1st chunk of node 2M..(3M-1); 2nd chunk of node 2M..(3M-1).. --- node 3 1st chunk of node 3M..(3M-1); 2nd chunk of node 2M..(3M-1).. --- --- Loop over c = 0..chunk-1 --- Loop over n = 0..M --- Loop over j = 0..sP --- total chunk*M*sP = fL/sP*fP/sP*sP = G/sP = sL --- csite = (c+m*chunk)% --- split into m*chunk+o = lsite*nvec/fP --- Must turn to vec, rsite, - */ - auto rdims = ldims; - int M = ratio[d]; - nvec /= M; // Reduce nvec by subdivision factor - rdims[d] *= M; // increase local dims by same factor + auto M = ratio[d]; auto rsites= lsites*M;// increases rsites by M + nvec /= M; // Reduce nvec by subdivision factor + rdims[d] *= M; // increase local dim by same factor int sP = split_grid->_processors[d]; int fP = full_grid->_processors[d]; int fvol = lsites; - int svol = rsites; - int chunk = (nvec*fvol)/sP; - int cL = (nvec*ldims[d])/sP; - - for(int c=0;c coor(ndim); + Lexicographic::CoorFromIndex(coor, lex_fvol, ldims); + coor[d] += m*ldims[d]; + Lexicographic::IndexFromCoor(coor, lex_r, rdims); + lex_r += lex_vec * rsites; - alldata[rsite] = tmpdata[c+chunk*m+chunk*M*s]; - - if ( 0 - &&(lcoor[0]==0) - &&(lcoor[1]==0) - &&(lcoor[2]==0) - &&(lcoor[3]==0) ) { - - std::cout << GridLogMessage << " SPLIT rcoor[d] = "< > & full,Lattice & split) ///////////////////////////////////////////////////////////////// // Start from split grid and work towards full grid ///////////////////////////////////////////////////////////////// - std::vector lcoor(ndim); - std::vector rcoor(ndim); int nvec = 1; uint64_t rsites = split_grid->lSites(); @@ -1046,77 +927,52 @@ void Grid_unsplit(std::vector > & full,Lattice & split) if ( ratio[d] != 1 ) { - { - int sP = split_grid->_processors[d]; - int fP = full_grid->_processors[d]; + auto M = ratio[d]; - int M = ratio[d]; - auto ldims = rdims; ldims[d] /= M; // Decrease local dims by same factor - auto lsites= rsites/M; // Decreases rsites by M - - int fvol = lsites; - int svol = rsites; - int chunk = (nvec*fvol)/sP; - int cL = (nvec*ldims[d])/sP; + int sP = split_grid->_processors[d]; + int fP = full_grid->_processors[d]; + + auto ldims = rdims; ldims[d] /= M; // Decrease local dims by same factor + auto lsites= rsites/M; // Decreases rsites by M + + int fvol = lsites; + int chunk = (nvec*fvol)/sP; assert(chunk*sP == nvec*fvol); + { + // Loop over reordered data post A2A for(int c=0;c= tmpdata.size() ) { - - std::cout << "c "< coor(ndim); + Lexicographic::CoorFromIndex(coor, lex_fvol, ldims); + coor[d] += m*ldims[d]; + Lexicographic::IndexFromCoor(coor, lex_r, rdims); + lex_r += lex_vec * rsites; + // LexicoFind coordinate & vector number within split lattice + tmpdata[lex_c] = alldata[lex_r]; } } } - - if ( split_grid->_processors[d] > 1 ) { - split_grid->AllToAll(d,tmpdata,alldata); - tmpdata=alldata; - } - full_grid ->AllToAll(d,tmpdata,alldata); - - rdims[d]/= M; - rsites /= M; - nvec *= M; // Increase nvec by subdivision factor } + + if ( split_grid->_processors[d] > 1 ) { + split_grid->AllToAll(d,tmpdata,alldata); + tmpdata=alldata; + } + full_grid ->AllToAll(d,tmpdata,alldata); + rdims[d]/= M; + rsites /= M; + nvec *= M; // Increase nvec by subdivision factor } } @@ -1129,7 +985,6 @@ void Grid_unsplit(std::vector > & full,Lattice & split) } vectorizeFromLexOrdArray(scalardata,full[v]); } - } } From 514993ed17671607a33d4b23873fd9f136b776e1 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Fri, 1 Dec 2017 19:38:23 +0000 Subject: [PATCH 55/86] Hadrons: progress on the interface, genetic algorithm freezing --- extras/Hadrons/Application.cc | 15 ++++-- extras/Hadrons/Environment.cc | 27 +++++++--- extras/Hadrons/Environment.hpp | 40 +++++++-------- extras/Hadrons/Module.hpp | 49 +++++++++++++++++-- extras/Hadrons/Modules.hpp | 8 +-- extras/Hadrons/Modules/MAction/DWF.hpp | 7 +-- extras/Hadrons/Modules/MAction/Wilson.hpp | 7 +-- extras/Hadrons/Modules/MContraction/Meson.hpp | 18 +++---- extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 29 ++++++----- extras/Hadrons/Modules/MGauge/Unit.cc | 4 +- extras/Hadrons/Modules/MSink/Point.hpp | 36 +++++++++----- extras/Hadrons/Modules/MSolver/RBPrecCG.hpp | 4 +- extras/Hadrons/Modules/MSource/Point.hpp | 4 +- extras/Hadrons/modules.inc | 9 ++-- 14 files changed, 164 insertions(+), 93 deletions(-) diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index a94b617c..0a7d0290 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -98,6 +98,8 @@ void Application::run(void) { parseParameterFile(parameterFileName_); } + env().checkGraph(); + env().printContent(); if (!scheduled_) { schedule(); @@ -124,8 +126,14 @@ void Application::parseParameterFile(const std::string parameterFileName) LOG(Message) << "Building application from '" << parameterFileName << "'..." << std::endl; read(reader, "parameters", par); setPar(par); - push(reader, "modules"); - push(reader, "module"); + if (!push(reader, "modules")) + { + HADRON_ERROR("Cannot open node 'modules' in parameter file '" + parameterFileName + "'"); + } + if (!push(reader, "module")) + { + HADRON_ERROR("Cannot open node 'modules/module' in parameter file '" + parameterFileName + "'"); + } do { read(reader, "id", id); @@ -186,6 +194,8 @@ void Application::schedule(void) // build module dependency graph LOG(Message) << "Building module graph..." << std::endl; auto graph = env().makeModuleGraph(); + LOG(Debug) << "Module graph:" << std::endl; + LOG(Debug) << graph << std::endl; auto con = graph.getConnectedComponents(); // constrained topological sort using a genetic algorithm @@ -329,4 +339,3 @@ void Application::memoryProfile(void) HadronsLogMessage.Active(msg); } - diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index eb0a6f70..a6855862 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -333,6 +333,17 @@ Graph Environment::makeModuleGraph(void) const return moduleGraph; } +void Environment::checkGraph(void) const +{ + for (auto &o: object_) + { + if (o.module < 0) + { + HADRON_ERROR("object '" + o.name + "' does not have a creator"); + } + } +} + #define BIG_SEP "===============" #define SEP "---------------" #define MEM_MSG(size)\ @@ -346,6 +357,7 @@ Environment::executeProgram(const std::vector &p) bool continueCollect, nothingFreed; // build garbage collection schedule + LOG(Debug) << "Building garbage collection schedule..." << std::endl; freeProg.resize(p.size()); for (unsigned int i = 0; i < object_.size(); ++i) { @@ -359,11 +371,12 @@ Environment::executeProgram(const std::vector &p) auto it = std::find_if(p.rbegin(), p.rend(), pred); if (it != p.rend()) { - freeProg[std::distance(p.rend(), it) - 1].insert(i); + freeProg[std::distance(it, p.rend()) - 1].insert(i); } } // program execution + LOG(Debug) << "Executing program..." << std::endl; for (unsigned int i = 0; i < p.size(); ++i) { // execute module @@ -712,16 +725,16 @@ void Environment::freeAll(void) void Environment::printContent(void) { - LOG(Message) << "Modules: " << std::endl; + LOG(Debug) << "Modules: " << std::endl; for (unsigned int i = 0; i < module_.size(); ++i) { - LOG(Message) << std::setw(4) << i << ": " - << getModuleName(i) << std::endl; + LOG(Debug) << std::setw(4) << i << ": " + << getModuleName(i) << std::endl; } - LOG(Message) << "Objects: " << std::endl; + LOG(Debug) << "Objects: " << std::endl; for (unsigned int i = 0; i < object_.size(); ++i) { - LOG(Message) << std::setw(4) << i << ": " - << getObjectName(i) << std::endl; + LOG(Debug) << std::setw(4) << i << ": " + << getObjectName(i) << std::endl; } } diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index b426fb27..58e035ac 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -76,6 +76,7 @@ public: typedef std::unique_ptr GridRbPt; typedef std::unique_ptr RngPt; typedef std::unique_ptr LatticePt; + enum class Storage {object, cache, temporary}; private: struct ModuleInfo { @@ -88,6 +89,7 @@ private: struct ObjInfo { Size size{0}; + Storage storage{Storage::object}; unsigned int Ls{0}; const std::type_info *type{nullptr}; std::string name; @@ -140,18 +142,17 @@ public: bool hasModule(const unsigned int address) const; bool hasModule(const std::string name) const; Graph makeModuleGraph(void) const; + void checkGraph(void) const; Size executeProgram(const std::vector &p); Size executeProgram(const std::vector &p); // general memory management void addObject(const std::string name, const int moduleAddress = -1); - template + template void createObject(const std::string name, + const Storage storage, const unsigned int Ls, - Ts ... args); - template - void createLattice(const std::string name, - const unsigned int Ls = 1); + P &&pt); template T * getObject(const unsigned int address) const; template @@ -203,6 +204,7 @@ private: // module and related maps std::vector module_; std::map moduleAddress_; + std::string currentModule_{""}; // lattice store std::map lattice_; // object store @@ -281,9 +283,11 @@ M * Environment::getModule(const std::string name) const return getModule(getModuleAddress(name)); } -template -void Environment::createObject(const std::string name, const unsigned int Ls, - Ts ... args) +template +void Environment::createObject(const std::string name, + const Environment::Storage storage, + const unsigned int Ls, + P &&pt) { if (!hasObject(name)) { @@ -296,11 +300,13 @@ void Environment::createObject(const std::string name, const unsigned int Ls, { MemoryStats memStats; - MemoryProfiler::stats = &memStats; - object_[address].Ls = Ls; - object_[address].data.reset(new Holder(new T(args...))); - object_[address].size = memStats.totalAllocated; - object_[address].type = &typeid(T); + MemoryProfiler::stats = &memStats; + object_[address].storage = storage; + object_[address].Ls = Ls; + object_[address].data.reset(new Holder(pt)); + object_[address].size = memStats.totalAllocated; + object_[address].type = &typeid(T); + MemoryProfiler::stats = nullptr; } else { @@ -308,14 +314,6 @@ void Environment::createObject(const std::string name, const unsigned int Ls, } } -template -void Environment::createLattice(const std::string name, const unsigned int Ls) -{ - GridCartesian *g = getGrid(Ls); - - createObject(name, Ls, g); -} - template T * Environment::getObject(const unsigned int address) const { diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index 5500bf36..a0b062df 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -87,13 +87,54 @@ public:\ static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance; #define ARG(...) __VA_ARGS__ +#define MACRO_REDIRECT(arg1, arg2, arg3, macro, ...) macro -#define mCreateObj(type, name, Ls, ...)\ -env().template createObject(name, Ls, __VA_ARGS__) - -#define mGetObj(type, name)\ +#define envGet(type, name)\ *env().template getObject(name) +#define envGetTmp(type, name)\ +*env().template getObject(getName() + "_tmp_" + name) + +#define envIsType(type, name)\ +env().template getObject(name) + +#define envCreate(type, name, Ls, pt)\ +env().template createObject(name, Environment::Storage::object, Ls, pt) + +#define envCreateLat4(type, name)\ +envCreate(type, name, 1, new type(env().getGrid())) + +#define envCreateLat5(type, name, Ls)\ +envCreate(type, name, Ls, new type(env().getGrid(Ls))) + +#define envCreateLat(...)\ +MACRO_REDIRECT(__VA_ARGS__, envCreateLat5, envCreateLat4)(__VA_ARGS__) + +#define envCache(type, name, Ls, pt)\ +env().template createObject(name, Environment::Storage::cache, Ls, pt) + +#define envCacheLat4(type, name)\ +envCache(type, name, 1, new type(env().getGrid())) + +#define envCacheLat5(type, name, Ls)\ +envCache(type, name, Ls, new type(env().getGrid(Ls))) + +#define envCacheLat(...)\ +MACRO_REDIRECT(__VA_ARGS__, envCacheLat5, envCacheLat4)(__VA_ARGS__) + +#define envTmp(type, name, Ls, pt)\ +env().template createObject(getName() + "_tmp_" + name, \ + Environment::Storage::temporary, Ls, pt) + +#define envTmpLat4(type, name)\ +envTmp(type, name, 1, new type(env().getGrid())) + +#define envTmpLat5(type, name, Ls)\ +envTmp(type, name, Ls, new type(env().getGrid(Ls))) + +#define envTmpLat(...)\ +MACRO_REDIRECT(__VA_ARGS__, envTmpLat5, envTmpLat4)(__VA_ARGS__) + /****************************************************************************** * Module class * ******************************************************************************/ diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 08678671..bb574a14 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -33,13 +33,13 @@ See the full license in the file "LICENSE" in the top level distribution directo // #include // #include // #include -// #include +#include // #include // #include // #include // #include // #include -// #include +#include // #include // #include // #include @@ -48,10 +48,10 @@ See the full license in the file "LICENSE" in the top level distribution directo // #include // #include // #include -// #include +#include // #include #include -// #include +#include // #include // #include // #include diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index a2ed063b..7c82fe8b 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -110,15 +110,16 @@ void TDWF::setup(void) LOG(Message) << "Fermion boundary conditions: " << par().boundary << std::endl; env().createGrid(par().Ls); - auto &U = mGetObj(LatticeGaugeField, par().gauge); + auto &U = envGet(LatticeGaugeField, par().gauge); auto &g4 = *env().getGrid(); auto &grb4 = *env().getRbGrid(); auto &g5 = *env().getGrid(par().Ls); auto &grb5 = *env().getRbGrid(par().Ls); std::vector boundary = strToVec(par().boundary); typename DomainWallFermion::ImplParams implParams(boundary); - mCreateObj(DomainWallFermion, getName(), par().Ls, - U, g5, grb5, g4, grb4, par().mass, par().M5, implParams); + envCreate(FMat, getName(), par().Ls, + new DomainWallFermion(U, g5, grb5, g4, grb4, par().mass, + par().M5, implParams)); } // execution /////////////////////////////////////////////////////////////////// diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index bc892daf..5c334f8d 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -105,13 +105,14 @@ void TWilson::setup(void) << " using gauge field '" << par().gauge << "'" << std::endl; LOG(Message) << "Fermion boundary conditions: " << par().boundary << std::endl; - auto &U = mGetObj(LatticeGaugeField, par().gauge); + auto &U = envGet(LatticeGaugeField, par().gauge); auto &grid = *env().getGrid(); auto &gridRb = *env().getRbGrid(); std::vector boundary = strToVec(par().boundary); typename WilsonFermion::ImplParams implParams(boundary); - mCreateObj(WilsonFermion, getName(), 1, U, grid, gridRb, par().mass, - implParams); + envCreate(FMat, getName(), 1, new WilsonFermion(U, grid, gridRb, + par().mass, + implParams)); } // execution /////////////////////////////////////////////////////////////////// diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index b71f7c08..ccc6dc55 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -153,7 +153,6 @@ void TMeson::parseGammaString(std::vector &gammaList) } } - // execution /////////////////////////////////////////////////////////////////// #define mesonConnected(q1, q2, gSnk, gSrc) \ (g5*(gSnk))*(q1)*(adj(gSrc)*g5)*adj(q2) @@ -180,11 +179,11 @@ void TMeson::execute(void) result[i].gamma_src = gammaList[i].second; result[i].corr.resize(nt); } - if (env().template isObjectOfType(par().q1) and - env().template isObjectOfType(par().q2)) + if (envIsType(SlicedPropagator1, par().q1) and + envIsType(SlicedPropagator2, par().q2)) { - SlicedPropagator1 &q1 = *env().template getObject(par().q1); - SlicedPropagator2 &q2 = *env().template getObject(par().q2); + SlicedPropagator1 &q1 = envGet(SlicedPropagator1, par().q1); + SlicedPropagator2 &q2 = envGet(SlicedPropagator2, par().q2); LOG(Message) << "(propagator already sinked)" << std::endl; for (unsigned int i = 0; i < result.size(); ++i) @@ -200,8 +199,8 @@ void TMeson::execute(void) } else { - PropagatorField1 &q1 = *env().template getObject(par().q1); - PropagatorField2 &q2 = *env().template getObject(par().q2); + PropagatorField1 &q1 = envGet(PropagatorField1, par().q1); + PropagatorField2 &q2 = envGet(PropagatorField2, par().q2); LatticeComplex c(env().getGrid()); LOG(Message) << "(using sink '" << par().sink << "')" << std::endl; @@ -214,15 +213,14 @@ void TMeson::execute(void) ns = env().getModuleNamespace(env().getObjectModule(par().sink)); if (ns == "MSource") { - PropagatorField1 &sink = - *env().template getObject(par().sink); + PropagatorField1 &sink = envGet(PropagatorField1, par().sink); c = trace(mesonConnected(q1, q2, gSnk, gSrc)*sink); sliceSum(c, buf, Tp); } else if (ns == "MSink") { - SinkFnScalar &sink = *env().template getObject(par().sink); + SinkFnScalar &sink = envGet(SinkFnScalar, par().sink); c = trace(mesonConnected(q1, q2, gSnk, gSrc)); buf = sink(c); diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index 8add9a00..59994d0d 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -127,10 +127,13 @@ template void TGaugeProp::setup(void) { Ls_ = env().getObjectLs(par().solver); - env().template registerLattice(getName()); + envCreateLat(PropagatorField, getName()); + envTmpLat(FermionField, "source", Ls_); + envTmpLat(FermionField, "sol", Ls_); + envTmpLat(FermionField, "tmp"); if (Ls_ > 1) { - env().template registerLattice(getName() + "_5d", Ls_); + envCreateLat(PropagatorField, getName() + "_5d", Ls_); } } @@ -139,21 +142,18 @@ template void TGaugeProp::execute(void) { LOG(Message) << "Computing quark propagator '" << getName() << "'" - << std::endl; + << std::endl; - FermionField source(env().getGrid(Ls_)), sol(env().getGrid(Ls_)), - tmp(env().getGrid()); + FermionField &source = envGetTmp(FermionField, "source"); + FermionField &sol = envGetTmp(FermionField, "sol"); + FermionField &tmp = envGetTmp(FermionField, "tmp"); std::string propName = (Ls_ == 1) ? getName() : (getName() + "_5d"); - PropagatorField &prop = *env().template createLattice(propName); - PropagatorField &fullSrc = *env().template getObject(par().source); - SolverFn &solver = *env().template getObject(par().solver); - if (Ls_ > 1) - { - env().template createLattice(getName()); - } + PropagatorField &prop = envGet(PropagatorField, propName); + PropagatorField &fullSrc = envGet(PropagatorField, par().source); + SolverFn &solver = envGet(SolverFn, par().solver); LOG(Message) << "Inverting using solver '" << par().solver - << "' on source '" << par().source << "'" << std::endl; + << "' on source '" << par().source << "'" << std::endl; for (unsigned int s = 0; s < Ns; ++s) for (unsigned int c = 0; c < Nc; ++c) { @@ -190,8 +190,7 @@ void TGaugeProp::execute(void) // create 4D propagators from 5D one if necessary if (Ls_ > 1) { - PropagatorField &p4d = - *env().template getObject(getName()); + PropagatorField &p4d = envGet(PropagatorField, getName()); make_4D(sol, tmp, Ls_); FermToProp(p4d, tmp, s, c); } diff --git a/extras/Hadrons/Modules/MGauge/Unit.cc b/extras/Hadrons/Modules/MGauge/Unit.cc index b259b7d5..b3a7d634 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.cc +++ b/extras/Hadrons/Modules/MGauge/Unit.cc @@ -57,13 +57,13 @@ std::vector TUnit::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TUnit::setup(void) { - mCreateObj(LatticeGaugeField, getName(), 1, env().getGrid()); + envCreateLat(LatticeGaugeField, getName()); } // execution /////////////////////////////////////////////////////////////////// void TUnit::execute(void) { LOG(Message) << "Creating unit gauge configuration" << std::endl; - auto &U = mGetObj(LatticeGaugeField, getName()); + auto &U = envGet(LatticeGaugeField, getName()); SU3::ColdConfiguration(*env().get4dRng(), U); } diff --git a/extras/Hadrons/Modules/MSink/Point.hpp b/extras/Hadrons/Modules/MSink/Point.hpp index 0761c4c4..b124e2e5 100644 --- a/extras/Hadrons/Modules/MSink/Point.hpp +++ b/extras/Hadrons/Modules/MSink/Point.hpp @@ -65,6 +65,9 @@ public: virtual void setup(void); // execution virtual void execute(void); +private: + bool hasPhase_{false}; + std::string momphName_; }; MODULE_REGISTER_NS(Point, TPoint, MSink); @@ -77,6 +80,7 @@ MODULE_REGISTER_NS(ScalarPoint, TPoint, MSink); template TPoint::TPoint(const std::string name) : Module(name) +, momphName_ (name + "_momph") {} // dependencies/products /////////////////////////////////////////////////////// @@ -100,30 +104,36 @@ std::vector TPoint::getOutput(void) template void TPoint::setup(void) { - unsigned int size; - - size = env().template lattice4dSize(); - env().registerObject(getName(), size); + envTmpLat(LatticeComplex, "coor"); + envCacheLat(LatticeComplex, momphName_); + envCreate(SinkFn, getName(), 1, nullptr); } // execution /////////////////////////////////////////////////////////////////// template void TPoint::execute(void) { - std::vector p = strToVec(par().mom); - LatticeComplex ph(env().getGrid()), coor(env().getGrid()); + std::vector p = strToVec(par().mom); + LatticeComplex &ph = envGet(LatticeComplex, momphName_); Complex i(0.0,1.0); LOG(Message) << "Setting up point sink function for momentum [" << par().mom << "]" << std::endl; - ph = zero; - for(unsigned int mu = 0; mu < env().getNd(); mu++) + + if (!hasPhase_) { - LatticeCoordinate(coor, mu); - ph = ph + (p[mu]/env().getGrid()->_fdimensions[mu])*coor; + LatticeComplex &coor = envGetTmp(LatticeComplex, "coor"); + + ph = zero; + for(unsigned int mu = 0; mu < env().getNd(); mu++) + { + LatticeCoordinate(coor, mu); + ph = ph + (p[mu]/env().getGrid()->_fdimensions[mu])*coor; + } + ph = exp((Real)(2*M_PI)*i*ph); + hasPhase_ = true; } - ph = exp((Real)(2*M_PI)*i*ph); - auto sink = [ph](const PropagatorField &field) + auto sink = [&ph](const PropagatorField &field) { SlicedPropagator res; PropagatorField tmp = ph*field; @@ -132,7 +142,7 @@ void TPoint::execute(void) return res; }; - env().setObject(getName(), new SinkFn(sink)); + envGet(SinkFn, getName()) = sink; } END_MODULE_NAMESPACE diff --git a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp index fe6992fc..8063d939 100644 --- a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp +++ b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp @@ -105,7 +105,7 @@ void TRBPrecCG::setup(void) << par().residual << std::endl; auto Ls = env().getObjectLs(par().action); - auto &mat = mGetObj(FMat, par().action); + auto &mat = envGet(FMat, par().action); auto solver = [&mat, this](FermionField &sol, const FermionField &source) { ConjugateGradient cg(par().residual, 10000); @@ -113,7 +113,7 @@ void TRBPrecCG::setup(void) schurSolver(mat, source, sol); }; - mCreateObj(SolverFn, getName(), Ls, solver); + envCreate(SolverFn, getName(), Ls, new SolverFn(solver)); env().addOwnership(getName(), par().action); } diff --git a/extras/Hadrons/Modules/MSource/Point.hpp b/extras/Hadrons/Modules/MSource/Point.hpp index 7815e5c1..5e16149e 100644 --- a/extras/Hadrons/Modules/MSource/Point.hpp +++ b/extras/Hadrons/Modules/MSource/Point.hpp @@ -111,7 +111,7 @@ std::vector TPoint::getOutput(void) template void TPoint::setup(void) { - env().template registerLattice(getName()); + envCreateLat(PropagatorField, getName()); } // execution /////////////////////////////////////////////////////////////////// @@ -123,7 +123,7 @@ void TPoint::execute(void) LOG(Message) << "Creating point source at position [" << par().position << "]" << std::endl; - PropagatorField &src = *env().template createLattice(getName()); + PropagatorField &src = envGet(PropagatorField, getName()); id = 1.; src = zero; pokeSite(id, src, position); diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 63745baf..5ce2435f 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -12,13 +12,16 @@ modules_cc =\ modules_hpp =\ Modules/MAction/DWF.hpp \ Modules/MAction/Wilson.hpp \ + Modules/MSink/Point.hpp \ + Modules/MSource/Point.hpp \ Modules/MGauge/Unit.hpp \ - Modules/MSolver/RBPrecCG.hpp + Modules/MSolver/RBPrecCG.hpp \ + Modules/MFermion/GaugeProp.hpp \ + Modules/MContraction/Meson.hpp # Modules/MContraction/Baryon.hpp \ # Modules/MContraction/DiscLoop.hpp \ # Modules/MContraction/Gamma3pt.hpp \ - # Modules/MContraction/Meson.hpp \ # Modules/MContraction/WardIdentity.hpp \ # Modules/MContraction/WeakHamiltonian.hpp \ # Modules/MContraction/WeakHamiltonianEye.hpp \ @@ -32,10 +35,8 @@ modules_hpp =\ # Modules/MScalar/ChargedProp.hpp \ # Modules/MScalar/FreeProp.hpp \ # Modules/MScalar/Scalar.hpp \ - # Modules/MSink/Point.hpp \ # Modules/MSink/Smear.hpp \ # Modules/MSolver/RBPrecCG.hpp \ - # Modules/MSource/Point.hpp \ # Modules/MSource/SeqConserved.hpp \ # Modules/MSource/SeqGamma.hpp \ # Modules/MSource/Wall.hpp \ From 2427a21428b6704a08119a24c60f0e77830c55c7 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Fri, 1 Dec 2017 19:44:07 +0000 Subject: [PATCH 56/86] minor serial IO fixes, XML now issues warning when trying to read absent nodes, these becomes --- lib/serialisation/JSON_IO.cc | 2 +- lib/serialisation/MacroMagic.h | 6 ++++- lib/serialisation/XmlIO.cc | 41 ++++++++++++++++++++++------------ lib/serialisation/XmlIO.h | 10 +++++++-- 4 files changed, 41 insertions(+), 18 deletions(-) diff --git a/lib/serialisation/JSON_IO.cc b/lib/serialisation/JSON_IO.cc index 99a9cdd6..6a01aa84 100644 --- a/lib/serialisation/JSON_IO.cc +++ b/lib/serialisation/JSON_IO.cc @@ -25,7 +25,7 @@ See the full license in the file "LICENSE" in the top level distribution directory *************************************************************************************/ /* END LEGAL */ -#include +#include using namespace Grid; using namespace std; diff --git a/lib/serialisation/MacroMagic.h b/lib/serialisation/MacroMagic.h index 774c947f..5df2c780 100644 --- a/lib/serialisation/MacroMagic.h +++ b/lib/serialisation/MacroMagic.h @@ -125,7 +125,11 @@ static inline void write(Writer &WR,const std::string &s, const cname &obj){ }\ template \ static inline void read(Reader &RD,const std::string &s, cname &obj){ \ - push(RD,s);\ + if (!push(RD,s))\ + {\ + std::cout << Grid::GridLogWarning << "IO: Cannot open node '" << s << "'" << std::endl;\ + return;\ + };\ GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_READ_MEMBER,__VA_ARGS__)) \ pop(RD);\ }\ diff --git a/lib/serialisation/XmlIO.cc b/lib/serialisation/XmlIO.cc index 260611a5..8ac7422c 100644 --- a/lib/serialisation/XmlIO.cc +++ b/lib/serialisation/XmlIO.cc @@ -100,13 +100,16 @@ XmlReader::XmlReader(const string &fileName,string toplev) : fileName_(fileName) bool XmlReader::push(const string &s) { + if (node_.child(s.c_str())) + { + node_ = node_.child(s.c_str()); - if (node_.child(s.c_str()) == NULL ) + return true; + } + else + { return false; - - node_ = node_.child(s.c_str()); - return true; - + } } void XmlReader::pop(void) @@ -117,20 +120,30 @@ void XmlReader::pop(void) bool XmlReader::nextElement(const std::string &s) { if (node_.next_sibling(s.c_str())) - { - node_ = node_.next_sibling(s.c_str()); - - return true; - } + { + node_ = node_.next_sibling(s.c_str()); + + return true; + } else - { - return false; - } + { + return false; + } } template <> void XmlReader::readDefault(const string &s, string &output) { - output = node_.child(s.c_str()).first_child().value(); + if (node_.child(s.c_str())) + { + output = node_.child(s.c_str()).first_child().value(); + } + else + { + std::cout << GridLogWarning << "XML: cannot open node '" << s << "'"; + std::cout << std::endl; + + output = ""; + } } diff --git a/lib/serialisation/XmlIO.h b/lib/serialisation/XmlIO.h index fcdbf1e4..e37eb8d9 100644 --- a/lib/serialisation/XmlIO.h +++ b/lib/serialisation/XmlIO.h @@ -39,6 +39,7 @@ Author: paboyle #include #include +#include namespace Grid { @@ -119,7 +120,6 @@ namespace Grid std::string buf; readDefault(s, buf); - // std::cout << s << " " << buf << std::endl; fromString(output, buf); } @@ -132,7 +132,13 @@ namespace Grid std::string buf; unsigned int i = 0; - push(s); + if (!push(s)) + { + std::cout << GridLogWarning << "XML: cannot open node '" << s << "'"; + std::cout << std::endl; + + return; + } while (node_.child("elem")) { output.resize(i + 1); From 2a9ebddad59116151e6db2a0bc8cdbf53dd5741c Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Sun, 3 Dec 2017 19:45:15 +0100 Subject: [PATCH 57/86] Hadrons: scheduler offline, minimal code working again --- extras/Hadrons/Application.cc | 93 ++++++++++--------- extras/Hadrons/Module.hpp | 4 +- extras/Hadrons/Modules/MContraction/Meson.hpp | 4 +- 3 files changed, 51 insertions(+), 50 deletions(-) diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index 0a7d0290..0860437b 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -182,7 +182,7 @@ GeneticScheduler::ObjFunc memPeak = \ memPeak = env().executeProgram(program);\ env().dryRun(false);\ env().freeAll();\ - HadronsLogMessage.Active(true);\ + HadronsLogMessage.Active(msg);\ \ return memPeak;\ } @@ -199,58 +199,59 @@ void Application::schedule(void) auto con = graph.getConnectedComponents(); // constrained topological sort using a genetic algorithm - LOG(Message) << "Scheduling computation..." << std::endl; - LOG(Message) << " #module= " << graph.size() << std::endl; - LOG(Message) << " population size= " << par_.genetic.popSize << std::endl; - LOG(Message) << " max. generation= " << par_.genetic.maxGen << std::endl; - LOG(Message) << " max. cst. generation= " << par_.genetic.maxCstGen << std::endl; - LOG(Message) << " mutation rate= " << par_.genetic.mutationRate << std::endl; + // LOG(Message) << "Scheduling computation..." << std::endl; + // LOG(Message) << " #module= " << graph.size() << std::endl; + // LOG(Message) << " population size= " << par_.genetic.popSize << std::endl; + // LOG(Message) << " max. generation= " << par_.genetic.maxGen << std::endl; + // LOG(Message) << " max. cst. generation= " << par_.genetic.maxCstGen << std::endl; + // LOG(Message) << " mutation rate= " << par_.genetic.mutationRate << std::endl; - unsigned int k = 0, gen, prevPeak, nCstPeak = 0; - std::random_device rd; - GeneticScheduler::Parameters par; + // unsigned int k = 0, gen, prevPeak, nCstPeak = 0; + // std::random_device rd; + // GeneticScheduler::Parameters par; - par.popSize = par_.genetic.popSize; - par.mutationRate = par_.genetic.mutationRate; - par.seed = rd(); - memPeak_ = 0; - CartesianCommunicator::BroadcastWorld(0, &(par.seed), sizeof(par.seed)); + // par.popSize = par_.genetic.popSize; + // par.mutationRate = par_.genetic.mutationRate; + // par.seed = rd(); + // memPeak_ = 0; + // CartesianCommunicator::BroadcastWorld(0, &(par.seed), sizeof(par.seed)); for (unsigned int i = 0; i < con.size(); ++i) { - GeneticScheduler scheduler(con[i], memPeak, par); + // GeneticScheduler scheduler(con[i], memPeak, par); - gen = 0; - do - { - LOG(Debug) << "Generation " << gen << ":" << std::endl; - scheduler.nextGeneration(); - if (gen != 0) - { - if (prevPeak == scheduler.getMinValue()) - { - nCstPeak++; - } - else - { - nCstPeak = 0; - } - } + // gen = 0; + // do + // { + // LOG(Debug) << "Generation " << gen << ":" << std::endl; + // scheduler.nextGeneration(); + // if (gen != 0) + // { + // if (prevPeak == scheduler.getMinValue()) + // { + // nCstPeak++; + // } + // else + // { + // nCstPeak = 0; + // } + // } - prevPeak = scheduler.getMinValue(); - if (gen % 10 == 0) - { - LOG(Iterative) << "Generation " << gen << ": " - << MEM_MSG(scheduler.getMinValue()) << std::endl; - } + // prevPeak = scheduler.getMinValue(); + // if (gen % 10 == 0) + // { + // LOG(Iterative) << "Generation " << gen << ": " + // << MEM_MSG(scheduler.getMinValue()) << std::endl; + // } - gen++; - } while ((gen < par_.genetic.maxGen) - and (nCstPeak < par_.genetic.maxCstGen)); - auto &t = scheduler.getMinSchedule(); - if (scheduler.getMinValue() > memPeak_) - { - memPeak_ = scheduler.getMinValue(); - } + // gen++; + // } while ((gen < par_.genetic.maxGen) + // and (nCstPeak < par_.genetic.maxCstGen)); + // auto &t = scheduler.getMinSchedule(); + // if (scheduler.getMinValue() > memPeak_) + // { + // memPeak_ = scheduler.getMinValue(); + // } + auto t = con[i].topoSort(); for (unsigned int j = 0; j < t.size(); ++j) { program_.push_back(t[j]); diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index a0b062df..a9525029 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -95,8 +95,8 @@ static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance; #define envGetTmp(type, name)\ *env().template getObject(getName() + "_tmp_" + name) -#define envIsType(type, name)\ -env().template getObject(name) +#define envHasType(type, name)\ +env().template isObjectOfType(name) #define envCreate(type, name, Ls, pt)\ env().template createObject(name, Environment::Storage::object, Ls, pt) diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index ccc6dc55..34127da3 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -179,8 +179,8 @@ void TMeson::execute(void) result[i].gamma_src = gammaList[i].second; result[i].corr.resize(nt); } - if (envIsType(SlicedPropagator1, par().q1) and - envIsType(SlicedPropagator2, par().q2)) + if (envHasType(SlicedPropagator1, par().q1) and + envHasType(SlicedPropagator2, par().q2)) { SlicedPropagator1 &q1 = envGet(SlicedPropagator1, par().q1); SlicedPropagator2 &q2 = envGet(SlicedPropagator2, par().q2); From 624246409cc769715c74665d876a4cb4038a9693 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Sun, 3 Dec 2017 19:46:18 +0100 Subject: [PATCH 58/86] Hadrons: module setup/execute protected to forbid user to bypass execution control --- extras/Hadrons/Module.hpp | 5 +++-- extras/Hadrons/Modules/MAction/DWF.hpp | 1 + extras/Hadrons/Modules/MAction/Wilson.hpp | 1 + extras/Hadrons/Modules/MContraction/Baryon.hpp | 1 + extras/Hadrons/Modules/MContraction/DiscLoop.hpp | 1 + extras/Hadrons/Modules/MContraction/Gamma3pt.hpp | 1 + extras/Hadrons/Modules/MContraction/Meson.hpp | 1 + extras/Hadrons/Modules/MContraction/WardIdentity.hpp | 1 + extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp | 4 +++- extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 1 + extras/Hadrons/Modules/MGauge/Load.hpp | 1 + extras/Hadrons/Modules/MGauge/Random.hpp | 1 + extras/Hadrons/Modules/MGauge/StochEm.hpp | 1 + extras/Hadrons/Modules/MGauge/Unit.hpp | 1 + extras/Hadrons/Modules/MLoop/NoiseLoop.hpp | 1 + extras/Hadrons/Modules/MScalar/ChargedProp.hpp | 1 + extras/Hadrons/Modules/MScalar/FreeProp.hpp | 1 + extras/Hadrons/Modules/MSink/Point.hpp | 1 + extras/Hadrons/Modules/MSink/Smear.hpp | 1 + extras/Hadrons/Modules/MSolver/RBPrecCG.hpp | 1 + extras/Hadrons/Modules/MSource/Point.hpp | 1 + extras/Hadrons/Modules/MSource/SeqConserved.hpp | 1 + extras/Hadrons/Modules/MSource/SeqGamma.hpp | 1 + extras/Hadrons/Modules/MSource/Wall.hpp | 1 + extras/Hadrons/Modules/MSource/Z2.hpp | 1 + extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp | 1 + extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp | 1 + 27 files changed, 31 insertions(+), 3 deletions(-) diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index a9525029..017a9172 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -157,10 +157,11 @@ public: // parse parameters virtual void parseParameters(XmlReader &reader, const std::string name) = 0; virtual void saveParameters(XmlWriter &writer, const std::string name) = 0; - // setup - virtual void setup(void) {}; // execution void operator()(void); +protected: + // setup + virtual void setup(void) {}; virtual void execute(void) = 0; private: std::string name_; diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index 7c82fe8b..36c70073 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -65,6 +65,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index 5c334f8d..7fe1f44e 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -63,6 +63,7 @@ public: // dependencies/products virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MContraction/Baryon.hpp b/extras/Hadrons/Modules/MContraction/Baryon.hpp index 78bde5a2..da927391 100644 --- a/extras/Hadrons/Modules/MContraction/Baryon.hpp +++ b/extras/Hadrons/Modules/MContraction/Baryon.hpp @@ -72,6 +72,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // execution virtual void execute(void); }; diff --git a/extras/Hadrons/Modules/MContraction/DiscLoop.hpp b/extras/Hadrons/Modules/MContraction/DiscLoop.hpp index 4f782cd3..f8da3943 100644 --- a/extras/Hadrons/Modules/MContraction/DiscLoop.hpp +++ b/extras/Hadrons/Modules/MContraction/DiscLoop.hpp @@ -68,6 +68,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp index 162ab786..a8653186 100644 --- a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp +++ b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp @@ -99,6 +99,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 34127da3..31640b7c 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -97,6 +97,7 @@ public: virtual std::vector getInput(void); virtual std::vector getOutput(void); virtual void parseGammaString(std::vector &gammaList); +protected: // execution virtual void execute(void); }; diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 8a56e0eb..a298c1a1 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -74,6 +74,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp index 302b207e..7df40370 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp @@ -100,11 +100,13 @@ public:\ /* dependency relation */ \ virtual std::vector getInput(void);\ virtual std::vector getOutput(void);\ +public:\ + std::vector VA_label = {"V", "A"};\ +protected:\ /* setup */ \ virtual void setup(void);\ /* execution */ \ virtual void execute(void);\ - std::vector VA_label = {"V", "A"};\ };\ MODULE_REGISTER_NS(modname, T##modname, MContraction); diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index 59994d0d..8529825b 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -85,6 +85,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MGauge/Load.hpp b/extras/Hadrons/Modules/MGauge/Load.hpp index 5ff6da0f..a338af79 100644 --- a/extras/Hadrons/Modules/MGauge/Load.hpp +++ b/extras/Hadrons/Modules/MGauge/Load.hpp @@ -58,6 +58,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MGauge/Random.hpp b/extras/Hadrons/Modules/MGauge/Random.hpp index a97d25cf..a07130e4 100644 --- a/extras/Hadrons/Modules/MGauge/Random.hpp +++ b/extras/Hadrons/Modules/MGauge/Random.hpp @@ -51,6 +51,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index 12ce9fdc..bacb5172 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -60,6 +60,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MGauge/Unit.hpp b/extras/Hadrons/Modules/MGauge/Unit.hpp index 7cd15ef7..c1650cc7 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.hpp +++ b/extras/Hadrons/Modules/MGauge/Unit.hpp @@ -51,6 +51,7 @@ public: // dependencies/products virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp b/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp index 5d2c4a13..1f40dd48 100644 --- a/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp +++ b/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp @@ -74,6 +74,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index fbe75c05..ab6a0184 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -37,6 +37,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MScalar/FreeProp.hpp b/extras/Hadrons/Modules/MScalar/FreeProp.hpp index 97cf288a..38372a0c 100644 --- a/extras/Hadrons/Modules/MScalar/FreeProp.hpp +++ b/extras/Hadrons/Modules/MScalar/FreeProp.hpp @@ -33,6 +33,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSink/Point.hpp b/extras/Hadrons/Modules/MSink/Point.hpp index b124e2e5..853a7c32 100644 --- a/extras/Hadrons/Modules/MSink/Point.hpp +++ b/extras/Hadrons/Modules/MSink/Point.hpp @@ -61,6 +61,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSink/Smear.hpp b/extras/Hadrons/Modules/MSink/Smear.hpp index c3973d2b..b51d2f49 100644 --- a/extras/Hadrons/Modules/MSink/Smear.hpp +++ b/extras/Hadrons/Modules/MSink/Smear.hpp @@ -62,6 +62,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp index 8063d939..d8a4b95f 100644 --- a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp +++ b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp @@ -62,6 +62,7 @@ public: // dependencies/products virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSource/Point.hpp b/extras/Hadrons/Modules/MSource/Point.hpp index 5e16149e..b9813688 100644 --- a/extras/Hadrons/Modules/MSource/Point.hpp +++ b/extras/Hadrons/Modules/MSource/Point.hpp @@ -72,6 +72,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index 86a7dfb9..e8f91be1 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -83,6 +83,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSource/SeqGamma.hpp b/extras/Hadrons/Modules/MSource/SeqGamma.hpp index e2129a46..8f67f8fa 100644 --- a/extras/Hadrons/Modules/MSource/SeqGamma.hpp +++ b/extras/Hadrons/Modules/MSource/SeqGamma.hpp @@ -81,6 +81,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSource/Wall.hpp b/extras/Hadrons/Modules/MSource/Wall.hpp index 4de37e4d..57dee06d 100644 --- a/extras/Hadrons/Modules/MSource/Wall.hpp +++ b/extras/Hadrons/Modules/MSource/Wall.hpp @@ -73,6 +73,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MSource/Z2.hpp b/extras/Hadrons/Modules/MSource/Z2.hpp index a7f7a3e6..e2cc4f34 100644 --- a/extras/Hadrons/Modules/MSource/Z2.hpp +++ b/extras/Hadrons/Modules/MSource/Z2.hpp @@ -76,6 +76,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index b085eb8c..f8714d88 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -80,6 +80,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp index 2799e5d0..9736ab54 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -64,6 +64,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution From 59aae5f5ec97133f4f9ba80f3d2f718284d9e7f7 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Sun, 3 Dec 2017 19:47:11 +0100 Subject: [PATCH 59/86] Hadrons: garbage collector clean temporaries --- extras/Hadrons/Environment.cc | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index a6855862..27849bd7 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -422,6 +422,15 @@ Environment::executeProgram(const std::vector &p) } } } while (continueCollect); + // free temporaries + for (unsigned int i = 0; i < object_.size(); ++i) + { + if ((object_[i].storage == Storage::temporary) + and hasCreatedObject(i)) + { + freeObject(i); + } + } // any remaining objects in step i garbage collection schedule // is scheduled for step i + 1 if (i + 1 < p.size()) @@ -687,7 +696,7 @@ bool Environment::freeObject(const unsigned int address) { if (!hasOwners(address)) { - if (!isDryRun()) + if (!isDryRun() and hasCreatedObject(address)) { LOG(Message) << "Destroying object '" << object_[address].name << "'" << std::endl; From 01f00385a4460ea21e09c2beaa77bd20c7a78550 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Sun, 3 Dec 2017 19:47:40 +0100 Subject: [PATCH 60/86] Hadrons: genetic pair selection based on exponential probability --- extras/Hadrons/GeneticScheduler.hpp | 33 ++++++++++++----------------- 1 file changed, 14 insertions(+), 19 deletions(-) diff --git a/extras/Hadrons/GeneticScheduler.hpp b/extras/Hadrons/GeneticScheduler.hpp index d0c52596..3b0195e7 100644 --- a/extras/Hadrons/GeneticScheduler.hpp +++ b/extras/Hadrons/GeneticScheduler.hpp @@ -212,28 +212,23 @@ typename GeneticScheduler::GenePair GeneticScheduler::selectPair(void) std::vector prob; unsigned int ind; Gene *p1, *p2; + const double max = population_.rbegin()->first; + for (auto &c: population_) { - prob.push_back(1./c.first); - } - do - { - double probCpy; - - std::discrete_distribution dis1(prob.begin(), prob.end()); - auto rIt = population_.begin(); - ind = dis1(gen_); - std::advance(rIt, ind); - p1 = &(rIt->second); - probCpy = prob[ind]; - prob[ind] = 0.; - std::discrete_distribution dis2(prob.begin(), prob.end()); - rIt = population_.begin(); - std::advance(rIt, dis2(gen_)); - p2 = &(rIt->second); - prob[ind] = probCpy; - } while (p1 == p2); + prob.push_back(std::exp((c.first-1.)/max)); + } + std::discrete_distribution dis1(prob.begin(), prob.end()); + auto rIt = population_.begin(); + ind = dis1(gen_); + std::advance(rIt, ind); + p1 = &(rIt->second); + prob[ind] = 0.; + std::discrete_distribution dis2(prob.begin(), prob.end()); + rIt = population_.begin(); + std::advance(rIt, dis2(gen_)); + p2 = &(rIt->second); return std::make_pair(p1, p2); } From 3127b52c907d6055d5d8e044a1e3764cea8c9f6f Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Sun, 3 Dec 2017 19:48:34 +0100 Subject: [PATCH 61/86] bootstrap script does not destroy Eigen is working offline --- bootstrap.sh | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/bootstrap.sh b/bootstrap.sh index dfb6735d..bdf748df 100755 --- a/bootstrap.sh +++ b/bootstrap.sh @@ -3,9 +3,7 @@ EIGEN_URL='http://bitbucket.org/eigen/eigen/get/3.3.3.tar.bz2' echo "-- deploying Eigen source..." -wget ${EIGEN_URL} --no-check-certificate -./scripts/update_eigen.sh `basename ${EIGEN_URL}` -rm `basename ${EIGEN_URL}` +wget ${EIGEN_URL} --no-check-certificate && ./scripts/update_eigen.sh `basename ${EIGEN_URL}` && rm `basename ${EIGEN_URL}` echo '-- generating Make.inc files...' ./scripts/filelist From ae3b7713a9b2d7c095e9e1dd8de396f506580a3f Mon Sep 17 00:00:00 2001 From: paboyle Date: Tue, 5 Dec 2017 11:36:31 +0000 Subject: [PATCH 62/86] Cold start doesnt need RNG --- lib/qcd/utils/SUn.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/lib/qcd/utils/SUn.h b/lib/qcd/utils/SUn.h index 8f0c0a7b..cdc6c961 100644 --- a/lib/qcd/utils/SUn.h +++ b/lib/qcd/utils/SUn.h @@ -746,7 +746,7 @@ template } } template - static void ColdConfiguration(GridParallelRNG &pRNG,GaugeField &out){ + static void ColdConfiguration(GaugeField &out){ typedef typename GaugeField::vector_type vector_type; typedef iSUnMatrix vMatrixType; typedef Lattice LatticeMatrixType; @@ -757,6 +757,10 @@ template PokeIndex(out,Umu,mu); } } + template + static void ColdConfiguration(GridParallelRNG &pRNG,GaugeField &out){ + ColdConfiguration(out); + } template static void taProj( const LatticeMatrixType &in, LatticeMatrixType &out){ From d93c6760ec850abb93ee3f94a3444ee0dba84c6f Mon Sep 17 00:00:00 2001 From: paboyle Date: Tue, 5 Dec 2017 11:39:26 +0000 Subject: [PATCH 63/86] Faster code for split unsplit --- lib/lattice/Lattice_transfer.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/lib/lattice/Lattice_transfer.h b/lib/lattice/Lattice_transfer.h index c7e2a507..32c15d22 100644 --- a/lib/lattice/Lattice_transfer.h +++ b/lib/lattice/Lattice_transfer.h @@ -822,6 +822,7 @@ void Grid_split(std::vector > & full,Lattice & split) // Loop over reordered data post A2A parallel_for(int c=0;c coor(ndim); for(int m=0;m > & full,Lattice & split) uint64_t lex_vec = lex_fvol_vec/fvol; // which node sets an adder to the coordinate - std::vector coor(ndim); Lexicographic::CoorFromIndex(coor, lex_fvol, ldims); coor[d] += m*ldims[d]; Lexicographic::IndexFromCoor(coor, lex_r, rdims); @@ -940,10 +940,11 @@ void Grid_unsplit(std::vector > & full,Lattice & split) { // Loop over reordered data post A2A - for(int c=0;c coor(ndim); for(int m=0;m > & full,Lattice & split) uint64_t lex_vec = lex_fvol_vec/fvol; // which node sets an adder to the coordinate - std::vector coor(ndim); Lexicographic::CoorFromIndex(coor, lex_fvol, ldims); coor[d] += m*ldims[d]; Lexicographic::IndexFromCoor(coor, lex_r, rdims); @@ -978,9 +978,9 @@ void Grid_unsplit(std::vector > & full,Lattice & split) lsites = full_grid->lSites(); for(int v=0;v Date: Tue, 5 Dec 2017 11:42:05 +0000 Subject: [PATCH 64/86] Faster RNG init --- lib/lattice/Lattice_rng.h | 35 +++++------------------------------ 1 file changed, 5 insertions(+), 30 deletions(-) diff --git a/lib/lattice/Lattice_rng.h b/lib/lattice/Lattice_rng.h index 6dc50fd2..11d8e325 100644 --- a/lib/lattice/Lattice_rng.h +++ b/lib/lattice/Lattice_rng.h @@ -77,9 +77,6 @@ namespace Grid { // merge of April 11 2017 -//<<<<<<< HEAD - - // this function is necessary for the LS vectorised field inline int RNGfillable_general(GridBase *coarse,GridBase *fine) { @@ -91,7 +88,6 @@ namespace Grid { // all further divisions are local for(int d=0;d_processors[d]==1); for(int d=0;d_processors[d] == fine->_processors[d+lowerdims]); - // then divide the number of local sites // check that the total number of sims agree, meanse the iSites are the same @@ -102,27 +98,6 @@ namespace Grid { return fine->lSites() / coarse->lSites(); } - - /* - // Wrap seed_seq to give common interface with random_device - class fixedSeed { - public: - typedef std::seed_seq::result_type result_type; - std::seed_seq src; - - fixedSeed(const std::vector &seeds) : src(seeds.begin(),seeds.end()) {}; - - result_type operator () (void){ - std::vector list(1); - src.generate(list.begin(),list.end()); - return list[0]; - } - - }; - -======= ->>>>>>> develop - */ // real scalars are one component template @@ -171,7 +146,7 @@ namespace Grid { // support for parallel init /////////////////////// #ifdef RNG_FAST_DISCARD - static void Skip(RngEngine &eng) + static void Skip(RngEngine &eng,uint64_t site) { ///////////////////////////////////////////////////////////////////////////////////// // Skip by 2^40 elements between successive lattice sites @@ -184,7 +159,8 @@ namespace Grid { // and margin of safety is orders of magnitude. // We could hack Sitmo to skip in the higher order words of state if necessary ///////////////////////////////////////////////////////////////////////////////////// - uint64_t skip = 0x1; skip = skip<<40; + uint64_t skip = site; + skip = skip<<40; eng.discard(skip); } #endif @@ -411,9 +387,7 @@ namespace Grid { int rank,o_idx,i_idx; // Everybody loops over global volume. - for(int gidx=0;gidx<_grid->_gsites;gidx++){ - - Skip(master_engine); // Skip to next RNG sequence + parallel_for(int gidx=0;gidx<_grid->_gsites;gidx++){ // Where is it? _grid->GlobalIndexToGlobalCoor(gidx,gcoor); @@ -423,6 +397,7 @@ namespace Grid { if( rank == _grid->ThisRank() ){ int l_idx=generator_idx(o_idx,i_idx); _generators[l_idx] = master_engine; + Skip(_generators[l_idx],gidx); // Skip to next RNG sequence } } From a14038051fbeed58692fe1342f746c045e093585 Mon Sep 17 00:00:00 2001 From: paboyle Date: Tue, 5 Dec 2017 11:43:25 +0000 Subject: [PATCH 65/86] Improved AllToAll asserts --- lib/communicator/Communicator_base.h | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/lib/communicator/Communicator_base.h b/lib/communicator/Communicator_base.h index 73ea6165..548515cd 100644 --- a/lib/communicator/Communicator_base.h +++ b/lib/communicator/Communicator_base.h @@ -276,10 +276,11 @@ class CartesianCommunicator { assert(in.size()==out.size()); uint64_t bytes=sizeof(T); uint64_t words=in.size()/numnode; - + // std:: cout << "AllToAll buffer size "<< in.size()*sizeof(T)< Date: Tue, 5 Dec 2017 13:01:10 +0000 Subject: [PATCH 66/86] Improved parallel RNG init --- lib/lattice/Lattice_rng.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/lattice/Lattice_rng.h b/lib/lattice/Lattice_rng.h index 11d8e325..d5190e63 100644 --- a/lib/lattice/Lattice_rng.h +++ b/lib/lattice/Lattice_rng.h @@ -159,9 +159,11 @@ namespace Grid { // and margin of safety is orders of magnitude. // We could hack Sitmo to skip in the higher order words of state if necessary ///////////////////////////////////////////////////////////////////////////////////// + // uint64_t skip = site+1; // Old init Skipped then drew. Checked compat with faster init uint64_t skip = site; skip = skip<<40; eng.discard(skip); + // std::cout << " Engine " < Date: Tue, 5 Dec 2017 13:07:31 +0000 Subject: [PATCH 67/86] Clean up of test --- tests/solver/Test_dwf_mrhs_cg_mpi.cc | 34 ++++++++++++++++------------ 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/tests/solver/Test_dwf_mrhs_cg_mpi.cc b/tests/solver/Test_dwf_mrhs_cg_mpi.cc index 06df58c6..7e11d8d1 100644 --- a/tests/solver/Test_dwf_mrhs_cg_mpi.cc +++ b/tests/solver/Test_dwf_mrhs_cg_mpi.cc @@ -81,21 +81,20 @@ int main (int argc, char ** argv) GridCartesian * SFGrid = SpaceTimeGrid::makeFiveDimGrid(Ls,SGrid); GridRedBlackCartesian * SrbGrid = SpaceTimeGrid::makeFourDimRedBlackGrid(SGrid); GridRedBlackCartesian * SFrbGrid = SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls,SGrid); - + std::cout << GridLogMessage << "Made the grids"< seeds({1,2,3,4}); - GridParallelRNG pRNG(UGrid ); pRNG.SeedFixedIntegers(seeds); - GridParallelRNG pRNG5(FGrid); pRNG5.SeedFixedIntegers(seeds); std::vector src(nrhs,FGrid); std::vector src_chk(nrhs,FGrid); std::vector result(nrhs,FGrid); FermionField tmp(FGrid); + std::cout << GridLogMessage << "Made the Fermion Fields"< Date: Tue, 5 Dec 2017 14:12:22 +0000 Subject: [PATCH 68/86] Threading improvement --- lib/lattice/Lattice_rng.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/lattice/Lattice_rng.h b/lib/lattice/Lattice_rng.h index d5190e63..edf9dd23 100644 --- a/lib/lattice/Lattice_rng.h +++ b/lib/lattice/Lattice_rng.h @@ -385,13 +385,14 @@ namespace Grid { // MT implementation does not implement fast discard even though // in principle this is possible //////////////////////////////////////////////// - std::vector gcoor; - int rank,o_idx,i_idx; // Everybody loops over global volume. parallel_for(int gidx=0;gidx<_grid->_gsites;gidx++){ // Where is it? + int rank,o_idx,i_idx; + std::vector gcoor; + _grid->GlobalIndexToGlobalCoor(gidx,gcoor); _grid->GlobalCoorToRankIndex(rank,o_idx,i_idx,gcoor); From 542225195903b5a54bd2b2768c8153b29fba5230 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Tue, 5 Dec 2017 15:31:59 +0100 Subject: [PATCH 69/86] Hadrons: execution part moved in a new virtual machine class --- extras/Hadrons/Application.cc | 41 +- extras/Hadrons/Application.hpp | 11 +- extras/Hadrons/Environment.cc | 387 ++--------------- extras/Hadrons/Environment.hpp | 124 +----- extras/Hadrons/Global.hpp | 4 + extras/Hadrons/Makefile.am | 6 +- extras/Hadrons/Module.cc | 8 +- extras/Hadrons/Module.hpp | 8 +- extras/Hadrons/Modules/MContraction/Meson.hpp | 2 +- extras/Hadrons/VirtualMachine.cc | 388 ++++++++++++++++++ extras/Hadrons/VirtualMachine.hpp | 164 ++++++++ 11 files changed, 647 insertions(+), 496 deletions(-) create mode 100644 extras/Hadrons/VirtualMachine.cc create mode 100644 extras/Hadrons/VirtualMachine.hpp diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index 0860437b..af67dff3 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -73,12 +73,6 @@ Application::Application(const std::string parameterFileName) parameterFileName_ = parameterFileName; } -// environment shortcut //////////////////////////////////////////////////////// -Environment & Application::env(void) const -{ - return Environment::getInstance(); -} - // access ////////////////////////////////////////////////////////////////////// void Application::setPar(const Application::GlobalPar &par) { @@ -94,12 +88,13 @@ const Application::GlobalPar & Application::getPar(void) // execute ///////////////////////////////////////////////////////////////////// void Application::run(void) { - if (!parameterFileName_.empty() and (env().getNModule() == 0)) + if (!parameterFileName_.empty() and (vm().getNModule() == 0)) { parseParameterFile(parameterFileName_); } - env().checkGraph(); + //vm().checkGraph(); env().printContent(); + vm().printContent(); if (!scheduled_) { schedule(); @@ -137,7 +132,7 @@ void Application::parseParameterFile(const std::string parameterFileName) do { read(reader, "id", id); - env().createModule(id.name, id.type, reader); + vm().createModule(id.name, id.type, reader); } while (reader.nextElement("module")); pop(reader); pop(reader); @@ -147,7 +142,7 @@ void Application::saveParameterFile(const std::string parameterFileName) { XmlWriter writer(parameterFileName); ObjectId id; - const unsigned int nMod = env().getNModule(); + const unsigned int nMod = vm().getNModule(); LOG(Message) << "Saving application to '" << parameterFileName << "'..." << std::endl; write(writer, "parameters", getPar()); @@ -155,10 +150,10 @@ void Application::saveParameterFile(const std::string parameterFileName) for (unsigned int i = 0; i < nMod; ++i) { push(writer, "module"); - id.name = env().getModuleName(i); - id.type = env().getModule(i)->getRegisteredName(); + id.name = vm().getModuleName(i); + id.type = vm().getModule(i)->getRegisteredName(); write(writer, "id", id); - env().getModule(i)->saveParameters(writer, "options"); + vm().getModule(i)->saveParameters(writer, "options"); pop(writer); } pop(writer); @@ -178,9 +173,9 @@ GeneticScheduler::ObjFunc memPeak = \ \ msg = HadronsLogMessage.isActive();\ HadronsLogMessage.Active(false);\ - env().dryRun(true);\ - memPeak = env().executeProgram(program);\ - env().dryRun(false);\ + vm().dryRun(true);\ + memPeak = vm().executeProgram(program);\ + vm().dryRun(false);\ env().freeAll();\ HadronsLogMessage.Active(msg);\ \ @@ -193,7 +188,7 @@ void Application::schedule(void) // build module dependency graph LOG(Message) << "Building module graph..." << std::endl; - auto graph = env().makeModuleGraph(); + auto graph = vm().makeModuleGraph(); LOG(Debug) << "Module graph:" << std::endl; LOG(Debug) << graph << std::endl; auto con = graph.getConnectedComponents(); @@ -273,7 +268,7 @@ void Application::saveSchedule(const std::string filename) << std::endl; for (auto address: program_) { - program.push_back(env().getModuleName(address)); + program.push_back(vm().getModuleName(address)); } write(writer, "schedule", program); } @@ -291,7 +286,7 @@ void Application::loadSchedule(const std::string filename) program_.clear(); for (auto &name: program) { - program_.push_back(env().getModuleAddress(name)); + program_.push_back(vm().getModuleAddress(name)); } scheduled_ = true; memPeak_ = memPeak(program_); @@ -308,7 +303,7 @@ void Application::printSchedule(void) for (unsigned int i = 0; i < program_.size(); ++i) { LOG(Message) << std::setw(4) << i + 1 << ": " - << env().getModuleName(program_[i]) << std::endl; + << vm().getModuleName(program_[i]) << std::endl; } } @@ -321,8 +316,8 @@ void Application::configLoop(void) { LOG(Message) << BIG_SEP << " Starting measurement for trajectory " << t << " " << BIG_SEP << std::endl; - env().setTrajectory(t); - env().executeProgram(program_); + vm().setTrajectory(t); + vm().executeProgram(program_); } LOG(Message) << BIG_SEP << " End of measurement " << BIG_SEP << std::endl; env().freeAll(); @@ -331,7 +326,7 @@ void Application::configLoop(void) // memory profile ////////////////////////////////////////////////////////////// void Application::memoryProfile(void) { - auto graph = env().makeModuleGraph(); + auto graph = vm().makeModuleGraph(); auto program = graph.topoSort(); bool msg; diff --git a/extras/Hadrons/Application.hpp b/extras/Hadrons/Application.hpp index 8b11b0c7..66488206 100644 --- a/extras/Hadrons/Application.hpp +++ b/extras/Hadrons/Application.hpp @@ -31,8 +31,7 @@ See the full license in the file "LICENSE" in the top level distribution directo #define Hadrons_Application_hpp_ #include -#include -#include +#include #include BEGIN_HADRONS_NAMESPACE @@ -100,7 +99,9 @@ public: void configLoop(void); private: // environment shortcut - Environment & env(void) const; + DEFINE_ENV_ALIAS; + // virtual machine shortcut + DEFINE_VM_ALIAS; // memory profile void memoryProfile(void); private: @@ -119,14 +120,14 @@ private: template void Application::createModule(const std::string name) { - env().createModule(name); + vm().createModule(name); } template void Application::createModule(const std::string name, const typename M::Par &par) { - env().createModule(name, par); + vm().createModule(name, par); } END_HADRONS_NAMESPACE diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index 27849bd7..ea41f343 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -56,38 +56,6 @@ Environment::Environment(void) rng4d_.reset(new GridParallelRNG(grid4d_.get())); } -// dry run ///////////////////////////////////////////////////////////////////// -void Environment::dryRun(const bool isDry) -{ - dryRun_ = isDry; -} - -bool Environment::isDryRun(void) const -{ - return dryRun_; -} - -void Environment::memoryProfile(const bool doMemoryProfile) -{ - memoryProfile_ = doMemoryProfile; -} - -bool Environment::doMemoryProfile(void) const -{ - return memoryProfile_; -} - -// trajectory number /////////////////////////////////////////////////////////// -void Environment::setTrajectory(const unsigned int traj) -{ - traj_ = traj; -} - -unsigned int Environment::getTrajectory(void) const -{ - return traj_; -} - // grids /////////////////////////////////////////////////////////////////////// void Environment::createGrid(const unsigned int Ls) { @@ -153,6 +121,11 @@ int Environment::getDim(const unsigned int mu) const return dim_[mu]; } +unsigned long int Environment::getLocalVolume(void) const +{ + return locVol_; +} + // random number generator ///////////////////////////////////////////////////// void Environment::setSeed(const std::vector &seed) { @@ -164,313 +137,6 @@ GridParallelRNG * Environment::get4dRng(void) const return rng4d_.get(); } -// module management /////////////////////////////////////////////////////////// -void Environment::pushModule(Environment::ModPt &pt) -{ - std::string name = pt->getName(); - - if (!hasModule(name)) - { - std::vector inputAddress; - unsigned int address; - ModuleInfo m; - - m.data = std::move(pt); - m.type = typeIdPt(*m.data.get()); - m.name = name; - auto input = m.data->getInput(); - for (auto &in: input) - { - if (!hasObject(in)) - { - addObject(in , -1); - } - m.input.push_back(objectAddress_[in]); - } - auto output = m.data->getOutput(); - module_.push_back(std::move(m)); - address = static_cast(module_.size() - 1); - moduleAddress_[name] = address; - for (auto &out: output) - { - if (!hasObject(out)) - { - addObject(out, address); - } - else - { - if (object_[objectAddress_[out]].module < 0) - { - object_[objectAddress_[out]].module = address; - } - else - { - HADRON_ERROR("object '" + out - + "' is already produced by module '" - + module_[object_[getObjectAddress(out)].module].name - + "' (while pushing module '" + name + "')"); - } - } - } - } - else - { - HADRON_ERROR("module '" + name + "' already exists"); - } -} - -unsigned int Environment::getNModule(void) const -{ - return module_.size(); -} - -void Environment::createModule(const std::string name, const std::string type, - XmlReader &reader) -{ - auto &factory = ModuleFactory::getInstance(); - auto pt = factory.create(type, name); - - pt->parseParameters(reader, "options"); - pushModule(pt); -} - -ModuleBase * Environment::getModule(const unsigned int address) const -{ - if (hasModule(address)) - { - return module_[address].data.get(); - } - else - { - HADRON_ERROR("no module with address " + std::to_string(address)); - } -} - -ModuleBase * Environment::getModule(const std::string name) const -{ - return getModule(getModuleAddress(name)); -} - -unsigned int Environment::getModuleAddress(const std::string name) const -{ - if (hasModule(name)) - { - return moduleAddress_.at(name); - } - else - { - HADRON_ERROR("no module with name '" + name + "'"); - } -} - -std::string Environment::getModuleName(const unsigned int address) const -{ - if (hasModule(address)) - { - return module_[address].name; - } - else - { - HADRON_ERROR("no module with address " + std::to_string(address)); - } -} - -std::string Environment::getModuleType(const unsigned int address) const -{ - if (hasModule(address)) - { - return typeName(module_[address].type); - } - else - { - HADRON_ERROR("no module with address " + std::to_string(address)); - } -} - -std::string Environment::getModuleType(const std::string name) const -{ - return getModuleType(getModuleAddress(name)); -} - -std::string Environment::getModuleNamespace(const unsigned int address) const -{ - std::string type = getModuleType(address), ns; - - auto pos2 = type.rfind("::"); - auto pos1 = type.rfind("::", pos2 - 2); - - return type.substr(pos1 + 2, pos2 - pos1 - 2); -} - -std::string Environment::getModuleNamespace(const std::string name) const -{ - return getModuleNamespace(getModuleAddress(name)); -} - -bool Environment::hasModule(const unsigned int address) const -{ - return (address < module_.size()); -} - -bool Environment::hasModule(const std::string name) const -{ - return (moduleAddress_.find(name) != moduleAddress_.end()); -} - -Graph Environment::makeModuleGraph(void) const -{ - Graph moduleGraph; - - for (unsigned int i = 0; i < module_.size(); ++i) - { - moduleGraph.addVertex(i); - for (auto &j: module_[i].input) - { - moduleGraph.addEdge(object_[j].module, i); - } - } - - return moduleGraph; -} - -void Environment::checkGraph(void) const -{ - for (auto &o: object_) - { - if (o.module < 0) - { - HADRON_ERROR("object '" + o.name + "' does not have a creator"); - } - } -} - -#define BIG_SEP "===============" -#define SEP "---------------" -#define MEM_MSG(size)\ -sizeString((size)*locVol_) << " (" << sizeString(size) << "/site)" - -Environment::Size -Environment::executeProgram(const std::vector &p) -{ - Size memPeak = 0, sizeBefore, sizeAfter; - std::vector> freeProg; - bool continueCollect, nothingFreed; - - // build garbage collection schedule - LOG(Debug) << "Building garbage collection schedule..." << std::endl; - freeProg.resize(p.size()); - for (unsigned int i = 0; i < object_.size(); ++i) - { - auto pred = [i, this](const unsigned int j) - { - auto &in = module_[j].input; - auto it = std::find(in.begin(), in.end(), i); - - return (it != in.end()) or (j == object_[i].module); - }; - auto it = std::find_if(p.rbegin(), p.rend(), pred); - if (it != p.rend()) - { - freeProg[std::distance(it, p.rend()) - 1].insert(i); - } - } - - // program execution - LOG(Debug) << "Executing program..." << std::endl; - for (unsigned int i = 0; i < p.size(); ++i) - { - // execute module - if (!isDryRun()) - { - LOG(Message) << SEP << " Measurement step " << i+1 << "/" - << p.size() << " (module '" << module_[p[i]].name - << "') " << SEP << std::endl; - } - (*module_[p[i]].data)(); - sizeBefore = getTotalSize(); - // print used memory after execution - if (!isDryRun()) - { - LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore) - << std::endl; - } - if (sizeBefore > memPeak) - { - memPeak = sizeBefore; - } - // garbage collection for step i - if (!isDryRun()) - { - LOG(Message) << "Garbage collection..." << std::endl; - } - nothingFreed = true; - do - { - continueCollect = false; - auto toFree = freeProg[i]; - for (auto &j: toFree) - { - // continue garbage collection while there are still - // objects without owners - continueCollect = continueCollect or !hasOwners(j); - if(freeObject(j)) - { - // if an object has been freed, remove it from - // the garbage collection schedule - freeProg[i].erase(j); - nothingFreed = false; - } - } - } while (continueCollect); - // free temporaries - for (unsigned int i = 0; i < object_.size(); ++i) - { - if ((object_[i].storage == Storage::temporary) - and hasCreatedObject(i)) - { - freeObject(i); - } - } - // any remaining objects in step i garbage collection schedule - // is scheduled for step i + 1 - if (i + 1 < p.size()) - { - for (auto &j: freeProg[i]) - { - freeProg[i + 1].insert(j); - } - } - // print used memory after garbage collection if necessary - if (!isDryRun()) - { - sizeAfter = getTotalSize(); - if (sizeBefore != sizeAfter) - { - LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter) - << std::endl; - } - else - { - LOG(Message) << "Nothing to free" << std::endl; - } - } - } - - return memPeak; -} - -Environment::Size Environment::executeProgram(const std::vector &p) -{ - std::vector pAddress; - - for (auto &n: p) - { - pAddress.push_back(getModuleAddress(n)); - } - - return executeProgram(pAddress); -} - // general memory management /////////////////////////////////////////////////// void Environment::addObject(const std::string name, const int moduleAddress) { @@ -490,6 +156,17 @@ void Environment::addObject(const std::string name, const int moduleAddress) } } +void Environment::setObjectModule(const unsigned int objAddress, + const int modAddress) +{ + object_[objAddress].module = modAddress; +} + +unsigned int Environment::getMaxAddress(void) const +{ + return object_.size(); +} + unsigned int Environment::getObjectAddress(const std::string name) const { if (hasObject(name)) @@ -555,7 +232,24 @@ Environment::Size Environment::getObjectSize(const std::string name) const return getObjectSize(getObjectAddress(name)); } -unsigned int Environment::getObjectModule(const unsigned int address) const +Environment::Storage Environment::getObjectStorage(const unsigned int address) const +{ + if (hasObject(address)) + { + return object_[address].storage; + } + else + { + HADRON_ERROR("no object with address " + std::to_string(address)); + } +} + +Environment::Storage Environment::getObjectStorage(const std::string name) const +{ + return getObjectStorage(getObjectAddress(name)); +} + +int Environment::getObjectModule(const unsigned int address) const { if (hasObject(address)) { @@ -567,7 +261,7 @@ unsigned int Environment::getObjectModule(const unsigned int address) const } } -unsigned int Environment::getObjectModule(const std::string name) const +int Environment::getObjectModule(const std::string name) const { return getObjectModule(getObjectAddress(name)); } @@ -696,7 +390,7 @@ bool Environment::freeObject(const unsigned int address) { if (!hasOwners(address)) { - if (!isDryRun() and hasCreatedObject(address)) + if (hasCreatedObject(address)) { LOG(Message) << "Destroying object '" << object_[address].name << "'" << std::endl; @@ -732,14 +426,9 @@ void Environment::freeAll(void) } } -void Environment::printContent(void) +// print environment content /////////////////////////////////////////////////// +void Environment::printContent(void) const { - LOG(Debug) << "Modules: " << std::endl; - for (unsigned int i = 0; i < module_.size(); ++i) - { - LOG(Debug) << std::setw(4) << i << ": " - << getModuleName(i) << std::endl; - } LOG(Debug) << "Objects: " << std::endl; for (unsigned int i = 0; i < object_.size(); ++i) { diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 58e035ac..9d482923 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -31,20 +31,12 @@ See the full license in the file "LICENSE" in the top level distribution directo #define Hadrons_Environment_hpp_ #include -#include - -#ifndef SITE_SIZE_TYPE -#define SITE_SIZE_TYPE unsigned int -#endif BEGIN_HADRONS_NAMESPACE /****************************************************************************** * Global environment * ******************************************************************************/ -// forward declaration of Module -class ModuleBase; - class Object { public: @@ -66,26 +58,22 @@ private: std::unique_ptr objPt_{nullptr}; }; +#define DEFINE_ENV_ALIAS \ +inline Environment & env(void) const\ +{\ + return Environment::getInstance();\ +} + class Environment { SINGLETON(Environment); public: typedef SITE_SIZE_TYPE Size; - typedef std::unique_ptr ModPt; typedef std::unique_ptr GridPt; typedef std::unique_ptr GridRbPt; typedef std::unique_ptr RngPt; - typedef std::unique_ptr LatticePt; enum class Storage {object, cache, temporary}; private: - struct ModuleInfo - { - const std::type_info *type{nullptr}; - std::string name; - ModPt data{nullptr}; - std::vector input; - size_t maxAllocated; - }; struct ObjInfo { Size size{0}; @@ -98,53 +86,17 @@ private: std::unique_ptr data{nullptr}; }; public: - // dry run - void dryRun(const bool isDry); - bool isDryRun(void) const; - void memoryProfile(const bool doMemoryProfile); - bool doMemoryProfile(void) const; - // trajectory number - void setTrajectory(const unsigned int traj); - unsigned int getTrajectory(void) const; // grids void createGrid(const unsigned int Ls); GridCartesian * getGrid(const unsigned int Ls = 1) const; GridRedBlackCartesian * getRbGrid(const unsigned int Ls = 1) const; std::vector getDim(void) const; int getDim(const unsigned int mu) const; + unsigned long int getLocalVolume(void) const; unsigned int getNd(void) const; // random number generator void setSeed(const std::vector &seed); GridParallelRNG * get4dRng(void) const; - // module management - void pushModule(ModPt &pt); - template - void createModule(const std::string name); - template - void createModule(const std::string name, - const typename M::Par &par); - void createModule(const std::string name, - const std::string type, - XmlReader &reader); - unsigned int getNModule(void) const; - ModuleBase * getModule(const unsigned int address) const; - ModuleBase * getModule(const std::string name) const; - template - M * getModule(const unsigned int address) const; - template - M * getModule(const std::string name) const; - unsigned int getModuleAddress(const std::string name) const; - std::string getModuleName(const unsigned int address) const; - std::string getModuleType(const unsigned int address) const; - std::string getModuleType(const std::string name) const; - std::string getModuleNamespace(const unsigned int address) const; - std::string getModuleNamespace(const std::string name) const; - bool hasModule(const unsigned int address) const; - bool hasModule(const std::string name) const; - Graph makeModuleGraph(void) const; - void checkGraph(void) const; - Size executeProgram(const std::vector &p); - Size executeProgram(const std::vector &p); // general memory management void addObject(const std::string name, const int moduleAddress = -1); @@ -153,18 +105,23 @@ public: const Storage storage, const unsigned int Ls, P &&pt); + void setObjectModule(const unsigned int objAddress, + const int modAddress); template T * getObject(const unsigned int address) const; template T * getObject(const std::string name) const; + unsigned int getMaxAddress(void) const; unsigned int getObjectAddress(const std::string name) const; std::string getObjectName(const unsigned int address) const; std::string getObjectType(const unsigned int address) const; std::string getObjectType(const std::string name) const; Size getObjectSize(const unsigned int address) const; Size getObjectSize(const std::string name) const; - unsigned int getObjectModule(const unsigned int address) const; - unsigned int getObjectModule(const std::string name) const; + Storage getObjectStorage(const unsigned int address) const; + Storage getObjectStorage(const std::string name) const; + int getObjectModule(const unsigned int address) const; + int getObjectModule(const std::string name) const; unsigned int getObjectLs(const unsigned int address) const; unsigned int getObjectLs(const std::string name) const; bool hasObject(const unsigned int address) const; @@ -187,11 +144,11 @@ public: bool freeObject(const unsigned int address); bool freeObject(const std::string name); void freeAll(void); - void printContent(void); + // print environment content + void printContent(void) const; private: // general - bool dryRun_{false}, memoryProfile_{false}; - unsigned int traj_, locVol_; + unsigned long int locVol_; // grids std::vector dim_; GridPt grid4d_; @@ -201,12 +158,6 @@ private: unsigned int nd_; // random number generator RngPt rng4d_; - // module and related maps - std::vector module_; - std::map moduleAddress_; - std::string currentModule_{""}; - // lattice store - std::map lattice_; // object store std::vector object_; std::map objectAddress_; @@ -243,46 +194,7 @@ void Holder::reset(T *pt) /****************************************************************************** * Environment template implementation * ******************************************************************************/ -// module management /////////////////////////////////////////////////////////// -template -void Environment::createModule(const std::string name) -{ - ModPt pt(new M(name)); - - pushModule(pt); -} - -template -void Environment::createModule(const std::string name, - const typename M::Par &par) -{ - ModPt pt(new M(name)); - - static_cast(pt.get())->setPar(par); - pushModule(pt); -} - -template -M * Environment::getModule(const unsigned int address) const -{ - if (auto *pt = dynamic_cast(getModule(address))) - { - return pt; - } - else - { - HADRON_ERROR("module '" + module_[address].name - + "' does not have type " + typeid(M).name() - + "(object type: " + getModuleType(address) + ")"); - } -} - -template -M * Environment::getModule(const std::string name) const -{ - return getModule(getModuleAddress(name)); -} - +// general memory management /////////////////////////////////////////////////// template void Environment::createObject(const std::string name, const Environment::Storage storage, diff --git a/extras/Hadrons/Global.hpp b/extras/Hadrons/Global.hpp index 371256e8..1f0ce201 100644 --- a/extras/Hadrons/Global.hpp +++ b/extras/Hadrons/Global.hpp @@ -35,6 +35,10 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include +#ifndef SITE_SIZE_TYPE +#define SITE_SIZE_TYPE unsigned int +#endif + #define BEGIN_HADRONS_NAMESPACE \ namespace Grid {\ using namespace QCD;\ diff --git a/extras/Hadrons/Makefile.am b/extras/Hadrons/Makefile.am index 9cb23600..826cb158 100644 --- a/extras/Hadrons/Makefile.am +++ b/extras/Hadrons/Makefile.am @@ -8,7 +8,8 @@ libHadrons_a_SOURCES = \ Application.cc \ Environment.cc \ Global.cc \ - Module.cc + Module.cc \ + VirtualMachine.cc libHadrons_adir = $(pkgincludedir)/Hadrons nobase_libHadrons_a_HEADERS = \ $(modules_hpp) \ @@ -20,7 +21,8 @@ nobase_libHadrons_a_HEADERS = \ Graph.hpp \ Module.hpp \ Modules.hpp \ - ModuleFactory.hpp + ModuleFactory.hpp \ + VirtualMachine.hpp HadronsXmlRun_SOURCES = HadronsXmlRun.cc HadronsXmlRun_LDADD = libHadrons.a -lGrid diff --git a/extras/Hadrons/Module.cc b/extras/Hadrons/Module.cc index 2549a931..bf596bfc 100644 --- a/extras/Hadrons/Module.cc +++ b/extras/Hadrons/Module.cc @@ -39,7 +39,6 @@ using namespace Hadrons; // constructor ///////////////////////////////////////////////////////////////// ModuleBase::ModuleBase(const std::string name) : name_(name) -, env_(Environment::getInstance()) {} // access ////////////////////////////////////////////////////////////////////// @@ -48,11 +47,6 @@ std::string ModuleBase::getName(void) const return name_; } -Environment & ModuleBase::env(void) const -{ - return env_; -} - // get factory registration name if available std::string ModuleBase::getRegisteredName(void) { @@ -64,7 +58,7 @@ std::string ModuleBase::getRegisteredName(void) void ModuleBase::operator()(void) { setup(); - if (!env().isDryRun()) + if (!vm().isDryRun()) { execute(); } diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index 017a9172..d1910c9b 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -31,7 +31,7 @@ See the full license in the file "LICENSE" in the top level distribution directo #define Hadrons_Module_hpp_ #include -#include +#include BEGIN_HADRONS_NAMESPACE @@ -148,7 +148,6 @@ public: virtual ~ModuleBase(void) = default; // access std::string getName(void) const; - Environment &env(void) const; // get factory registration name if available virtual std::string getRegisteredName(void); // dependencies/products @@ -163,9 +162,12 @@ protected: // setup virtual void setup(void) {}; virtual void execute(void) = 0; + // environment shortcut + DEFINE_ENV_ALIAS; + // virtual machine shortcut + DEFINE_VM_ALIAS; private: std::string name_; - Environment &env_; }; // derived class, templating the parameter class diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 31640b7c..7c0012d2 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -211,7 +211,7 @@ void TMeson::execute(void) Gamma gSrc(gammaList[i].second); std::string ns; - ns = env().getModuleNamespace(env().getObjectModule(par().sink)); + ns = vm().getModuleNamespace(env().getObjectModule(par().sink)); if (ns == "MSource") { PropagatorField1 &sink = envGet(PropagatorField1, par().sink); diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc new file mode 100644 index 00000000..f09e2710 --- /dev/null +++ b/extras/Hadrons/VirtualMachine.cc @@ -0,0 +1,388 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/VirtualMachine.cc + +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + +#include +#include + +using namespace Grid; +using namespace QCD; +using namespace Hadrons; + +/****************************************************************************** + * VirtualMachine implementation * + ******************************************************************************/ +// dry run ///////////////////////////////////////////////////////////////////// +void VirtualMachine::dryRun(const bool isDry) +{ + dryRun_ = isDry; +} + +bool VirtualMachine::isDryRun(void) const +{ + return dryRun_; +} + +void VirtualMachine::memoryProfile(const bool doMemoryProfile) +{ + memoryProfile_ = doMemoryProfile; +} + +bool VirtualMachine::doMemoryProfile(void) const +{ + return memoryProfile_; +} + +// trajectory counter ////////////////////////////////////////////////////////// +void VirtualMachine::setTrajectory(const unsigned int traj) +{ + traj_ = traj; +} + +unsigned int VirtualMachine::getTrajectory(void) const +{ + return traj_; +} + +// module management /////////////////////////////////////////////////////////// +void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) +{ + std::string name = pt->getName(); + + if (!hasModule(name)) + { + std::vector inputAddress; + unsigned int address; + ModuleInfo m; + + m.data = std::move(pt); + m.type = typeIdPt(*m.data.get()); + m.name = name; + auto input = m.data->getInput(); + for (auto &in: input) + { + if (!env().hasObject(in)) + { + env().addObject(in , -1); + } + m.input.push_back(env().getObjectAddress(in)); + } + auto output = m.data->getOutput(); + module_.push_back(std::move(m)); + address = static_cast(module_.size() - 1); + moduleAddress_[name] = address; + for (auto &out: output) + { + if (!env().hasObject(out)) + { + env().addObject(out, address); + } + else + { + if (env().getObjectModule(env().getObjectAddress(out)) < 0) + { + env().setObjectModule(env().getObjectAddress(out), address); + } + else + { + HADRON_ERROR("object '" + out + + "' is already produced by module '" + + module_[env().getObjectModule(out)].name + + "' (while pushing module '" + name + "')"); + } + } + } + } + else + { + HADRON_ERROR("module '" + name + "' already exists"); + } +} + +unsigned int VirtualMachine::getNModule(void) const +{ + return module_.size(); +} + +void VirtualMachine::createModule(const std::string name, const std::string type, + XmlReader &reader) +{ + auto &factory = ModuleFactory::getInstance(); + auto pt = factory.create(type, name); + + pt->parseParameters(reader, "options"); + pushModule(pt); +} + +ModuleBase * VirtualMachine::getModule(const unsigned int address) const +{ + if (hasModule(address)) + { + return module_[address].data.get(); + } + else + { + HADRON_ERROR("no module with address " + std::to_string(address)); + } +} + +ModuleBase * VirtualMachine::getModule(const std::string name) const +{ + return getModule(getModuleAddress(name)); +} + +unsigned int VirtualMachine::getModuleAddress(const std::string name) const +{ + if (hasModule(name)) + { + return moduleAddress_.at(name); + } + else + { + HADRON_ERROR("no module with name '" + name + "'"); + } +} + +std::string VirtualMachine::getModuleName(const unsigned int address) const +{ + if (hasModule(address)) + { + return module_[address].name; + } + else + { + HADRON_ERROR("no module with address " + std::to_string(address)); + } +} + +std::string VirtualMachine::getModuleType(const unsigned int address) const +{ + if (hasModule(address)) + { + return typeName(module_[address].type); + } + else + { + HADRON_ERROR("no module with address " + std::to_string(address)); + } +} + +std::string VirtualMachine::getModuleType(const std::string name) const +{ + return getModuleType(getModuleAddress(name)); +} + +std::string VirtualMachine::getModuleNamespace(const unsigned int address) const +{ + std::string type = getModuleType(address), ns; + + auto pos2 = type.rfind("::"); + auto pos1 = type.rfind("::", pos2 - 2); + + return type.substr(pos1 + 2, pos2 - pos1 - 2); +} + +std::string VirtualMachine::getModuleNamespace(const std::string name) const +{ + return getModuleNamespace(getModuleAddress(name)); +} + +bool VirtualMachine::hasModule(const unsigned int address) const +{ + return (address < module_.size()); +} + +bool VirtualMachine::hasModule(const std::string name) const +{ + return (moduleAddress_.find(name) != moduleAddress_.end()); +} + +Graph VirtualMachine::makeModuleGraph(void) const +{ + Graph moduleGraph; + + for (unsigned int i = 0; i < module_.size(); ++i) + { + moduleGraph.addVertex(i); + for (auto &j: module_[i].input) + { + moduleGraph.addEdge(env().getObjectModule(j), i); + } + } + + return moduleGraph; +} + +// void VirtualMachine::checkGraph(void) const +// { +// for (auto &o: object_) +// { +// if (o.module < 0) +// { +// HADRON_ERROR("object '" + o.name + "' does not have a creator"); +// } +// } +// } + +// general execution /////////////////////////////////////////////////////////// +#define BIG_SEP "===============" +#define SEP "---------------" +#define MEM_MSG(size)\ +sizeString((size)*env().getLocalVolume()) << " (" << sizeString(size) << "/site)" + +VirtualMachine::Size +VirtualMachine::executeProgram(const std::vector &p) +{ + Size memPeak = 0, sizeBefore, sizeAfter; + std::vector> freeProg; + bool continueCollect, nothingFreed; + + // build garbage collection schedule + LOG(Debug) << "Building garbage collection schedule..." << std::endl; + freeProg.resize(p.size()); + for (unsigned int i = 0; i < env().getMaxAddress(); ++i) + { + auto pred = [i, this](const unsigned int j) + { + auto &in = module_[j].input; + auto it = std::find(in.begin(), in.end(), i); + + return (it != in.end()) or (j == env().getObjectModule(i)); + }; + auto it = std::find_if(p.rbegin(), p.rend(), pred); + if (it != p.rend()) + { + freeProg[std::distance(it, p.rend()) - 1].insert(i); + } + } + + // program execution + LOG(Debug) << "Executing program..." << std::endl; + for (unsigned int i = 0; i < p.size(); ++i) + { + // execute module + if (!isDryRun()) + { + LOG(Message) << SEP << " Measurement step " << i+1 << "/" + << p.size() << " (module '" << module_[p[i]].name + << "') " << SEP << std::endl; + } + (*module_[p[i]].data)(); + sizeBefore = env().getTotalSize(); + // print used memory after execution + if (!isDryRun()) + { + LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore) + << std::endl; + } + if (sizeBefore > memPeak) + { + memPeak = sizeBefore; + } + // garbage collection for step i + if (!isDryRun()) + { + LOG(Message) << "Garbage collection..." << std::endl; + } + nothingFreed = true; + do + { + continueCollect = false; + auto toFree = freeProg[i]; + for (auto &j: toFree) + { + // continue garbage collection while there are still + // objects without owners + continueCollect = continueCollect or !env().hasOwners(j); + if(env().freeObject(j)) + { + // if an object has been freed, remove it from + // the garbage collection schedule + freeProg[i].erase(j); + nothingFreed = false; + } + } + } while (continueCollect); + // free temporaries + for (unsigned int i = 0; i < env().getMaxAddress(); ++i) + { + if ((env().getObjectStorage(i) == Environment::Storage::temporary) + and env().hasCreatedObject(i)) + { + env().freeObject(i); + } + } + // any remaining objects in step i garbage collection schedule + // is scheduled for step i + 1 + if (i + 1 < p.size()) + { + for (auto &j: freeProg[i]) + { + freeProg[i + 1].insert(j); + } + } + // print used memory after garbage collection if necessary + if (!isDryRun()) + { + sizeAfter = env().getTotalSize(); + if (sizeBefore != sizeAfter) + { + LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter) + << std::endl; + } + else + { + LOG(Message) << "Nothing to free" << std::endl; + } + } + } + + return memPeak; +} + +VirtualMachine::Size VirtualMachine::executeProgram(const std::vector &p) +{ + std::vector pAddress; + + for (auto &n: p) + { + pAddress.push_back(getModuleAddress(n)); + } + + return executeProgram(pAddress); +} + +// print VM content //////////////////////////////////////////////////////////// +void VirtualMachine::printContent(void) const +{ + LOG(Debug) << "Modules: " << std::endl; + for (unsigned int i = 0; i < module_.size(); ++i) + { + LOG(Debug) << std::setw(4) << i << ": " + << getModuleName(i) << std::endl; + } +} diff --git a/extras/Hadrons/VirtualMachine.hpp b/extras/Hadrons/VirtualMachine.hpp new file mode 100644 index 00000000..357fdb5b --- /dev/null +++ b/extras/Hadrons/VirtualMachine.hpp @@ -0,0 +1,164 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/VirtualMachine.hpp + +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + +#ifndef Hadrons_VirtualMachine_hpp_ +#define Hadrons_VirtualMachine_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +#define DEFINE_VM_ALIAS \ +inline VirtualMachine & vm(void) const\ +{\ + return VirtualMachine::getInstance();\ +} + +/****************************************************************************** + * Virtual machine for module execution * + ******************************************************************************/ +// forward declaration of Module +class ModuleBase; + +class VirtualMachine +{ + SINGLETON_DEFCTOR(VirtualMachine); +public: + typedef SITE_SIZE_TYPE Size; + typedef std::unique_ptr ModPt; +private: + struct ModuleInfo + { + const std::type_info *type{nullptr}; + std::string name; + ModPt data{nullptr}; + std::vector input; + size_t maxAllocated; + }; +public: + // dry run + void dryRun(const bool isDry); + bool isDryRun(void) const; + void memoryProfile(const bool doMemoryProfile); + bool doMemoryProfile(void) const; + // trajectory counter + void setTrajectory(const unsigned int traj); + unsigned int getTrajectory(void) const; + // module management + void pushModule(ModPt &pt); + template + void createModule(const std::string name); + template + void createModule(const std::string name, + const typename M::Par &par); + void createModule(const std::string name, + const std::string type, + XmlReader &reader); + unsigned int getNModule(void) const; + ModuleBase * getModule(const unsigned int address) const; + ModuleBase * getModule(const std::string name) const; + template + M * getModule(const unsigned int address) const; + template + M * getModule(const std::string name) const; + unsigned int getModuleAddress(const std::string name) const; + std::string getModuleName(const unsigned int address) const; + std::string getModuleType(const unsigned int address) const; + std::string getModuleType(const std::string name) const; + std::string getModuleNamespace(const unsigned int address) const; + std::string getModuleNamespace(const std::string name) const; + bool hasModule(const unsigned int address) const; + bool hasModule(const std::string name) const; + Graph makeModuleGraph(void) const; + void checkGraph(void) const; + // print VM content + void printContent(void) const; + // general execution + Size executeProgram(const std::vector &p); + Size executeProgram(const std::vector &p); +private: + // environment shortcut + DEFINE_ENV_ALIAS; +private: + // general + bool dryRun_{false}, memoryProfile_{false}; + unsigned int traj_; + // module and related maps + std::vector module_; + std::map moduleAddress_; + std::string currentModule_{""}; +}; + +/****************************************************************************** + * VirtualMachine template implementation * + ******************************************************************************/ +// module management /////////////////////////////////////////////////////////// +template +void VirtualMachine::createModule(const std::string name) +{ + ModPt pt(new M(name)); + + pushModule(pt); +} + +template +void VirtualMachine::createModule(const std::string name, + const typename M::Par &par) +{ + ModPt pt(new M(name)); + + static_cast(pt.get())->setPar(par); + pushModule(pt); +} + +template +M * VirtualMachine::getModule(const unsigned int address) const +{ + if (auto *pt = dynamic_cast(getModule(address))) + { + return pt; + } + else + { + HADRON_ERROR("module '" + module_[address].name + + "' does not have type " + typeid(M).name() + + "(has type: " + getModuleType(address) + ")"); + } +} + +template +M * VirtualMachine::getModule(const std::string name) const +{ + return getModule(getModuleAddress(name)); +} + +END_HADRONS_NAMESPACE + +#endif // Hadrons_VirtualMachine_hpp_ From 62eb1f0e593042f9f7665a55c0f17fe3e196beae Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 6 Dec 2017 16:48:17 +0100 Subject: [PATCH 70/86] FermionOperator virtual destructor needed for polymorphism --- lib/qcd/action/fermion/FermionOperator.h | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/qcd/action/fermion/FermionOperator.h b/lib/qcd/action/fermion/FermionOperator.h index 676a0e83..ddd2272a 100644 --- a/lib/qcd/action/fermion/FermionOperator.h +++ b/lib/qcd/action/fermion/FermionOperator.h @@ -47,6 +47,7 @@ namespace Grid { INHERIT_IMPL_TYPES(Impl); FermionOperator(const ImplParams &p= ImplParams()) : Impl(p) {}; + virtual ~FermionOperator(void) = default; virtual FermionField &tmp(void) = 0; From e78794688a676131ecf88902ae923a7d32b7cb96 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 6 Dec 2017 16:50:25 +0100 Subject: [PATCH 71/86] memory profiler improvement --- lib/allocator/AlignedAllocator.cc | 3 +- lib/allocator/AlignedAllocator.h | 79 ++++++++++++++++++------------- 2 files changed, 47 insertions(+), 35 deletions(-) diff --git a/lib/allocator/AlignedAllocator.cc b/lib/allocator/AlignedAllocator.cc index 944e287f..dfdb1050 100644 --- a/lib/allocator/AlignedAllocator.cc +++ b/lib/allocator/AlignedAllocator.cc @@ -3,7 +3,8 @@ namespace Grid { -MemoryStats *MemoryProfiler::stats = nullptr; +MemoryStats *MemoryProfiler::stats = nullptr; +bool MemoryProfiler::debug = false; int PointerCache::victim; diff --git a/lib/allocator/AlignedAllocator.h b/lib/allocator/AlignedAllocator.h index bdccacec..85e2b240 100644 --- a/lib/allocator/AlignedAllocator.h +++ b/lib/allocator/AlignedAllocator.h @@ -74,8 +74,47 @@ namespace Grid { { public: static MemoryStats *stats; + static bool debug; }; + #define profilerDebugPrint \ + if (MemoryProfiler::stats)\ + {\ + auto s = MemoryProfiler::stats;\ + std::cout << "[Memory debug] Stats " << MemoryProfiler::stats << std::endl;\ + std::cout << "[Memory debug] Total : " << s->totalAllocated << "B" << std::endl;\ + std::cout << "[Memory debug] Max : " << s->maxAllocated << "B" << std::endl;\ + std::cout << "[Memory debug] Current: " << s->totalAllocated << "B" << std::endl;\ + std::cout << "[Memory debug] Freed : " << s->totalFreed << "B" << std::endl;\ + } + + #define profilerAllocate(bytes)\ + if (MemoryProfiler::stats)\ + {\ + auto s = MemoryProfiler::stats;\ + s->totalAllocated += (bytes);\ + s->currentlyAllocated += (bytes);\ + s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated);\ + }\ + if (MemoryProfiler::debug)\ + {\ + std::cout << "[Memory debug] allocating " << bytes << "B" << std::endl;\ + profilerDebugPrint;\ + } + + #define profilerFree(bytes)\ + if (MemoryProfiler::stats)\ + {\ + auto s = MemoryProfiler::stats;\ + s->totalFreed += (bytes);\ + s->currentlyAllocated -= (bytes);\ + }\ + if (MemoryProfiler::debug)\ + {\ + std::cout << "[Memory debug] freeing " << bytes << "B" << std::endl;\ + profilerDebugPrint;\ + } + void check_huge_pages(void *Buf,uint64_t BYTES); //////////////////////////////////////////////////////////////////// @@ -104,13 +143,7 @@ public: pointer allocate(size_type __n, const void* _p= 0) { size_type bytes = __n*sizeof(_Tp); - - if (auto s = MemoryProfiler::stats) - { - s->totalAllocated += bytes; - s->currentlyAllocated += bytes; - s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated); - } + profilerAllocate(bytes); _Tp *ptr = (_Tp *) PointerCache::Lookup(bytes); // if ( ptr != NULL ) @@ -141,11 +174,7 @@ public: void deallocate(pointer __p, size_type __n) { size_type bytes = __n * sizeof(_Tp); - if (auto s = MemoryProfiler::stats) - { - s->totalFreed += bytes; - s->currentlyAllocated -= bytes; - } + profilerFree(bytes); pointer __freeme = (pointer)PointerCache::Insert((void *)__p,bytes); @@ -199,12 +228,7 @@ public: { size_type bytes = __n*sizeof(_Tp); - if (auto s = MemoryProfiler::stats) - { - s->totalAllocated += bytes; - s->currentlyAllocated += bytes; - s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated); - } + profilerAllocate(bytes); #ifdef CRAY _Tp *ptr = (_Tp *) shmem_align(bytes,64); #else @@ -229,11 +253,7 @@ public: void deallocate(pointer __p, size_type __n) { size_type bytes = __n*sizeof(_Tp); - if (auto s = MemoryProfiler::stats) - { - s->totalFreed += bytes; - s->currentlyAllocated -= bytes; - } + profilerFree(bytes); shmem_free((void *)__p); } #else @@ -241,12 +261,7 @@ public: { size_type bytes = __n*sizeof(_Tp); - if (auto s = MemoryProfiler::stats) - { - s->totalAllocated += bytes; - s->currentlyAllocated += bytes; - s->maxAllocated = std::max(s->maxAllocated, s->currentlyAllocated); - } + profilerAllocate(bytes); #ifdef HAVE_MM_MALLOC_H _Tp * ptr = (_Tp *) _mm_malloc(bytes, GRID_ALLOC_ALIGN); #else @@ -265,11 +280,7 @@ public: void deallocate(pointer __p, size_type __n) { size_type bytes = __n*sizeof(_Tp); - if (auto s = MemoryProfiler::stats) - { - s->totalFreed += bytes; - s->currentlyAllocated -= bytes; - } + profilerFree(bytes); #ifdef HAVE_MM_MALLOC_H _mm_free((void *)__p); #else From 0fbf445edd90be7ac6363a77bc93c8b7325c45fe Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 6 Dec 2017 16:51:48 +0100 Subject: [PATCH 72/86] Hadrons: object creation that get properly captured by the memory profiler --- extras/Hadrons/Environment.hpp | 32 +++++++++++++++------ extras/Hadrons/Module.hpp | 27 +++++++++-------- extras/Hadrons/Modules/MAction/DWF.hpp | 5 ++-- extras/Hadrons/Modules/MAction/Wilson.hpp | 5 ++-- extras/Hadrons/Modules/MSolver/RBPrecCG.hpp | 2 +- extras/Hadrons/VirtualMachine.cc | 3 +- 6 files changed, 44 insertions(+), 30 deletions(-) diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 9d482923..5058a820 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -100,11 +100,16 @@ public: // general memory management void addObject(const std::string name, const int moduleAddress = -1); - template + template + void createDerivedObject(const std::string name, + const Environment::Storage storage, + const unsigned int Ls, + Ts && ... args); + template void createObject(const std::string name, - const Storage storage, + const Environment::Storage storage, const unsigned int Ls, - P &&pt); + Ts && ... args); void setObjectModule(const unsigned int objAddress, const int modAddress); template @@ -195,11 +200,11 @@ void Holder::reset(T *pt) * Environment template implementation * ******************************************************************************/ // general memory management /////////////////////////////////////////////////// -template -void Environment::createObject(const std::string name, +template +void Environment::createDerivedObject(const std::string name, const Environment::Storage storage, const unsigned int Ls, - P &&pt) + Ts && ... args) { if (!hasObject(name)) { @@ -210,13 +215,13 @@ void Environment::createObject(const std::string name, if (!object_[address].data) { - MemoryStats memStats; + MemoryStats memStats; MemoryProfiler::stats = &memStats; object_[address].storage = storage; object_[address].Ls = Ls; - object_[address].data.reset(new Holder(pt)); - object_[address].size = memStats.totalAllocated; + object_[address].data.reset(new Holder(new T(std::forward(args)...))); + object_[address].size = memStats.maxAllocated; object_[address].type = &typeid(T); MemoryProfiler::stats = nullptr; } @@ -226,6 +231,15 @@ void Environment::createObject(const std::string name, } } +template +void Environment::createObject(const std::string name, + const Environment::Storage storage, + const unsigned int Ls, + Ts && ... args) +{ + createDerivedObject(name, storage, Ls, std::forward(args)...); +} + template T * Environment::getObject(const unsigned int address) const { diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index d1910c9b..14d98bfb 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -98,39 +98,42 @@ static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance; #define envHasType(type, name)\ env().template isObjectOfType(name) -#define envCreate(type, name, Ls, pt)\ -env().template createObject(name, Environment::Storage::object, Ls, pt) +#define envCreate(type, name, Ls, ...)\ +env().template createObject(name, Environment::Storage::object, Ls, __VA_ARGS__) + +#define envCreateDerived(base, type, name, Ls, ...)\ +env().template createDerivedObject(name, Environment::Storage::object, Ls, __VA_ARGS__) #define envCreateLat4(type, name)\ -envCreate(type, name, 1, new type(env().getGrid())) +envCreate(type, name, 1, env().getGrid()) #define envCreateLat5(type, name, Ls)\ -envCreate(type, name, Ls, new type(env().getGrid(Ls))) +envCreate(type, name, Ls, env().getGrid(Ls)) #define envCreateLat(...)\ MACRO_REDIRECT(__VA_ARGS__, envCreateLat5, envCreateLat4)(__VA_ARGS__) -#define envCache(type, name, Ls, pt)\ -env().template createObject(name, Environment::Storage::cache, Ls, pt) +#define envCache(type, name, Ls, ...)\ +env().template createObject(name, Environment::Storage::cache, Ls, __VA_ARGS__) #define envCacheLat4(type, name)\ -envCache(type, name, 1, new type(env().getGrid())) +envCache(type, name, 1, env().getGrid()) #define envCacheLat5(type, name, Ls)\ -envCache(type, name, Ls, new type(env().getGrid(Ls))) +envCache(type, name, Ls, env().getGrid(Ls)) #define envCacheLat(...)\ MACRO_REDIRECT(__VA_ARGS__, envCacheLat5, envCacheLat4)(__VA_ARGS__) -#define envTmp(type, name, Ls, pt)\ +#define envTmp(type, name, Ls, ...)\ env().template createObject(getName() + "_tmp_" + name, \ - Environment::Storage::temporary, Ls, pt) + Environment::Storage::temporary, Ls, __VA_ARGS__) #define envTmpLat4(type, name)\ -envTmp(type, name, 1, new type(env().getGrid())) +envTmp(type, name, 1, env().getGrid()) #define envTmpLat5(type, name, Ls)\ -envTmp(type, name, Ls, new type(env().getGrid(Ls))) +envTmp(type, name, Ls, env().getGrid(Ls)) #define envTmpLat(...)\ MACRO_REDIRECT(__VA_ARGS__, envTmpLat5, envTmpLat4)(__VA_ARGS__) diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index 36c70073..e7d28476 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -118,9 +118,8 @@ void TDWF::setup(void) auto &grb5 = *env().getRbGrid(par().Ls); std::vector boundary = strToVec(par().boundary); typename DomainWallFermion::ImplParams implParams(boundary); - envCreate(FMat, getName(), par().Ls, - new DomainWallFermion(U, g5, grb5, g4, grb4, par().mass, - par().M5, implParams)); + envCreateDerived(FMat, DomainWallFermion, getName(), par().Ls, U, g5, + grb5, g4, grb4, par().mass, par().M5, implParams); } // execution /////////////////////////////////////////////////////////////////// diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index 7fe1f44e..591a3fed 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -111,9 +111,8 @@ void TWilson::setup(void) auto &gridRb = *env().getRbGrid(); std::vector boundary = strToVec(par().boundary); typename WilsonFermion::ImplParams implParams(boundary); - envCreate(FMat, getName(), 1, new WilsonFermion(U, grid, gridRb, - par().mass, - implParams)); + envCreateDerived(FMat, WilsonFermion, getName(), 1, U, grid, gridRb, + par().mass, implParams); } // execution /////////////////////////////////////////////////////////////////// diff --git a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp index d8a4b95f..d6c21412 100644 --- a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp +++ b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp @@ -114,7 +114,7 @@ void TRBPrecCG::setup(void) schurSolver(mat, source, sol); }; - envCreate(SolverFn, getName(), Ls, new SolverFn(solver)); + envCreate(SolverFn, getName(), Ls, solver); env().addOwnership(getName(), par().action); } diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index f09e2710..ae1d5b6b 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -251,8 +251,7 @@ Graph VirtualMachine::makeModuleGraph(void) const // general execution /////////////////////////////////////////////////////////// #define BIG_SEP "===============" #define SEP "---------------" -#define MEM_MSG(size)\ -sizeString((size)*env().getLocalVolume()) << " (" << sizeString(size) << "/site)" +#define MEM_MSG(size) sizeString(size) VirtualMachine::Size VirtualMachine::executeProgram(const std::vector &p) From f9aa39e1c458652185ea81d2cfa16b9e47119e4e Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Thu, 7 Dec 2017 14:40:58 +0100 Subject: [PATCH 73/86] global memory debug through command line flag --- extras/Hadrons/Environment.hpp | 15 +++++++++++---- extras/Hadrons/Global.cc | 27 --------------------------- extras/Hadrons/Global.hpp | 3 --- lib/allocator/AlignedAllocator.cc | 25 +++++++++++++++++++++++++ lib/allocator/AlignedAllocator.h | 21 ++++++++++++++------- lib/util/Init.cc | 8 +++++++- 6 files changed, 57 insertions(+), 42 deletions(-) diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 5058a820..5177b312 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -216,14 +216,21 @@ void Environment::createDerivedObject(const std::string name, if (!object_[address].data) { MemoryStats memStats; - - MemoryProfiler::stats = &memStats; + + if (!MemoryProfiler::stats) + { + MemoryProfiler::stats = &memStats; + } + size_t initMem = MemoryProfiler::stats->currentlyAllocated; object_[address].storage = storage; object_[address].Ls = Ls; object_[address].data.reset(new Holder(new T(std::forward(args)...))); - object_[address].size = memStats.maxAllocated; + object_[address].size = MemoryProfiler::stats->maxAllocated - initMem; object_[address].type = &typeid(T); - MemoryProfiler::stats = nullptr; + if (MemoryProfiler::stats == &memStats) + { + MemoryProfiler::stats = nullptr; + } } else { diff --git a/extras/Hadrons/Global.cc b/extras/Hadrons/Global.cc index 7b0b8fb6..130ede96 100644 --- a/extras/Hadrons/Global.cc +++ b/extras/Hadrons/Global.cc @@ -39,33 +39,6 @@ HadronsLogger Hadrons::HadronsLogMessage(1,"Message"); HadronsLogger Hadrons::HadronsLogIterative(1,"Iterative"); HadronsLogger Hadrons::HadronsLogDebug(1,"Debug"); -// pretty size formatting ////////////////////////////////////////////////////// -std::string Hadrons::sizeString(long unsigned int bytes) - -{ - constexpr unsigned int bufSize = 256; - const char *suffixes[7] = {"", "K", "M", "G", "T", "P", "E"}; - char buf[256]; - long unsigned int s = 0; - double count = bytes; - - while (count >= 1024 && s < 7) - { - s++; - count /= 1024; - } - if (count - floor(count) == 0.0) - { - snprintf(buf, bufSize, "%d %sB", (int)count, suffixes[s]); - } - else - { - snprintf(buf, bufSize, "%.1f %sB", count, suffixes[s]); - } - - return std::string(buf); -} - // type utilities ////////////////////////////////////////////////////////////// constexpr unsigned int maxNameSize = 1024u; diff --git a/extras/Hadrons/Global.hpp b/extras/Hadrons/Global.hpp index 1f0ce201..4c37b961 100644 --- a/extras/Hadrons/Global.hpp +++ b/extras/Hadrons/Global.hpp @@ -138,9 +138,6 @@ public:\ private:\ name(void) = default; -// pretty size formating -std::string sizeString(long unsigned int bytes); - // type utilities template const std::type_info * typeIdPt(const T &x) diff --git a/lib/allocator/AlignedAllocator.cc b/lib/allocator/AlignedAllocator.cc index dfdb1050..10b49f4b 100644 --- a/lib/allocator/AlignedAllocator.cc +++ b/lib/allocator/AlignedAllocator.cc @@ -97,4 +97,29 @@ void check_huge_pages(void *Buf,uint64_t BYTES) #endif } +std::string sizeString(const size_t bytes) +{ + constexpr unsigned int bufSize = 256; + const char *suffixes[7] = {"", "K", "M", "G", "T", "P", "E"}; + char buf[256]; + size_t s = 0; + double count = bytes; + + while (count >= 1024 && s < 7) + { + s++; + count /= 1024; + } + if (count - floor(count) == 0.0) + { + snprintf(buf, bufSize, "%d %sB", (int)count, suffixes[s]); + } + else + { + snprintf(buf, bufSize, "%.1f %sB", count, suffixes[s]); + } + + return std::string(buf); +} + } diff --git a/lib/allocator/AlignedAllocator.h b/lib/allocator/AlignedAllocator.h index 85e2b240..3b27aec9 100644 --- a/lib/allocator/AlignedAllocator.h +++ b/lib/allocator/AlignedAllocator.h @@ -64,6 +64,8 @@ namespace Grid { }; + std::string sizeString(size_t bytes); + struct MemoryStats { size_t totalAllocated{0}, maxAllocated{0}, @@ -77,15 +79,20 @@ namespace Grid { static bool debug; }; + #define memString(bytes) std::to_string(bytes) + " (" + sizeString(bytes) + ")" #define profilerDebugPrint \ if (MemoryProfiler::stats)\ {\ auto s = MemoryProfiler::stats;\ - std::cout << "[Memory debug] Stats " << MemoryProfiler::stats << std::endl;\ - std::cout << "[Memory debug] Total : " << s->totalAllocated << "B" << std::endl;\ - std::cout << "[Memory debug] Max : " << s->maxAllocated << "B" << std::endl;\ - std::cout << "[Memory debug] Current: " << s->totalAllocated << "B" << std::endl;\ - std::cout << "[Memory debug] Freed : " << s->totalFreed << "B" << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] Stats " << MemoryProfiler::stats << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] total : " << memString(s->totalAllocated) \ + << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] max : " << memString(s->maxAllocated) \ + << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] current: " << memString(s->currentlyAllocated) \ + << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] freed : " << memString(s->totalFreed) \ + << std::endl;\ } #define profilerAllocate(bytes)\ @@ -98,7 +105,7 @@ namespace Grid { }\ if (MemoryProfiler::debug)\ {\ - std::cout << "[Memory debug] allocating " << bytes << "B" << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] allocating " << memString(bytes) << std::endl;\ profilerDebugPrint;\ } @@ -111,7 +118,7 @@ namespace Grid { }\ if (MemoryProfiler::debug)\ {\ - std::cout << "[Memory debug] freeing " << bytes << "B" << std::endl;\ + std::cout << GridLogDebug << "[Memory debug] freeing " << memString(bytes) << std::endl;\ profilerDebugPrint;\ } diff --git a/lib/util/Init.cc b/lib/util/Init.cc index 031f8f5a..20367293 100644 --- a/lib/util/Init.cc +++ b/lib/util/Init.cc @@ -204,7 +204,7 @@ std::string GridCmdVectorIntToString(const std::vector & vec){ // Reinit guard ///////////////////////////////////////////////////////// static int Grid_is_initialised = 0; - +static MemoryStats dbgMemStats; void Grid_init(int *argc,char ***argv) { @@ -251,6 +251,11 @@ void Grid_init(int *argc,char ***argv) assert(fp!=(FILE *)NULL); } + if( GridCmdOptionExists(*argv,*argv+*argc,"--debug-mem") ){ + MemoryProfiler::debug = true; + MemoryProfiler::stats = &dbgMemStats; + } + //////////////////////////////////// // Banner //////////////////////////////////// @@ -324,6 +329,7 @@ void Grid_init(int *argc,char ***argv) std::cout< Date: Fri, 8 Dec 2017 11:13:39 +0000 Subject: [PATCH 74/86] bug fix in sequential insertion of conserved vector current --- lib/qcd/action/fermion/WilsonFermion.cc | 8 +++++++- lib/qcd/action/fermion/WilsonFermion5D.cc | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/lib/qcd/action/fermion/WilsonFermion.cc b/lib/qcd/action/fermion/WilsonFermion.cc index b986edd7..1a020e8a 100644 --- a/lib/qcd/action/fermion/WilsonFermion.cc +++ b/lib/qcd/action/fermion/WilsonFermion.cc @@ -395,7 +395,8 @@ void WilsonFermion::SeqConservedCurrent(PropagatorField &q_in, Lattice> ph(_grid), coor(_grid); Complex i(0.0,1.0); PropagatorField tmpFwd(_grid), tmpBwd(_grid), tmp(_grid); - int tshift = (mu == Tp) ? 1 : 0; + unsigned int tshift = (mu == Tp) ? 1 : 0; + unsigned int LLt = GridDefaultLatt()[Tp]; // Momentum projection ph = zero; @@ -434,6 +435,11 @@ void WilsonFermion::SeqConservedCurrent(PropagatorField &q_in, // Repeat for backward direction. t_mask = ((coords._odata[sU] >= (tmin + tshift)) && (coords._odata[sU] <= (tmax + tshift))); + + //if tmax = LLt-1 (last timeslice) include timeslice 0 if the time is shifted (mu=3) + unsigned int t0 = 0; + if((tmax==LLt-1) && (tshift==1)) t_mask = (t_mask || (coords._odata[sU] == t0 )); + timeSlices = Reduce(t_mask); if (timeSlices > 0) diff --git a/lib/qcd/action/fermion/WilsonFermion5D.cc b/lib/qcd/action/fermion/WilsonFermion5D.cc index 19a37c34..393ee7f3 100644 --- a/lib/qcd/action/fermion/WilsonFermion5D.cc +++ b/lib/qcd/action/fermion/WilsonFermion5D.cc @@ -794,8 +794,9 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, PropagatorField tmpFwd(FermionGrid()), tmpBwd(FermionGrid()), tmp(FermionGrid()); Complex i(0.0, 1.0); - int tshift = (mu == Tp) ? 1 : 0; + unsigned int tshift = (mu == Tp) ? 1 : 0; unsigned int LLs = q_in._grid->_rdimensions[0]; + unsigned int LLt = GridDefaultLatt()[Tp]; // Momentum projection. ph = zero; @@ -842,6 +843,11 @@ void WilsonFermion5D::SeqConservedCurrent(PropagatorField &q_in, // Repeat for backward direction. t_mask = ((coords._odata[sU] >= (tmin + tshift)) && (coords._odata[sU] <= (tmax + tshift))); + + //if tmax = LLt-1 (last timeslice) include timeslice 0 if the time is shifted (mu=3) + unsigned int t0 = 0; + if((tmax==LLt-1) && (tshift==1)) t_mask = (t_mask || (coords._odata[sU] == t0 )); + timeSlices = Reduce(t_mask); if (timeSlices > 0) From 64161a8743ded19a767883793d7030d6e4093699 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Tue, 12 Dec 2017 13:08:01 +0000 Subject: [PATCH 75/86] Hadrons: much simpler reference dependency --- extras/Hadrons/Environment.cc | 78 +++---------------- extras/Hadrons/Environment.hpp | 27 +++---- extras/Hadrons/Graph.hpp | 12 +-- extras/Hadrons/Module.hpp | 1 + extras/Hadrons/Modules/MAction/DWF.hpp | 9 +++ extras/Hadrons/Modules/MAction/Wilson.hpp | 9 +++ extras/Hadrons/Modules/MContraction/Meson.hpp | 9 +++ extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 9 +++ extras/Hadrons/Modules/MGauge/Unit.cc | 7 ++ extras/Hadrons/Modules/MGauge/Unit.hpp | 1 + extras/Hadrons/Modules/MSink/Point.hpp | 9 +++ extras/Hadrons/Modules/MSolver/RBPrecCG.hpp | 12 ++- extras/Hadrons/Modules/MSource/Point.hpp | 9 +++ .../Modules/templates/Module.cc.template | 8 ++ .../Modules/templates/Module.hpp.template | 1 + .../templates/Module_in_NS.cc.template | 8 ++ .../templates/Module_in_NS.hpp.template | 1 + .../Modules/templates/Module_tmp.hpp.template | 1 + .../templates/Module_tmp_in_NS.hpp.template | 9 +++ extras/Hadrons/VirtualMachine.cc | 77 +++++++++--------- 20 files changed, 171 insertions(+), 126 deletions(-) diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index ea41f343..66291966 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -341,81 +341,21 @@ Environment::Size Environment::getTotalSize(void) const return size; } -void Environment::addOwnership(const unsigned int owner, - const unsigned int property) +void Environment::freeObject(const unsigned int address) { - if (hasObject(property)) + if (hasCreatedObject(address)) { - object_[property].owners.insert(owner); - } - else - { - HADRON_ERROR("no object with address " + std::to_string(property)); - } - if (hasObject(owner)) - { - object_[owner].properties.insert(property); - } - else - { - HADRON_ERROR("no object with address " + std::to_string(owner)); + LOG(Message) << "Destroying object '" << object_[address].name + << "'" << std::endl; } + object_[address].size = 0; + object_[address].type = nullptr; + object_[address].data.reset(nullptr); } -void Environment::addOwnership(const std::string owner, - const std::string property) +void Environment::freeObject(const std::string name) { - addOwnership(getObjectAddress(owner), getObjectAddress(property)); -} - -bool Environment::hasOwners(const unsigned int address) const -{ - - if (hasObject(address)) - { - return (!object_[address].owners.empty()); - } - else - { - HADRON_ERROR("no object with address " + std::to_string(address)); - } -} - -bool Environment::hasOwners(const std::string name) const -{ - return hasOwners(getObjectAddress(name)); -} - -bool Environment::freeObject(const unsigned int address) -{ - if (!hasOwners(address)) - { - if (hasCreatedObject(address)) - { - LOG(Message) << "Destroying object '" << object_[address].name - << "'" << std::endl; - } - for (auto &p: object_[address].properties) - { - object_[p].owners.erase(address); - } - object_[address].size = 0; - object_[address].type = nullptr; - object_[address].owners.clear(); - object_[address].properties.clear(); - object_[address].data.reset(nullptr); - - return true; - } - else - { - return false; - } -} - -bool Environment::freeObject(const std::string name) -{ - return freeObject(getObjectAddress(name)); + freeObject(getObjectAddress(name)); } void Environment::freeAll(void) diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 5177b312..811ee14e 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -82,7 +82,6 @@ private: const std::type_info *type{nullptr}; std::string name; int module{-1}; - std::set owners, properties; std::unique_ptr data{nullptr}; }; public: @@ -140,14 +139,8 @@ public: template bool isObjectOfType(const std::string name) const; Environment::Size getTotalSize(void) const; - void addOwnership(const unsigned int owner, - const unsigned int property); - void addOwnership(const std::string owner, - const std::string property); - bool hasOwners(const unsigned int address) const; - bool hasOwners(const std::string name) const; - bool freeObject(const unsigned int address); - bool freeObject(const std::string name); + void freeObject(const unsigned int address); + void freeObject(const std::string name); void freeAll(void); // print environment content void printContent(void) const; @@ -252,15 +245,23 @@ T * Environment::getObject(const unsigned int address) const { if (hasObject(address)) { - if (auto h = dynamic_cast *>(object_[address].data.get())) + if (hasCreatedObject(address)) { - return h->getPt(); + if (auto h = dynamic_cast *>(object_[address].data.get())) + { + return h->getPt(); + } + else + { + HADRON_ERROR("object with address " + std::to_string(address) + + " does not have type '" + typeName(&typeid(T)) + + "' (has type '" + getObjectType(address) + "')"); + } } else { HADRON_ERROR("object with address " + std::to_string(address) + - " does not have type '" + typeName(&typeid(T)) + - "' (has type '" + getObjectType(address) + "')"); + " is empty"); } } else diff --git a/extras/Hadrons/Graph.hpp b/extras/Hadrons/Graph.hpp index df255517..bb9ae679 100644 --- a/extras/Hadrons/Graph.hpp +++ b/extras/Hadrons/Graph.hpp @@ -430,7 +430,7 @@ std::vector Graph::getAdjacentVertices(const T &value) const { return ((e.first == value) or (e.second == value)); }; - auto eIt = find_if(edgeSet_.begin(), edgeSet_.end(), pred); + auto eIt = std::find_if(edgeSet_.begin(), edgeSet_.end(), pred); while (eIt != edgeSet_.end()) { @@ -442,7 +442,7 @@ std::vector Graph::getAdjacentVertices(const T &value) const { adjacentVertex.push_back((*eIt).first); } - eIt = find_if(++eIt, edgeSet_.end(), pred); + eIt = std::find_if(++eIt, edgeSet_.end(), pred); } return adjacentVertex; @@ -458,12 +458,12 @@ std::vector Graph::getChildren(const T &value) const { return (e.first == value); }; - auto eIt = find_if(edgeSet_.begin(), edgeSet_.end(), pred); + auto eIt = std::find_if(edgeSet_.begin(), edgeSet_.end(), pred); while (eIt != edgeSet_.end()) { child.push_back((*eIt).second); - eIt = find_if(++eIt, edgeSet_.end(), pred); + eIt = std::find_if(++eIt, edgeSet_.end(), pred); } return child; @@ -479,12 +479,12 @@ std::vector Graph::getParents(const T &value) const { return (e.second == value); }; - auto eIt = find_if(edgeSet_.begin(), edgeSet_.end(), pred); + auto eIt = std::find_if(edgeSet_.begin(), edgeSet_.end(), pred); while (eIt != edgeSet_.end()) { parent.push_back((*eIt).first); - eIt = find_if(++eIt, edgeSet_.end(), pred); + eIt = std::find_if(++eIt, edgeSet_.end(), pred); } return parent; diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index 14d98bfb..c6b58e9f 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -155,6 +155,7 @@ public: virtual std::string getRegisteredName(void); // dependencies/products virtual std::vector getInput(void) = 0; + virtual std::vector getReference(void) = 0; virtual std::vector getOutput(void) = 0; // parse parameters virtual void parseParameters(XmlReader &reader, const std::string name) = 0; diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index e7d28476..91e4ec94 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -64,6 +64,7 @@ public: virtual ~TDWF(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -92,6 +93,14 @@ std::vector TDWF::getInput(void) return in; } +template +std::vector TDWF::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TDWF::getOutput(void) { diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index 591a3fed..1ca3bf59 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -62,6 +62,7 @@ public: virtual ~TWilson(void) = default; // dependencies/products virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -90,6 +91,14 @@ std::vector TWilson::getInput(void) return in; } +template +std::vector TWilson::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TWilson::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 7c0012d2..7d19feb8 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -95,6 +95,7 @@ public: virtual ~TMeson(void) = default; // dependencies/products virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); virtual void parseGammaString(std::vector &gammaList); protected: @@ -122,6 +123,14 @@ std::vector TMeson::getInput(void) return input; } +template +std::vector TMeson::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TMeson::getOutput(void) { diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index 8529825b..f860c403 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -84,6 +84,7 @@ public: virtual ~TGaugeProp(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -115,6 +116,14 @@ std::vector TGaugeProp::getInput(void) return in; } +template +std::vector TGaugeProp::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TGaugeProp::getOutput(void) { diff --git a/extras/Hadrons/Modules/MGauge/Unit.cc b/extras/Hadrons/Modules/MGauge/Unit.cc index b3a7d634..bc05a785 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.cc +++ b/extras/Hadrons/Modules/MGauge/Unit.cc @@ -47,6 +47,13 @@ std::vector TUnit::getInput(void) return std::vector(); } +std::vector TUnit::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + std::vector TUnit::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/MGauge/Unit.hpp b/extras/Hadrons/Modules/MGauge/Unit.hpp index c1650cc7..4b69f0ce 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.hpp +++ b/extras/Hadrons/Modules/MGauge/Unit.hpp @@ -50,6 +50,7 @@ public: virtual ~TUnit(void) = default; // dependencies/products virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MSink/Point.hpp b/extras/Hadrons/Modules/MSink/Point.hpp index 853a7c32..16b89434 100644 --- a/extras/Hadrons/Modules/MSink/Point.hpp +++ b/extras/Hadrons/Modules/MSink/Point.hpp @@ -60,6 +60,7 @@ public: virtual ~TPoint(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -93,6 +94,14 @@ std::vector TPoint::getInput(void) return in; } +template +std::vector TPoint::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TPoint::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp index d6c21412..bb4f3f62 100644 --- a/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp +++ b/extras/Hadrons/Modules/MSolver/RBPrecCG.hpp @@ -61,6 +61,7 @@ public: virtual ~TRBPrecCG(void) = default; // dependencies/products virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -84,11 +85,19 @@ TRBPrecCG::TRBPrecCG(const std::string name) template std::vector TRBPrecCG::getInput(void) { - std::vector in = {par().action}; + std::vector in = {}; return in; } +template +std::vector TRBPrecCG::getReference(void) +{ + std::vector ref = {par().action}; + + return ref; +} + template std::vector TRBPrecCG::getOutput(void) { @@ -115,7 +124,6 @@ void TRBPrecCG::setup(void) schurSolver(mat, source, sol); }; envCreate(SolverFn, getName(), Ls, solver); - env().addOwnership(getName(), par().action); } // execution /////////////////////////////////////////////////////////////////// diff --git a/extras/Hadrons/Modules/MSource/Point.hpp b/extras/Hadrons/Modules/MSource/Point.hpp index b9813688..3fab41c0 100644 --- a/extras/Hadrons/Modules/MSource/Point.hpp +++ b/extras/Hadrons/Modules/MSource/Point.hpp @@ -71,6 +71,7 @@ public: virtual ~TPoint(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -100,6 +101,14 @@ std::vector TPoint::getInput(void) return in; } +template +std::vector TPoint::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TPoint::getOutput(void) { diff --git a/extras/Hadrons/Modules/templates/Module.cc.template b/extras/Hadrons/Modules/templates/Module.cc.template index 0c509d6d..29edadfb 100644 --- a/extras/Hadrons/Modules/templates/Module.cc.template +++ b/extras/Hadrons/Modules/templates/Module.cc.template @@ -19,6 +19,14 @@ std::vector T___FILEBASENAME___::getInput(void) return in; } +template +std::vector T___FILEBASENAME___::getReference(void) +{ + std::vector in = {}; + + return in; +} + std::vector T___FILEBASENAME___::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/templates/Module.hpp.template b/extras/Hadrons/Modules/templates/Module.hpp.template index fb43260f..b59e168f 100644 --- a/extras/Hadrons/Modules/templates/Module.hpp.template +++ b/extras/Hadrons/Modules/templates/Module.hpp.template @@ -26,6 +26,7 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); diff --git a/extras/Hadrons/Modules/templates/Module_in_NS.cc.template b/extras/Hadrons/Modules/templates/Module_in_NS.cc.template index 8b2a0ec0..880129bd 100644 --- a/extras/Hadrons/Modules/templates/Module_in_NS.cc.template +++ b/extras/Hadrons/Modules/templates/Module_in_NS.cc.template @@ -20,6 +20,14 @@ std::vector T___FILEBASENAME___::getInput(void) return in; } +template +std::vector T___FILEBASENAME___::getReference(void) +{ + std::vector in = {}; + + return in; +} + std::vector T___FILEBASENAME___::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template b/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template index ea77b12a..f90cb052 100644 --- a/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template +++ b/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template @@ -28,6 +28,7 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); diff --git a/extras/Hadrons/Modules/templates/Module_tmp.hpp.template b/extras/Hadrons/Modules/templates/Module_tmp.hpp.template index 2ee053a9..b4e7f87f 100644 --- a/extras/Hadrons/Modules/templates/Module_tmp.hpp.template +++ b/extras/Hadrons/Modules/templates/Module_tmp.hpp.template @@ -27,6 +27,7 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); diff --git a/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template b/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template index b79c0ad3..9aef1c92 100644 --- a/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template +++ b/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template @@ -29,6 +29,7 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); @@ -56,6 +57,14 @@ std::vector T___FILEBASENAME___::getInput(void) return in; } +template +std::vector T___FILEBASENAME___::getReference(void) +{ + std::vector in = {}; + + return in; +} + template std::vector T___FILEBASENAME___::getOutput(void) { diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index ae1d5b6b..7f967f66 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -82,8 +82,7 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) m.data = std::move(pt); m.type = typeIdPt(*m.data.get()); m.name = name; - auto input = m.data->getInput(); - for (auto &in: input) + for (auto &in: m.data->getInput()) { if (!env().hasObject(in)) { @@ -91,11 +90,18 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) } m.input.push_back(env().getObjectAddress(in)); } - auto output = m.data->getOutput(); + for (auto &ref: m.data->getReference()) + { + if (!env().hasObject(ref)) + { + env().addObject(ref , -1); + } + m.input.push_back(env().getObjectAddress(ref)); + } module_.push_back(std::move(m)); address = static_cast(module_.size() - 1); moduleAddress_[name] = address; - for (auto &out: output) + for (auto &out: getModule(address)->getOutput()) { if (!env().hasObject(out)) { @@ -114,6 +120,25 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) + module_[env().getObjectModule(out)].name + "' (while pushing module '" + name + "')"); } + if (getModule(address)->getReference().size() > 0) + { + auto pred = [this, out](const ModuleInfo &n) + { + auto &in = n.input; + auto it = std::find(in.begin(), in.end(), env().getObjectAddress(out)); + + return (it != in.end()); + }; + auto it = std::find_if(module_.begin(), module_.end(), pred); + while (it != module_.end()) + { + for (auto &ref: getModule(address)->getReference()) + { + it->input.push_back(env().getObjectAddress(ref)); + } + it = std::find_if(++it, module_.end(), pred); + } + } } } } @@ -225,12 +250,17 @@ Graph VirtualMachine::makeModuleGraph(void) const { Graph moduleGraph; - for (unsigned int i = 0; i < module_.size(); ++i) + // create vertices + for (unsigned int m = 0; m < module_.size(); ++m) { - moduleGraph.addVertex(i); - for (auto &j: module_[i].input) + moduleGraph.addVertex(m); + } + // create edges + for (unsigned int m = 0; m < module_.size(); ++m) + { + for (auto &in: module_[m].input) { - moduleGraph.addEdge(env().getObjectModule(j), i); + moduleGraph.addEdge(env().getObjectModule(in), m); } } @@ -258,7 +288,6 @@ VirtualMachine::executeProgram(const std::vector &p) { Size memPeak = 0, sizeBefore, sizeAfter; std::vector> freeProg; - bool continueCollect, nothingFreed; // build garbage collection schedule LOG(Debug) << "Building garbage collection schedule..." << std::endl; @@ -307,25 +336,10 @@ VirtualMachine::executeProgram(const std::vector &p) { LOG(Message) << "Garbage collection..." << std::endl; } - nothingFreed = true; - do + for (auto &j: freeProg[i]) { - continueCollect = false; - auto toFree = freeProg[i]; - for (auto &j: toFree) - { - // continue garbage collection while there are still - // objects without owners - continueCollect = continueCollect or !env().hasOwners(j); - if(env().freeObject(j)) - { - // if an object has been freed, remove it from - // the garbage collection schedule - freeProg[i].erase(j); - nothingFreed = false; - } - } - } while (continueCollect); + env().freeObject(j); + } // free temporaries for (unsigned int i = 0; i < env().getMaxAddress(); ++i) { @@ -335,15 +349,6 @@ VirtualMachine::executeProgram(const std::vector &p) env().freeObject(i); } } - // any remaining objects in step i garbage collection schedule - // is scheduled for step i + 1 - if (i + 1 < p.size()) - { - for (auto &j: freeProg[i]) - { - freeProg[i + 1].insert(j); - } - } // print used memory after garbage collection if necessary if (!isDryRun()) { From 26d7b829a076fa74df370789e9f723f8b793fa67 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Tue, 12 Dec 2017 14:04:28 +0000 Subject: [PATCH 76/86] Hadrons: error managed through expections --- extras/Hadrons/Application.cc | 8 +-- extras/Hadrons/Environment.cc | 23 +++--- extras/Hadrons/Environment.hpp | 10 +-- extras/Hadrons/Exceptions.cc | 57 +++++++++++++++ extras/Hadrons/Exceptions.hpp | 72 +++++++++++++++++++ extras/Hadrons/Factory.hpp | 2 +- extras/Hadrons/Global.hpp | 7 +- extras/Hadrons/Graph.hpp | 12 ++-- extras/Hadrons/Makefile.am | 2 + extras/Hadrons/Module.cc | 2 +- .../Modules/MContraction/WardIdentity.hpp | 2 +- extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 2 +- .../Modules/MUtilities/TestSeqConserved.hpp | 2 +- extras/Hadrons/VirtualMachine.cc | 14 ++-- extras/Hadrons/VirtualMachine.hpp | 2 +- 15 files changed, 174 insertions(+), 43 deletions(-) create mode 100644 extras/Hadrons/Exceptions.cc create mode 100644 extras/Hadrons/Exceptions.hpp diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index af67dff3..aa66d36f 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -123,11 +123,11 @@ void Application::parseParameterFile(const std::string parameterFileName) setPar(par); if (!push(reader, "modules")) { - HADRON_ERROR("Cannot open node 'modules' in parameter file '" + parameterFileName + "'"); + HADRON_ERROR(Parsing, "Cannot open node 'modules' in parameter file '" + parameterFileName + "'"); } if (!push(reader, "module")) { - HADRON_ERROR("Cannot open node 'modules/module' in parameter file '" + parameterFileName + "'"); + HADRON_ERROR(Parsing, "Cannot open node 'modules/module' in parameter file '" + parameterFileName + "'"); } do { @@ -262,7 +262,7 @@ void Application::saveSchedule(const std::string filename) if (!scheduled_) { - HADRON_ERROR("Computation not scheduled"); + HADRON_ERROR(Definition, "Computation not scheduled"); } LOG(Message) << "Saving current schedule to '" << filename << "'..." << std::endl; @@ -296,7 +296,7 @@ void Application::printSchedule(void) { if (!scheduled_) { - HADRON_ERROR("Computation not scheduled"); + HADRON_ERROR(Definition, "Computation not scheduled"); } LOG(Message) << "Schedule (memory peak: " << MEM_MSG(memPeak_) << "):" << std::endl; diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index 66291966..403476d0 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -35,6 +35,9 @@ using namespace Grid; using namespace QCD; using namespace Hadrons; +#define ERROR_NO_ADDRESS(address)\ +HADRON_ERROR(Definition, "no object with address " + std::to_string(address)); + /****************************************************************************** * Environment implementation * ******************************************************************************/ @@ -83,7 +86,7 @@ GridCartesian * Environment::getGrid(const unsigned int Ls) const } catch(std::out_of_range &) { - HADRON_ERROR("no grid with Ls= " << Ls); + HADRON_ERROR(Definition, "no grid with Ls= " + std::to_string(Ls)); } } @@ -102,7 +105,7 @@ GridRedBlackCartesian * Environment::getRbGrid(const unsigned int Ls) const } catch(std::out_of_range &) { - HADRON_ERROR("no red-black 5D grid with Ls= " << Ls); + HADRON_ERROR(Definition, "no red-black 5D grid with Ls= " + std::to_string(Ls)); } } @@ -152,7 +155,7 @@ void Environment::addObject(const std::string name, const int moduleAddress) } else { - HADRON_ERROR("object '" + name + "' already exists"); + HADRON_ERROR(Definition, "object '" + name + "' already exists"); } } @@ -175,7 +178,7 @@ unsigned int Environment::getObjectAddress(const std::string name) const } else { - HADRON_ERROR("no object with name '" + name + "'"); + HADRON_ERROR(Definition, "no object with name '" + name + "'"); } } @@ -187,7 +190,7 @@ std::string Environment::getObjectName(const unsigned int address) const } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + ERROR_NO_ADDRESS(address); } } @@ -206,7 +209,7 @@ std::string Environment::getObjectType(const unsigned int address) const } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + ERROR_NO_ADDRESS(address); } } @@ -223,7 +226,7 @@ Environment::Size Environment::getObjectSize(const unsigned int address) const } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + ERROR_NO_ADDRESS(address); } } @@ -240,7 +243,7 @@ Environment::Storage Environment::getObjectStorage(const unsigned int address) c } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + ERROR_NO_ADDRESS(address); } } @@ -257,7 +260,7 @@ int Environment::getObjectModule(const unsigned int address) const } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + ERROR_NO_ADDRESS(address); } } @@ -274,7 +277,7 @@ unsigned int Environment::getObjectLs(const unsigned int address) const } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + ERROR_NO_ADDRESS(address); } } diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 811ee14e..60371c20 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -227,7 +227,7 @@ void Environment::createDerivedObject(const std::string name, } else { - HADRON_ERROR("object '" + name + "' already allocated"); + HADRON_ERROR(Definition, "object '" + name + "' already allocated"); } } @@ -253,20 +253,20 @@ T * Environment::getObject(const unsigned int address) const } else { - HADRON_ERROR("object with address " + std::to_string(address) + + HADRON_ERROR(Definition, "object with address " + std::to_string(address) + " does not have type '" + typeName(&typeid(T)) + "' (has type '" + getObjectType(address) + "')"); } } else { - HADRON_ERROR("object with address " + std::to_string(address) + + HADRON_ERROR(Definition, "object with address " + std::to_string(address) + " is empty"); } } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + HADRON_ERROR(Definition, "no object with address " + std::to_string(address)); } } @@ -292,7 +292,7 @@ bool Environment::isObjectOfType(const unsigned int address) const } else { - HADRON_ERROR("no object with address " + std::to_string(address)); + HADRON_ERROR(Definition, "no object with address " + std::to_string(address)); } } diff --git a/extras/Hadrons/Exceptions.cc b/extras/Hadrons/Exceptions.cc new file mode 100644 index 00000000..bf532c21 --- /dev/null +++ b/extras/Hadrons/Exceptions.cc @@ -0,0 +1,57 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Exceptions.cc + +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + +#include + +#ifndef ERR_SUFF +#define ERR_SUFF " (" + loc + ")" +#endif + +#define CONST_EXC(name, init) \ +name::name(std::string msg, std::string loc)\ +:init\ +{} + +using namespace Grid; +using namespace Hadrons; +using namespace Exceptions; + +// logic errors +CONST_EXC(Logic, logic_error(msg + ERR_SUFF)) +CONST_EXC(Definition, Logic("definition error: " + msg, loc)) +CONST_EXC(Implementation, Logic("implementation error: " + msg, loc)) +CONST_EXC(Range, Logic("range error: " + msg, loc)) +CONST_EXC(Size, Logic("size error: " + msg, loc)) +// runtime errors +CONST_EXC(Runtime, runtime_error(msg + ERR_SUFF)) +CONST_EXC(Argument, Runtime("argument error: " + msg, loc)) +CONST_EXC(Io, Runtime("IO error: " + msg, loc)) +CONST_EXC(Memory, Runtime("memory error: " + msg, loc)) +CONST_EXC(Parsing, Runtime("parsing error: " + msg, loc)) +CONST_EXC(Program, Runtime("program error: " + msg, loc)) +CONST_EXC(System, Runtime("system error: " + msg, loc)) \ No newline at end of file diff --git a/extras/Hadrons/Exceptions.hpp b/extras/Hadrons/Exceptions.hpp new file mode 100644 index 00000000..8f04ab41 --- /dev/null +++ b/extras/Hadrons/Exceptions.hpp @@ -0,0 +1,72 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Exceptions.hpp + +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ + +#ifndef Hadrons_Exceptions_hpp_ +#define Hadrons_Exceptions_hpp_ + +#include +#ifndef Hadrons_Global_hpp_ +#include +#endif + +#define SRC_LOC std::string(__FUNCTION__) + " at " + std::string(__FILE__) + ":"\ + + std::to_string(__LINE__) +#define HADRON_ERROR(exc, msg)\ +LOG(Error) << msg << std::endl;\ +throw(Exceptions::exc(msg, SRC_LOC)); + +#define DECL_EXC(name, base) \ +class name: public base\ +{\ +public:\ + name(std::string msg, std::string loc);\ +} + +BEGIN_HADRONS_NAMESPACE + +namespace Exceptions +{ + // logic errors + DECL_EXC(Logic, std::logic_error); + DECL_EXC(Definition, Logic); + DECL_EXC(Implementation, Logic); + DECL_EXC(Range, Logic); + DECL_EXC(Size, Logic); + // runtime errors + DECL_EXC(Runtime, std::runtime_error); + DECL_EXC(Argument, Runtime); + DECL_EXC(Io, Runtime); + DECL_EXC(Memory, Runtime); + DECL_EXC(Parsing, Runtime); + DECL_EXC(Program, Runtime); + DECL_EXC(System, Runtime); +} + +END_HADRONS_NAMESPACE + +#endif // Hadrons_Exceptions_hpp_ diff --git a/extras/Hadrons/Factory.hpp b/extras/Hadrons/Factory.hpp index da86acae..65ce03ca 100644 --- a/extras/Hadrons/Factory.hpp +++ b/extras/Hadrons/Factory.hpp @@ -95,7 +95,7 @@ std::unique_ptr Factory::create(const std::string type, } catch (std::out_of_range &) { - HADRON_ERROR("object of type '" + type + "' unknown"); + HADRON_ERROR(Argument, "object of type '" + type + "' unknown"); } return func(name); diff --git a/extras/Hadrons/Global.hpp b/extras/Hadrons/Global.hpp index 4c37b961..c3d60bf2 100644 --- a/extras/Hadrons/Global.hpp +++ b/extras/Hadrons/Global.hpp @@ -100,11 +100,6 @@ public: }; #define LOG(channel) std::cout << HadronsLog##channel -#define HADRON_ERROR(msg)\ -LOG(Error) << msg << " (" << __FUNCTION__ << " at " << __FILE__ << ":"\ - << __LINE__ << ")" << std::endl;\ -abort(); - #define DEBUG_VAR(var) LOG(Debug) << #var << "= " << (var) << std::endl; extern HadronsLogger HadronsLogError; @@ -176,4 +171,6 @@ typedef XmlWriter CorrWriter; END_HADRONS_NAMESPACE +#include + #endif // Hadrons_Global_hpp_ diff --git a/extras/Hadrons/Graph.hpp b/extras/Hadrons/Graph.hpp index bb9ae679..a9c240fa 100644 --- a/extras/Hadrons/Graph.hpp +++ b/extras/Hadrons/Graph.hpp @@ -185,7 +185,7 @@ void Graph::removeVertex(const T &value) } else { - HADRON_ERROR("vertex " << value << " does not exists"); + HADRON_ERROR(Range, "vertex does not exists"); } // remove all edges containing the vertex @@ -214,7 +214,7 @@ void Graph::removeEdge(const Edge &e) } else { - HADRON_ERROR("edge " << e << " does not exists"); + HADRON_ERROR(Range, "edge does not exists"); } } @@ -260,7 +260,7 @@ void Graph::mark(const T &value, const bool doMark) } else { - HADRON_ERROR("vertex " << value << " does not exists"); + HADRON_ERROR(Range, "vertex does not exists"); } } @@ -298,7 +298,7 @@ bool Graph::isMarked(const T &value) const } else { - HADRON_ERROR("vertex " << value << " does not exists"); + HADRON_ERROR(Range, "vertex does not exists"); return false; } @@ -544,7 +544,7 @@ std::vector Graph::topoSort(void) { if (tmpMarked.at(v)) { - HADRON_ERROR("cannot topologically sort a cyclic graph"); + HADRON_ERROR(Range, "cannot topologically sort a cyclic graph"); } if (!isMarked(v)) { @@ -603,7 +603,7 @@ std::vector Graph::topoSort(Gen &gen) { if (tmpMarked.at(v)) { - HADRON_ERROR("cannot topologically sort a cyclic graph"); + HADRON_ERROR(Range, "cannot topologically sort a cyclic graph"); } if (!isMarked(v)) { diff --git a/extras/Hadrons/Makefile.am b/extras/Hadrons/Makefile.am index 826cb158..3d07679a 100644 --- a/extras/Hadrons/Makefile.am +++ b/extras/Hadrons/Makefile.am @@ -7,6 +7,7 @@ libHadrons_a_SOURCES = \ $(modules_cc) \ Application.cc \ Environment.cc \ + Exceptions.cc \ Global.cc \ Module.cc \ VirtualMachine.cc @@ -15,6 +16,7 @@ nobase_libHadrons_a_HEADERS = \ $(modules_hpp) \ Application.hpp \ Environment.hpp \ + Exceptions.hpp \ Factory.hpp \ GeneticScheduler.hpp \ Global.hpp \ diff --git a/extras/Hadrons/Module.cc b/extras/Hadrons/Module.cc index bf596bfc..383a5c2e 100644 --- a/extras/Hadrons/Module.cc +++ b/extras/Hadrons/Module.cc @@ -50,7 +50,7 @@ std::string ModuleBase::getName(void) const // get factory registration name if available std::string ModuleBase::getRegisteredName(void) { - HADRON_ERROR("module '" + getName() + "' has a type not registered" + HADRON_ERROR(Definition, "module '" + getName() + "' has no registered type" + " in the factory"); } diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index a298c1a1..90922c27 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -118,7 +118,7 @@ void TWardIdentity::setup(void) Ls_ = env().getObjectLs(par().q); if (Ls_ != env().getObjectLs(par().action)) { - HADRON_ERROR("Ls mismatch between quark action and propagator"); + HADRON_ERROR(Size, "Ls mismatch between quark action and propagator"); } } diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index f860c403..4d08841d 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -187,7 +187,7 @@ void TGaugeProp::execute(void) { if (Ls_ != env().getObjectLs(par().source)) { - HADRON_ERROR("Ls mismatch between quark action and source"); + HADRON_ERROR(Size, "Ls mismatch between quark action and source"); } else { diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index f8714d88..b0f2846f 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -122,7 +122,7 @@ void TTestSeqConserved::setup(void) auto Ls = env().getObjectLs(par().q); if (Ls != env().getObjectLs(par().action)) { - HADRON_ERROR("Ls mismatch between quark action and propagator"); + HADRON_ERROR(Size, "Ls mismatch between quark action and propagator"); } } diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 7f967f66..0c3eca20 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -115,7 +115,7 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) } else { - HADRON_ERROR("object '" + out + HADRON_ERROR(Definition, "object '" + out + "' is already produced by module '" + module_[env().getObjectModule(out)].name + "' (while pushing module '" + name + "')"); @@ -144,7 +144,7 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) } else { - HADRON_ERROR("module '" + name + "' already exists"); + HADRON_ERROR(Definition, "module '" + name + "' already exists"); } } @@ -171,7 +171,7 @@ ModuleBase * VirtualMachine::getModule(const unsigned int address) const } else { - HADRON_ERROR("no module with address " + std::to_string(address)); + HADRON_ERROR(Definition, "no module with address " + std::to_string(address)); } } @@ -188,7 +188,7 @@ unsigned int VirtualMachine::getModuleAddress(const std::string name) const } else { - HADRON_ERROR("no module with name '" + name + "'"); + HADRON_ERROR(Definition, "no module with name '" + name + "'"); } } @@ -200,7 +200,7 @@ std::string VirtualMachine::getModuleName(const unsigned int address) const } else { - HADRON_ERROR("no module with address " + std::to_string(address)); + HADRON_ERROR(Definition, "no module with address " + std::to_string(address)); } } @@ -212,7 +212,7 @@ std::string VirtualMachine::getModuleType(const unsigned int address) const } else { - HADRON_ERROR("no module with address " + std::to_string(address)); + HADRON_ERROR(Definition, "no module with address " + std::to_string(address)); } } @@ -273,7 +273,7 @@ Graph VirtualMachine::makeModuleGraph(void) const // { // if (o.module < 0) // { -// HADRON_ERROR("object '" + o.name + "' does not have a creator"); +// HADRON_ERROR(Runtime, "object '" + o.name + "' does not have a creator"); // } // } // } diff --git a/extras/Hadrons/VirtualMachine.hpp b/extras/Hadrons/VirtualMachine.hpp index 357fdb5b..c5557add 100644 --- a/extras/Hadrons/VirtualMachine.hpp +++ b/extras/Hadrons/VirtualMachine.hpp @@ -147,7 +147,7 @@ M * VirtualMachine::getModule(const unsigned int address) const } else { - HADRON_ERROR("module '" + module_[address].name + HADRON_ERROR(Definition, "module '" + module_[address].name + "' does not have type " + typeid(M).name() + "(has type: " + getModuleType(address) + ")"); } From 259d504ef0325879d19d8283a4cd97a4dabd8c1d Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Tue, 12 Dec 2017 19:32:58 +0000 Subject: [PATCH 77/86] Hadrons: first full implementation of the module memory profiler --- extras/Hadrons/Application.cc | 5 +- extras/Hadrons/Environment.cc | 13 +- extras/Hadrons/Environment.hpp | 9 +- extras/Hadrons/Global.hpp | 2 +- extras/Hadrons/Module.hpp | 6 +- extras/Hadrons/Modules/MContraction/Meson.hpp | 2 +- extras/Hadrons/VirtualMachine.cc | 120 ++++++++++++++++++ extras/Hadrons/VirtualMachine.hpp | 22 +++- 8 files changed, 166 insertions(+), 13 deletions(-) diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index aa66d36f..135e4df4 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -92,9 +92,10 @@ void Application::run(void) { parseParameterFile(parameterFileName_); } - //vm().checkGraph(); - env().printContent(); vm().printContent(); + env().printContent(); + //vm().checkGraph(); + vm().memoryProfile(); if (!scheduled_) { schedule(); diff --git a/extras/Hadrons/Environment.cc b/extras/Hadrons/Environment.cc index 403476d0..6de13e86 100644 --- a/extras/Hadrons/Environment.cc +++ b/extras/Hadrons/Environment.cc @@ -369,6 +369,16 @@ void Environment::freeAll(void) } } +void Environment::protectObjects(const bool protect) +{ + protect_ = protect; +} + +bool Environment::objectsProtected(void) const +{ + return protect_; +} + // print environment content /////////////////////////////////////////////////// void Environment::printContent(void) const { @@ -376,6 +386,7 @@ void Environment::printContent(void) const for (unsigned int i = 0; i < object_.size(); ++i) { LOG(Debug) << std::setw(4) << i << ": " - << getObjectName(i) << std::endl; + << getObjectName(i) << " (" + << sizeString(getObjectSize(i)) << ")" << std::endl; } } diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index 60371c20..adea13ce 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -142,11 +142,14 @@ public: void freeObject(const unsigned int address); void freeObject(const std::string name); void freeAll(void); + void protectObjects(const bool protect); + bool objectsProtected(void) const; // print environment content void printContent(void) const; private: // general unsigned long int locVol_; + bool protect_{true}; // grids std::vector dim_; GridPt grid4d_; @@ -195,8 +198,8 @@ void Holder::reset(T *pt) // general memory management /////////////////////////////////////////////////// template void Environment::createDerivedObject(const std::string name, - const Environment::Storage storage, - const unsigned int Ls, + const Environment::Storage storage, + const unsigned int Ls, Ts && ... args) { if (!hasObject(name)) @@ -206,7 +209,7 @@ void Environment::createDerivedObject(const std::string name, unsigned int address = getObjectAddress(name); - if (!object_[address].data) + if (!object_[address].data or !objectsProtected()) { MemoryStats memStats; diff --git a/extras/Hadrons/Global.hpp b/extras/Hadrons/Global.hpp index c3d60bf2..ebfe94dc 100644 --- a/extras/Hadrons/Global.hpp +++ b/extras/Hadrons/Global.hpp @@ -36,7 +36,7 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #ifndef SITE_SIZE_TYPE -#define SITE_SIZE_TYPE unsigned int +#define SITE_SIZE_TYPE size_t #endif #define BEGIN_HADRONS_NAMESPACE \ diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index c6b58e9f..25c0ac05 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -160,12 +160,12 @@ public: // parse parameters virtual void parseParameters(XmlReader &reader, const std::string name) = 0; virtual void saveParameters(XmlWriter &writer, const std::string name) = 0; - // execution - void operator()(void); -protected: // setup virtual void setup(void) {}; virtual void execute(void) = 0; + // execution + void operator()(void); +protected: // environment shortcut DEFINE_ENV_ALIAS; // virtual machine shortcut diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 7d19feb8..3c179d44 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -134,7 +134,7 @@ std::vector TMeson::getReference(void) template std::vector TMeson::getOutput(void) { - std::vector output = {getName()}; + std::vector output = {}; return output; } diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 0c3eca20..15e53dbf 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -390,3 +390,123 @@ void VirtualMachine::printContent(void) const << getModuleName(i) << std::endl; } } + +// memory profile ////////////////////////////////////////////////////////////// +VirtualMachine::MemoryProfile VirtualMachine::memoryProfile(void) const +{ + bool protect = env().objectsProtected(); + bool hmsg = HadronsLogMessage.isActive(); + bool gmsg = GridLogMessage.isActive(); + bool err = HadronsLogError.isActive(); + MemoryProfile profile; + auto program = makeModuleGraph().topoSort(); + + profile.module.resize(getNModule()); + env().protectObjects(false); + GridLogMessage.Active(false); + HadronsLogMessage.Active(false); + HadronsLogError.Active(false); + for (auto it = program.rbegin(); it != program.rend(); ++it) + { + auto a = *it; + + if (profile.module[a].empty()) + { + LOG(Debug) << "Profiling memory for module '" << module_[a].name << "' (" << a << ")..." << std::endl; + memoryProfile(profile, a); + env().freeAll(); + } + } + env().protectObjects(protect); + GridLogMessage.Active(gmsg); + HadronsLogMessage.Active(hmsg); + HadronsLogError.Active(err); + LOG(Debug) << "Memory profile:" << std::endl; + LOG(Debug) << "----------------" << std::endl; + for (unsigned int a = 0; a < profile.module.size(); ++a) + { + LOG(Debug) << getModuleName(a) << " (" << a << ")" << std::endl; + for (auto &o: profile.module[a]) + { + LOG(Debug) << "|__ " << env().getObjectName(o.first) << " (" + << sizeString(o.second) << ")" << std::endl; + } + LOG(Debug) << std::endl; + } + LOG(Debug) << "----------------" << std::endl; + + return profile; +} + +void VirtualMachine::resizeProfile(MemoryProfile &profile) const +{ + if (env().getMaxAddress() > profile.object.size()) + { + MemoryPrint empty; + + empty.size = 0; + empty.module = -1; + profile.object.resize(env().getMaxAddress(), empty); + } +} + +void VirtualMachine::updateProfile(MemoryProfile &profile, + const unsigned int address) const +{ + resizeProfile(profile); + for (unsigned int a = 0; a < env().getMaxAddress(); ++a) + { + if (env().hasCreatedObject(a) and (profile.object[a].module == -1)) + { + profile.object[a].size = env().getObjectSize(a); + profile.object[a].module = address; + profile.module[address][a] = profile.object[a].size; + } + } +} + +void VirtualMachine::cleanEnvironment(MemoryProfile &profile) const +{ + resizeProfile(profile); + for (unsigned int a = 0; a < env().getMaxAddress(); ++a) + { + if (env().hasCreatedObject(a) and (profile.object[a].module == -1)) + { + env().freeObject(a); + } + } +} + +void VirtualMachine::memoryProfile(MemoryProfile &profile, + const unsigned int address) const +{ + auto m = getModule(address); + + LOG(Debug) << "Setting up module '" << m->getName() << "' (" << address << ")..." << std::endl; + + try + { + m->setup(); + updateProfile(profile, address); + } + catch (Exceptions::Definition &) + { + cleanEnvironment(profile); + for (auto &in: m->getInput()) + { + memoryProfile(profile, env().getObjectModule(in)); + } + for (auto &ref: m->getReference()) + { + memoryProfile(profile, env().getObjectModule(ref)); + } + m->setup(); + updateProfile(profile, address); + } +} + +void VirtualMachine::memoryProfile(MemoryProfile &profile, + const std::string name) const +{ + memoryProfile(profile, getModuleAddress(name)); +} diff --git a/extras/Hadrons/VirtualMachine.hpp b/extras/Hadrons/VirtualMachine.hpp index c5557add..56e5a8cf 100644 --- a/extras/Hadrons/VirtualMachine.hpp +++ b/extras/Hadrons/VirtualMachine.hpp @@ -51,8 +51,18 @@ class VirtualMachine { SINGLETON_DEFCTOR(VirtualMachine); public: - typedef SITE_SIZE_TYPE Size; - typedef std::unique_ptr ModPt; + typedef SITE_SIZE_TYPE Size; + typedef std::unique_ptr ModPt; + struct MemoryPrint + { + Size size; + unsigned int module; + }; + struct MemoryProfile + { + std::vector> module; + std::vector object; + }; private: struct ModuleInfo { @@ -100,12 +110,20 @@ public: void checkGraph(void) const; // print VM content void printContent(void) const; + // memory profile + MemoryProfile memoryProfile(void) const; // general execution Size executeProgram(const std::vector &p); Size executeProgram(const std::vector &p); private: // environment shortcut DEFINE_ENV_ALIAS; + // memory profile + void resizeProfile(MemoryProfile &profile) const; + void updateProfile(MemoryProfile &profile, const unsigned int address) const; + void cleanEnvironment(MemoryProfile &profile) const; + void memoryProfile(MemoryProfile &profile, const std::string name) const; + void memoryProfile(MemoryProfile &profile, const unsigned int address) const; private: // general bool dryRun_{false}, memoryProfile_{false}; From a9c8d7dad03f1b39acb5e081c3424d03ee035e07 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 13 Dec 2017 12:13:40 +0000 Subject: [PATCH 78/86] Hadrons: code cleaning --- extras/Hadrons/VirtualMachine.cc | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 15e53dbf..1f4772a6 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -79,21 +79,26 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) unsigned int address; ModuleInfo m; + // module registration ------------------------------------------------- m.data = std::move(pt); m.type = typeIdPt(*m.data.get()); m.name = name; + // input dependencies for (auto &in: m.data->getInput()) { if (!env().hasObject(in)) { + // if object does not exist, add it with no creator module env().addObject(in , -1); } m.input.push_back(env().getObjectAddress(in)); } + // reference dependencies for (auto &ref: m.data->getReference()) { if (!env().hasObject(ref)) { + // if object does not exist, add it with no creator module env().addObject(ref , -1); } m.input.push_back(env().getObjectAddress(ref)); @@ -101,20 +106,24 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) module_.push_back(std::move(m)); address = static_cast(module_.size() - 1); moduleAddress_[name] = address; + // connecting outputs to potential inputs ------------------------------ for (auto &out: getModule(address)->getOutput()) { if (!env().hasObject(out)) { + // output does not exists, add it env().addObject(out, address); } else { if (env().getObjectModule(env().getObjectAddress(out)) < 0) { + // output exists but without creator, correct it env().setObjectModule(env().getObjectAddress(out), address); } else { + // output already fully registered, error HADRON_ERROR(Definition, "object '" + out + "' is already produced by module '" + module_[env().getObjectModule(out)].name @@ -122,10 +131,14 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) } if (getModule(address)->getReference().size() > 0) { + // module has references, dependency should be propagated + // to children modules; find module with `out` as an input + // and add references to their input auto pred = [this, out](const ModuleInfo &n) { auto &in = n.input; - auto it = std::find(in.begin(), in.end(), env().getObjectAddress(out)); + auto it = std::find(in.begin(), in.end(), + env().getObjectAddress(out)); return (it != in.end()); }; @@ -154,7 +167,7 @@ unsigned int VirtualMachine::getNModule(void) const } void VirtualMachine::createModule(const std::string name, const std::string type, - XmlReader &reader) + XmlReader &reader) { auto &factory = ModuleFactory::getInstance(); auto pt = factory.create(type, name); @@ -267,17 +280,6 @@ Graph VirtualMachine::makeModuleGraph(void) const return moduleGraph; } -// void VirtualMachine::checkGraph(void) const -// { -// for (auto &o: object_) -// { -// if (o.module < 0) -// { -// HADRON_ERROR(Runtime, "object '" + o.name + "' does not have a creator"); -// } -// } -// } - // general execution /////////////////////////////////////////////////////////// #define BIG_SEP "===============" #define SEP "---------------" @@ -412,7 +414,8 @@ VirtualMachine::MemoryProfile VirtualMachine::memoryProfile(void) const if (profile.module[a].empty()) { - LOG(Debug) << "Profiling memory for module '" << module_[a].name << "' (" << a << ")..." << std::endl; + LOG(Debug) << "Profiling memory for module '" << module_[a].name + << "' (" << a << ")..." << std::endl; memoryProfile(profile, a); env().freeAll(); } From 61fc50d616674e198b503d177ed86adef0e2260b Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 13 Dec 2017 13:44:23 +0000 Subject: [PATCH 79/86] Hadrons: better organisation of the VM --- extras/Hadrons/Application.cc | 23 +- extras/Hadrons/Application.hpp | 2 - extras/Hadrons/Module.cc | 5 +- extras/Hadrons/VirtualMachine.cc | 403 +++++++++++++++--------------- extras/Hadrons/VirtualMachine.hpp | 47 ++-- 5 files changed, 236 insertions(+), 244 deletions(-) diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index 135e4df4..24618447 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -94,8 +94,6 @@ void Application::run(void) } vm().printContent(); env().printContent(); - //vm().checkGraph(); - vm().memoryProfile(); if (!scheduled_) { schedule(); @@ -185,11 +183,11 @@ GeneticScheduler::ObjFunc memPeak = \ void Application::schedule(void) { - DEFINE_MEMPEAK; + //DEFINE_MEMPEAK; // build module dependency graph LOG(Message) << "Building module graph..." << std::endl; - auto graph = vm().makeModuleGraph(); + auto graph = vm().getModuleGraph(); LOG(Debug) << "Module graph:" << std::endl; LOG(Debug) << graph << std::endl; auto con = graph.getConnectedComponents(); @@ -276,7 +274,7 @@ void Application::saveSchedule(const std::string filename) void Application::loadSchedule(const std::string filename) { - DEFINE_MEMPEAK; + //DEFINE_MEMPEAK; TextReader reader(filename); std::vector program; @@ -290,7 +288,7 @@ void Application::loadSchedule(const std::string filename) program_.push_back(vm().getModuleAddress(name)); } scheduled_ = true; - memPeak_ = memPeak(program_); + //memPeak_ = memPeak(program_); } void Application::printSchedule(void) @@ -323,16 +321,3 @@ void Application::configLoop(void) LOG(Message) << BIG_SEP << " End of measurement " << BIG_SEP << std::endl; env().freeAll(); } - -// memory profile ////////////////////////////////////////////////////////////// -void Application::memoryProfile(void) -{ - auto graph = vm().makeModuleGraph(); - auto program = graph.topoSort(); - bool msg; - - msg = HadronsLogMessage.isActive(); - HadronsLogMessage.Active(false); - - HadronsLogMessage.Active(msg); -} diff --git a/extras/Hadrons/Application.hpp b/extras/Hadrons/Application.hpp index 66488206..8d2537d0 100644 --- a/extras/Hadrons/Application.hpp +++ b/extras/Hadrons/Application.hpp @@ -102,8 +102,6 @@ private: DEFINE_ENV_ALIAS; // virtual machine shortcut DEFINE_VM_ALIAS; - // memory profile - void memoryProfile(void); private: long unsigned int locVol_; std::string parameterFileName_{""}; diff --git a/extras/Hadrons/Module.cc b/extras/Hadrons/Module.cc index 383a5c2e..e5ef0fe4 100644 --- a/extras/Hadrons/Module.cc +++ b/extras/Hadrons/Module.cc @@ -58,8 +58,5 @@ std::string ModuleBase::getRegisteredName(void) void ModuleBase::operator()(void) { setup(); - if (!vm().isDryRun()) - { - execute(); - } + execute(); } diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 1f4772a6..8667a51c 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -36,27 +36,6 @@ using namespace Hadrons; /****************************************************************************** * VirtualMachine implementation * ******************************************************************************/ -// dry run ///////////////////////////////////////////////////////////////////// -void VirtualMachine::dryRun(const bool isDry) -{ - dryRun_ = isDry; -} - -bool VirtualMachine::isDryRun(void) const -{ - return dryRun_; -} - -void VirtualMachine::memoryProfile(const bool doMemoryProfile) -{ - memoryProfile_ = doMemoryProfile; -} - -bool VirtualMachine::doMemoryProfile(void) const -{ - return memoryProfile_; -} - // trajectory counter ////////////////////////////////////////////////////////// void VirtualMachine::setTrajectory(const unsigned int traj) { @@ -259,40 +238,192 @@ bool VirtualMachine::hasModule(const std::string name) const return (moduleAddress_.find(name) != moduleAddress_.end()); } -Graph VirtualMachine::makeModuleGraph(void) const +// print VM content //////////////////////////////////////////////////////////// +void VirtualMachine::printContent(void) const { - Graph moduleGraph; + LOG(Debug) << "Modules: " << std::endl; + for (unsigned int i = 0; i < module_.size(); ++i) + { + LOG(Debug) << std::setw(4) << i << ": " + << getModuleName(i) << std::endl; + } +} + +// module graph //////////////////////////////////////////////////////////////// +Graph VirtualMachine::getModuleGraph(void) +{ + if (graphOutdated_) + { + makeModuleGraph(); + graphOutdated_ = false; + } + + return graph_; +} + +void VirtualMachine::makeModuleGraph(void) +{ + Graph graph; // create vertices for (unsigned int m = 0; m < module_.size(); ++m) { - moduleGraph.addVertex(m); + graph.addVertex(m); } // create edges for (unsigned int m = 0; m < module_.size(); ++m) { for (auto &in: module_[m].input) { - moduleGraph.addEdge(env().getObjectModule(in), m); + graph.addEdge(env().getObjectModule(in), m); } } - - return moduleGraph; + graph_ = graph; } -// general execution /////////////////////////////////////////////////////////// -#define BIG_SEP "===============" -#define SEP "---------------" -#define MEM_MSG(size) sizeString(size) - -VirtualMachine::Size -VirtualMachine::executeProgram(const std::vector &p) +// memory profile ////////////////////////////////////////////////////////////// +const VirtualMachine::MemoryProfile & VirtualMachine::getMemoryProfile(void) { - Size memPeak = 0, sizeBefore, sizeAfter; - std::vector> freeProg; + if (memoryProfileOutdated_) + { + makeMemoryProfile(); + memoryProfileOutdated_ = false; + } + + return profile_; +} + +void VirtualMachine::makeMemoryProfile(void) +{ + bool protect = env().objectsProtected(); + bool hmsg = HadronsLogMessage.isActive(); + bool gmsg = GridLogMessage.isActive(); + bool err = HadronsLogError.isActive(); + auto program = getModuleGraph().topoSort(); + + resetProfile(); + profile_.module.resize(getNModule()); + env().protectObjects(false); + GridLogMessage.Active(false); + HadronsLogMessage.Active(false); + HadronsLogError.Active(false); + for (auto it = program.rbegin(); it != program.rend(); ++it) + { + auto a = *it; + + if (profile_.module[a].empty()) + { + LOG(Debug) << "Profiling memory for module '" << module_[a].name + << "' (" << a << ")..." << std::endl; + memoryProfile(a); + env().freeAll(); + } + } + env().protectObjects(protect); + GridLogMessage.Active(gmsg); + HadronsLogMessage.Active(hmsg); + HadronsLogError.Active(err); + LOG(Debug) << "Memory profile:" << std::endl; + LOG(Debug) << "----------------" << std::endl; + for (unsigned int a = 0; a < profile_.module.size(); ++a) + { + LOG(Debug) << getModuleName(a) << " (" << a << ")" << std::endl; + for (auto &o: profile_.module[a]) + { + LOG(Debug) << "|__ " << env().getObjectName(o.first) << " (" + << sizeString(o.second) << ")" << std::endl; + } + LOG(Debug) << std::endl; + } + LOG(Debug) << "----------------" << std::endl; +} + +void VirtualMachine::resetProfile(void) +{ + profile_.module.clear(); + profile_.object.clear(); +} + +void VirtualMachine::resizeProfile(void) +{ + if (env().getMaxAddress() > profile_.object.size()) + { + MemoryPrint empty; + + empty.size = 0; + empty.module = -1; + profile_.object.resize(env().getMaxAddress(), empty); + } +} + +void VirtualMachine::updateProfile(const unsigned int address) +{ + resizeProfile(); + for (unsigned int a = 0; a < env().getMaxAddress(); ++a) + { + if (env().hasCreatedObject(a) and (profile_.object[a].module == -1)) + { + profile_.object[a].size = env().getObjectSize(a); + profile_.object[a].module = address; + profile_.module[address][a] = profile_.object[a].size; + if (env().getObjectModule(a) < 0) + { + env().setObjectModule(a, address); + } + } + } +} + +void VirtualMachine::cleanEnvironment(void) +{ + resizeProfile(); + for (unsigned int a = 0; a < env().getMaxAddress(); ++a) + { + if (env().hasCreatedObject(a) and (profile_.object[a].module == -1)) + { + env().freeObject(a); + } + } +} + +void VirtualMachine::memoryProfile(const unsigned int address) +{ + auto m = getModule(address); + + LOG(Debug) << "Setting up module '" << m->getName() + << "' (" << address << ")..." << std::endl; + try + { + m->setup(); + updateProfile(address); + } + catch (Exceptions::Definition &) + { + cleanEnvironment(); + for (auto &in: m->getInput()) + { + memoryProfile(env().getObjectModule(in)); + } + for (auto &ref: m->getReference()) + { + memoryProfile(env().getObjectModule(ref)); + } + m->setup(); + updateProfile(address); + } +} + +void VirtualMachine::memoryProfile(const std::string name) +{ + memoryProfile(getModuleAddress(name)); +} + +// garbage collector /////////////////////////////////////////////////////////// +VirtualMachine::GarbageSchedule +VirtualMachine::makeGarbageSchedule(const std::vector &p) const +{ + GarbageSchedule freeProg; - // build garbage collection schedule - LOG(Debug) << "Building garbage collection schedule..." << std::endl; freeProg.resize(p.size()); for (unsigned int i = 0; i < env().getMaxAddress(); ++i) { @@ -310,34 +441,42 @@ VirtualMachine::executeProgram(const std::vector &p) } } + return freeProg; +} + +// general execution /////////////////////////////////////////////////////////// +#define BIG_SEP "===============" +#define SEP "---------------" +#define MEM_MSG(size) sizeString(size) + +void VirtualMachine::executeProgram(const std::vector &p) const +{ + Size memPeak = 0, sizeBefore, sizeAfter; + GarbageSchedule freeProg; + + // build garbage collection schedule + LOG(Debug) << "Building garbage collection schedule..." << std::endl; + freeProg = makeGarbageSchedule(p); + // program execution LOG(Debug) << "Executing program..." << std::endl; for (unsigned int i = 0; i < p.size(); ++i) { // execute module - if (!isDryRun()) - { - LOG(Message) << SEP << " Measurement step " << i+1 << "/" - << p.size() << " (module '" << module_[p[i]].name - << "') " << SEP << std::endl; - } + LOG(Message) << SEP << " Measurement step " << i + 1 << "/" + << p.size() << " (module '" << module_[p[i]].name + << "') " << SEP << std::endl; (*module_[p[i]].data)(); sizeBefore = env().getTotalSize(); // print used memory after execution - if (!isDryRun()) - { - LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore) - << std::endl; - } + LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore) + << std::endl; if (sizeBefore > memPeak) { memPeak = sizeBefore; } // garbage collection for step i - if (!isDryRun()) - { - LOG(Message) << "Garbage collection..." << std::endl; - } + LOG(Message) << "Garbage collection..." << std::endl; for (auto &j: freeProg[i]) { env().freeObject(j); @@ -352,25 +491,20 @@ VirtualMachine::executeProgram(const std::vector &p) } } // print used memory after garbage collection if necessary - if (!isDryRun()) + sizeAfter = env().getTotalSize(); + if (sizeBefore != sizeAfter) { - sizeAfter = env().getTotalSize(); - if (sizeBefore != sizeAfter) - { - LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter) - << std::endl; - } - else - { - LOG(Message) << "Nothing to free" << std::endl; - } + LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter) + << std::endl; + } + else + { + LOG(Message) << "Nothing to free" << std::endl; } } - - return memPeak; } -VirtualMachine::Size VirtualMachine::executeProgram(const std::vector &p) +void VirtualMachine::executeProgram(const std::vector &p) const { std::vector pAddress; @@ -378,138 +512,5 @@ VirtualMachine::Size VirtualMachine::executeProgram(const std::vector profile.object.size()) - { - MemoryPrint empty; - - empty.size = 0; - empty.module = -1; - profile.object.resize(env().getMaxAddress(), empty); - } -} - -void VirtualMachine::updateProfile(MemoryProfile &profile, - const unsigned int address) const -{ - resizeProfile(profile); - for (unsigned int a = 0; a < env().getMaxAddress(); ++a) - { - if (env().hasCreatedObject(a) and (profile.object[a].module == -1)) - { - profile.object[a].size = env().getObjectSize(a); - profile.object[a].module = address; - profile.module[address][a] = profile.object[a].size; - } - } -} - -void VirtualMachine::cleanEnvironment(MemoryProfile &profile) const -{ - resizeProfile(profile); - for (unsigned int a = 0; a < env().getMaxAddress(); ++a) - { - if (env().hasCreatedObject(a) and (profile.object[a].module == -1)) - { - env().freeObject(a); - } - } -} - -void VirtualMachine::memoryProfile(MemoryProfile &profile, - const unsigned int address) const -{ - auto m = getModule(address); - - LOG(Debug) << "Setting up module '" << m->getName() << "' (" << address << ")..." << std::endl; - - try - { - m->setup(); - updateProfile(profile, address); - } - catch (Exceptions::Definition &) - { - cleanEnvironment(profile); - for (auto &in: m->getInput()) - { - memoryProfile(profile, env().getObjectModule(in)); - } - for (auto &ref: m->getReference()) - { - memoryProfile(profile, env().getObjectModule(ref)); - } - m->setup(); - updateProfile(profile, address); - } -} - -void VirtualMachine::memoryProfile(MemoryProfile &profile, - const std::string name) const -{ - memoryProfile(profile, getModuleAddress(name)); + executeProgram(pAddress); } diff --git a/extras/Hadrons/VirtualMachine.hpp b/extras/Hadrons/VirtualMachine.hpp index 56e5a8cf..88e70b55 100644 --- a/extras/Hadrons/VirtualMachine.hpp +++ b/extras/Hadrons/VirtualMachine.hpp @@ -51,8 +51,9 @@ class VirtualMachine { SINGLETON_DEFCTOR(VirtualMachine); public: - typedef SITE_SIZE_TYPE Size; - typedef std::unique_ptr ModPt; + typedef SITE_SIZE_TYPE Size; + typedef std::unique_ptr ModPt; + typedef std::vector> GarbageSchedule; struct MemoryPrint { Size size; @@ -73,11 +74,6 @@ private: size_t maxAllocated; }; public: - // dry run - void dryRun(const bool isDry); - bool isDryRun(void) const; - void memoryProfile(const bool doMemoryProfile); - bool doMemoryProfile(void) const; // trajectory counter void setTrajectory(const unsigned int traj); unsigned int getTrajectory(void) const; @@ -106,32 +102,47 @@ public: std::string getModuleNamespace(const std::string name) const; bool hasModule(const unsigned int address) const; bool hasModule(const std::string name) const; - Graph makeModuleGraph(void) const; - void checkGraph(void) const; // print VM content void printContent(void) const; + // module graph (could be a const reference if topoSort was const) + Graph getModuleGraph(void); // memory profile - MemoryProfile memoryProfile(void) const; + const MemoryProfile &getMemoryProfile(void); + // garbage collector + GarbageSchedule makeGarbageSchedule(const std::vector &p) const; + // high-water memory function + Size memoryNeeded(const std::vector &p, + const GarbageSchedule &g); + Size memoryNeeded(const std::vector &p); // general execution - Size executeProgram(const std::vector &p); - Size executeProgram(const std::vector &p); + void executeProgram(const std::vector &p) const; + void executeProgram(const std::vector &p) const; private: // environment shortcut DEFINE_ENV_ALIAS; + // module graph + void makeModuleGraph(void); // memory profile - void resizeProfile(MemoryProfile &profile) const; - void updateProfile(MemoryProfile &profile, const unsigned int address) const; - void cleanEnvironment(MemoryProfile &profile) const; - void memoryProfile(MemoryProfile &profile, const std::string name) const; - void memoryProfile(MemoryProfile &profile, const unsigned int address) const; + void makeMemoryProfile(void); + void resetProfile(void); + void resizeProfile(void); + void updateProfile(const unsigned int address); + void cleanEnvironment(void); + void memoryProfile(const std::string name); + void memoryProfile(const unsigned int address); private: // general - bool dryRun_{false}, memoryProfile_{false}; unsigned int traj_; // module and related maps std::vector module_; std::map moduleAddress_; std::string currentModule_{""}; + // module graph + bool graphOutdated_{true}; + Graph graph_; + // memory profile + bool memoryProfileOutdated_{true}; + MemoryProfile profile_; }; /****************************************************************************** From 0887566134b7cd7b1a4fb3af69180c0dd9dbed91 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 13 Dec 2017 16:36:15 +0000 Subject: [PATCH 80/86] Hadrons: scheduler back! --- extras/Hadrons/Application.cc | 110 +++-------------------- extras/Hadrons/Application.hpp | 31 +++---- extras/Hadrons/GeneticScheduler.hpp | 66 +++++++------- extras/Hadrons/VirtualMachine.cc | 134 +++++++++++++++++++++++----- extras/Hadrons/VirtualMachine.hpp | 34 ++++--- 5 files changed, 189 insertions(+), 186 deletions(-) diff --git a/extras/Hadrons/Application.cc b/extras/Hadrons/Application.cc index 24618447..9a3366d4 100644 --- a/extras/Hadrons/Application.cc +++ b/extras/Hadrons/Application.cc @@ -94,10 +94,7 @@ void Application::run(void) } vm().printContent(); env().printContent(); - if (!scheduled_) - { - schedule(); - } + schedule(); printSchedule(); configLoop(); } @@ -122,11 +119,13 @@ void Application::parseParameterFile(const std::string parameterFileName) setPar(par); if (!push(reader, "modules")) { - HADRON_ERROR(Parsing, "Cannot open node 'modules' in parameter file '" + parameterFileName + "'"); + HADRON_ERROR(Parsing, "Cannot open node 'modules' in parameter file '" + + parameterFileName + "'"); } if (!push(reader, "module")) { - HADRON_ERROR(Parsing, "Cannot open node 'modules/module' in parameter file '" + parameterFileName + "'"); + HADRON_ERROR(Parsing, "Cannot open node 'modules/module' in parameter file '" + + parameterFileName + "'"); } do { @@ -160,98 +159,13 @@ void Application::saveParameterFile(const std::string parameterFileName) } // schedule computation //////////////////////////////////////////////////////// -#define MEM_MSG(size)\ -sizeString((size)*locVol_) << " (" << sizeString(size) << "/site)" - -#define DEFINE_MEMPEAK \ -GeneticScheduler::ObjFunc memPeak = \ -[this](const std::vector &program)\ -{\ - unsigned int memPeak;\ - bool msg;\ - \ - msg = HadronsLogMessage.isActive();\ - HadronsLogMessage.Active(false);\ - vm().dryRun(true);\ - memPeak = vm().executeProgram(program);\ - vm().dryRun(false);\ - env().freeAll();\ - HadronsLogMessage.Active(msg);\ - \ - return memPeak;\ -} - void Application::schedule(void) { - //DEFINE_MEMPEAK; - - // build module dependency graph - LOG(Message) << "Building module graph..." << std::endl; - auto graph = vm().getModuleGraph(); - LOG(Debug) << "Module graph:" << std::endl; - LOG(Debug) << graph << std::endl; - auto con = graph.getConnectedComponents(); - - // constrained topological sort using a genetic algorithm - // LOG(Message) << "Scheduling computation..." << std::endl; - // LOG(Message) << " #module= " << graph.size() << std::endl; - // LOG(Message) << " population size= " << par_.genetic.popSize << std::endl; - // LOG(Message) << " max. generation= " << par_.genetic.maxGen << std::endl; - // LOG(Message) << " max. cst. generation= " << par_.genetic.maxCstGen << std::endl; - // LOG(Message) << " mutation rate= " << par_.genetic.mutationRate << std::endl; - - // unsigned int k = 0, gen, prevPeak, nCstPeak = 0; - // std::random_device rd; - // GeneticScheduler::Parameters par; - - // par.popSize = par_.genetic.popSize; - // par.mutationRate = par_.genetic.mutationRate; - // par.seed = rd(); - // memPeak_ = 0; - // CartesianCommunicator::BroadcastWorld(0, &(par.seed), sizeof(par.seed)); - for (unsigned int i = 0; i < con.size(); ++i) + if (!scheduled_ and !loadedSchedule_) { - // GeneticScheduler scheduler(con[i], memPeak, par); - - // gen = 0; - // do - // { - // LOG(Debug) << "Generation " << gen << ":" << std::endl; - // scheduler.nextGeneration(); - // if (gen != 0) - // { - // if (prevPeak == scheduler.getMinValue()) - // { - // nCstPeak++; - // } - // else - // { - // nCstPeak = 0; - // } - // } - - // prevPeak = scheduler.getMinValue(); - // if (gen % 10 == 0) - // { - // LOG(Iterative) << "Generation " << gen << ": " - // << MEM_MSG(scheduler.getMinValue()) << std::endl; - // } - - // gen++; - // } while ((gen < par_.genetic.maxGen) - // and (nCstPeak < par_.genetic.maxCstGen)); - // auto &t = scheduler.getMinSchedule(); - // if (scheduler.getMinValue() > memPeak_) - // { - // memPeak_ = scheduler.getMinValue(); - // } - auto t = con[i].topoSort(); - for (unsigned int j = 0; j < t.size(); ++j) - { - program_.push_back(t[j]); - } + program_ = vm().schedule(par_.genetic); + scheduled_ = true; } - scheduled_ = true; } void Application::saveSchedule(const std::string filename) @@ -274,8 +188,6 @@ void Application::saveSchedule(const std::string filename) void Application::loadSchedule(const std::string filename) { - //DEFINE_MEMPEAK; - TextReader reader(filename); std::vector program; @@ -287,8 +199,7 @@ void Application::loadSchedule(const std::string filename) { program_.push_back(vm().getModuleAddress(name)); } - scheduled_ = true; - //memPeak_ = memPeak(program_); + loadedSchedule_ = true; } void Application::printSchedule(void) @@ -297,7 +208,8 @@ void Application::printSchedule(void) { HADRON_ERROR(Definition, "Computation not scheduled"); } - LOG(Message) << "Schedule (memory peak: " << MEM_MSG(memPeak_) << "):" + auto peak = vm().memoryNeeded(program_); + LOG(Message) << "Schedule (memory needed: " << sizeString(peak) << "):" << std::endl; for (unsigned int i = 0; i < program_.size(); ++i) { diff --git a/extras/Hadrons/Application.hpp b/extras/Hadrons/Application.hpp index 8d2537d0..4b2ce77b 100644 --- a/extras/Hadrons/Application.hpp +++ b/extras/Hadrons/Application.hpp @@ -50,25 +50,13 @@ public: unsigned int, end, unsigned int, step); }; - class GeneticPar: Serializable - { - public: - GeneticPar(void): - popSize{20}, maxGen{1000}, maxCstGen{100}, mutationRate{.1} {}; - public: - GRID_SERIALIZABLE_CLASS_MEMBERS(GeneticPar, - unsigned int, popSize, - unsigned int, maxGen, - unsigned int, maxCstGen, - double , mutationRate); - }; class GlobalPar: Serializable { public: GRID_SERIALIZABLE_CLASS_MEMBERS(GlobalPar, - TrajRange, trajCounter, - GeneticPar, genetic, - std::string, seed); + TrajRange, trajCounter, + VirtualMachine::GeneticPar, genetic, + std::string, seed); }; public: // constructors @@ -103,12 +91,11 @@ private: // virtual machine shortcut DEFINE_VM_ALIAS; private: - long unsigned int locVol_; - std::string parameterFileName_{""}; - GlobalPar par_; - std::vector program_; - Environment::Size memPeak_; - bool scheduled_{false}; + long unsigned int locVol_; + std::string parameterFileName_{""}; + GlobalPar par_; + VirtualMachine::Program program_; + bool scheduled_{false}, loadedSchedule_{false}; }; /****************************************************************************** @@ -119,6 +106,7 @@ template void Application::createModule(const std::string name) { vm().createModule(name); + scheduled_ = false; } template @@ -126,6 +114,7 @@ void Application::createModule(const std::string name, const typename M::Par &par) { vm().createModule(name, par); + scheduled_ = false; } END_HADRONS_NAMESPACE diff --git a/extras/Hadrons/GeneticScheduler.hpp b/extras/Hadrons/GeneticScheduler.hpp index 3b0195e7..f199f1ed 100644 --- a/extras/Hadrons/GeneticScheduler.hpp +++ b/extras/Hadrons/GeneticScheduler.hpp @@ -38,13 +38,13 @@ BEGIN_HADRONS_NAMESPACE /****************************************************************************** * Scheduler based on a genetic algorithm * ******************************************************************************/ -template +template class GeneticScheduler { public: - typedef std::vector Gene; - typedef std::pair GenePair; - typedef std::function ObjFunc; + typedef std::vector Gene; + typedef std::pair GenePair; + typedef std::function ObjFunc; struct Parameters { double mutationRate; @@ -65,7 +65,7 @@ public: void benchmarkCrossover(const unsigned int nIt); // print population friend std::ostream & operator<<(std::ostream &out, - const GeneticScheduler &s) + const GeneticScheduler &s) { out << "["; for (auto &p: s.population_) @@ -87,19 +87,19 @@ private: void mutation(Gene &m, const Gene &c); private: - Graph &graph_; - const ObjFunc &func_; - const Parameters par_; - std::multimap population_; - std::mt19937 gen_; + Graph &graph_; + const ObjFunc &func_; + const Parameters par_; + std::multimap population_; + std::mt19937 gen_; }; /****************************************************************************** * template implementation * ******************************************************************************/ // constructor ///////////////////////////////////////////////////////////////// -template -GeneticScheduler::GeneticScheduler(Graph &graph, const ObjFunc &func, +template +GeneticScheduler::GeneticScheduler(Graph &graph, const ObjFunc &func, const Parameters &par) : graph_(graph) , func_(func) @@ -109,22 +109,22 @@ GeneticScheduler::GeneticScheduler(Graph &graph, const ObjFunc &func, } // access ////////////////////////////////////////////////////////////////////// -template -const typename GeneticScheduler::Gene & -GeneticScheduler::getMinSchedule(void) +template +const typename GeneticScheduler::Gene & +GeneticScheduler::getMinSchedule(void) { return population_.begin()->second; } -template -int GeneticScheduler::getMinValue(void) +template +int GeneticScheduler::getMinValue(void) { return population_.begin()->first; } // breed a new generation ////////////////////////////////////////////////////// -template -void GeneticScheduler::nextGeneration(void) +template +void GeneticScheduler::nextGeneration(void) { // random initialization of the population if necessary if (population_.size() != par_.popSize) @@ -158,8 +158,8 @@ void GeneticScheduler::nextGeneration(void) } // evolution steps ///////////////////////////////////////////////////////////// -template -void GeneticScheduler::initPopulation(void) +template +void GeneticScheduler::initPopulation(void) { population_.clear(); for (unsigned int i = 0; i < par_.popSize; ++i) @@ -170,8 +170,8 @@ void GeneticScheduler::initPopulation(void) } } -template -void GeneticScheduler::doCrossover(void) +template +void GeneticScheduler::doCrossover(void) { auto p = selectPair(); Gene &p1 = *(p.first), &p2 = *(p.second); @@ -185,8 +185,8 @@ void GeneticScheduler::doCrossover(void) } } -template -void GeneticScheduler::doMutation(void) +template +void GeneticScheduler::doMutation(void) { std::uniform_real_distribution mdis(0., 1.); std::uniform_int_distribution pdis(0, population_.size() - 1); @@ -206,8 +206,8 @@ void GeneticScheduler::doMutation(void) } // genetic operators /////////////////////////////////////////////////////////// -template -typename GeneticScheduler::GenePair GeneticScheduler::selectPair(void) +template +typename GeneticScheduler::GenePair GeneticScheduler::selectPair(void) { std::vector prob; unsigned int ind; @@ -233,8 +233,8 @@ typename GeneticScheduler::GenePair GeneticScheduler::selectPair(void) return std::make_pair(p1, p2); } -template -void GeneticScheduler::crossover(Gene &c1, Gene &c2, const Gene &p1, +template +void GeneticScheduler::crossover(Gene &c1, Gene &c2, const Gene &p1, const Gene &p2) { Gene buf; @@ -268,8 +268,8 @@ void GeneticScheduler::crossover(Gene &c1, Gene &c2, const Gene &p1, } } -template -void GeneticScheduler::mutation(Gene &m, const Gene &c) +template +void GeneticScheduler::mutation(Gene &m, const Gene &c) { Gene buf; std::uniform_int_distribution dis(0, c.size() - 1); @@ -298,8 +298,8 @@ void GeneticScheduler::mutation(Gene &m, const Gene &c) } } -template -void GeneticScheduler::benchmarkCrossover(const unsigned int nIt) +template +void GeneticScheduler::benchmarkCrossover(const unsigned int nIt) { Gene p1, p2, c1, c2; double neg = 0., eq = 0., pos = 0., total; diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 8667a51c..8a6bd149 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -27,6 +27,7 @@ See the full license in the file "LICENSE" in the top level distribution directo /* END LEGAL */ #include +#include #include using namespace Grid; @@ -133,6 +134,8 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) } } } + graphOutdated_ = true; + memoryProfileOutdated_ = true; } else { @@ -364,6 +367,7 @@ void VirtualMachine::updateProfile(const unsigned int address) if (env().hasCreatedObject(a) and (profile_.object[a].module == -1)) { profile_.object[a].size = env().getObjectSize(a); + profile_.object[a].storage = env().getObjectStorage(a); profile_.object[a].module = address; profile_.module[address][a] = profile_.object[a].size; if (env().getObjectModule(a) < 0) @@ -419,37 +423,130 @@ void VirtualMachine::memoryProfile(const std::string name) } // garbage collector /////////////////////////////////////////////////////////// -VirtualMachine::GarbageSchedule -VirtualMachine::makeGarbageSchedule(const std::vector &p) const +VirtualMachine::GarbageSchedule +VirtualMachine::makeGarbageSchedule(const Program &p) const { GarbageSchedule freeProg; freeProg.resize(p.size()); - for (unsigned int i = 0; i < env().getMaxAddress(); ++i) + for (unsigned int a = 0; a < env().getMaxAddress(); ++a) { - auto pred = [i, this](const unsigned int j) + if (env().getObjectStorage(a) == Environment::Storage::temporary) { - auto &in = module_[j].input; - auto it = std::find(in.begin(), in.end(), i); - - return (it != in.end()) or (j == env().getObjectModule(i)); - }; - auto it = std::find_if(p.rbegin(), p.rend(), pred); - if (it != p.rend()) + auto it = std::find(p.begin(), p.end(), env().getObjectModule(a)); + + if (it != p.end()) + { + freeProg[std::distance(p.begin(), it)].insert(a); + } + } + else if (env().getObjectStorage(a) == Environment::Storage::object) { - freeProg[std::distance(it, p.rend()) - 1].insert(i); + auto pred = [a, this](const unsigned int b) + { + auto &in = module_[b].input; + auto it = std::find(in.begin(), in.end(), a); + + return (it != in.end()) or (b == env().getObjectModule(a)); + }; + auto it = std::find_if(p.rbegin(), p.rend(), pred); + if (it != p.rend()) + { + freeProg[std::distance(it, p.rend()) - 1].insert(a); + } } } return freeProg; } +// high-water memory function ////////////////////////////////////////////////// +VirtualMachine::Size VirtualMachine::memoryNeeded(const Program &p) +{ + const MemoryProfile &profile = getMemoryProfile(); + GarbageSchedule freep = makeGarbageSchedule(p); + Size current = 0, max = 0; + + for (unsigned int i = 0; i < p.size(); ++i) + { + for (auto &o: profile.module[p[i]]) + { + current += o.second; + } + max = std::max(current, max); + for (auto &o: freep[i]) + { + current -= profile.object[o].size; + } + } + + return max; +} + +// genetic scheduler /////////////////////////////////////////////////////////// +VirtualMachine::Program VirtualMachine::schedule(const GeneticPar &par) +{ + typedef GeneticScheduler Scheduler; + + auto graph = getModuleGraph(); + + //constrained topological sort using a genetic algorithm + LOG(Message) << "Scheduling computation..." << std::endl; + LOG(Message) << " #module= " << graph.size() << std::endl; + LOG(Message) << " population size= " << par.popSize << std::endl; + LOG(Message) << " max. generation= " << par.maxGen << std::endl; + LOG(Message) << " max. cst. generation= " << par.maxCstGen << std::endl; + LOG(Message) << " mutation rate= " << par.mutationRate << std::endl; + + unsigned int k = 0, gen, prevPeak, nCstPeak = 0; + std::random_device rd; + Scheduler::Parameters gpar; + + gpar.popSize = par.popSize; + gpar.mutationRate = par.mutationRate; + gpar.seed = rd(); + CartesianCommunicator::BroadcastWorld(0, &(gpar.seed), sizeof(gpar.seed)); + Scheduler::ObjFunc memPeak = [this](const Program &p)->Size + { + return memoryNeeded(p); + }; + Scheduler scheduler(graph, memPeak, gpar); + gen = 0; + do + { + LOG(Debug) << "Generation " << gen << ":" << std::endl; + scheduler.nextGeneration(); + if (gen != 0) + { + if (prevPeak == scheduler.getMinValue()) + { + nCstPeak++; + } + else + { + nCstPeak = 0; + } + } + + prevPeak = scheduler.getMinValue(); + if (gen % 10 == 0) + { + LOG(Iterative) << "Generation " << gen << ": " + << sizeString(scheduler.getMinValue()) << std::endl; + } + + gen++; + } while ((gen < par.maxGen) and (nCstPeak < par.maxCstGen)); + + return scheduler.getMinSchedule(); +} + // general execution /////////////////////////////////////////////////////////// #define BIG_SEP "===============" #define SEP "---------------" #define MEM_MSG(size) sizeString(size) -void VirtualMachine::executeProgram(const std::vector &p) const +void VirtualMachine::executeProgram(const Program &p) const { Size memPeak = 0, sizeBefore, sizeAfter; GarbageSchedule freeProg; @@ -481,15 +578,6 @@ void VirtualMachine::executeProgram(const std::vector &p) const { env().freeObject(j); } - // free temporaries - for (unsigned int i = 0; i < env().getMaxAddress(); ++i) - { - if ((env().getObjectStorage(i) == Environment::Storage::temporary) - and env().hasCreatedObject(i)) - { - env().freeObject(i); - } - } // print used memory after garbage collection if necessary sizeAfter = env().getTotalSize(); if (sizeBefore != sizeAfter) @@ -506,7 +594,7 @@ void VirtualMachine::executeProgram(const std::vector &p) const void VirtualMachine::executeProgram(const std::vector &p) const { - std::vector pAddress; + Program pAddress; for (auto &n: p) { diff --git a/extras/Hadrons/VirtualMachine.hpp b/extras/Hadrons/VirtualMachine.hpp index 88e70b55..a411c108 100644 --- a/extras/Hadrons/VirtualMachine.hpp +++ b/extras/Hadrons/VirtualMachine.hpp @@ -51,19 +51,33 @@ class VirtualMachine { SINGLETON_DEFCTOR(VirtualMachine); public: - typedef SITE_SIZE_TYPE Size; - typedef std::unique_ptr ModPt; - typedef std::vector> GarbageSchedule; + typedef SITE_SIZE_TYPE Size; + typedef std::unique_ptr ModPt; + typedef std::vector> GarbageSchedule; + typedef std::vector Program; struct MemoryPrint { - Size size; - unsigned int module; + Size size; + Environment::Storage storage; + unsigned int module; }; struct MemoryProfile { std::vector> module; std::vector object; }; + class GeneticPar: Serializable + { + public: + GeneticPar(void): + popSize{20}, maxGen{1000}, maxCstGen{100}, mutationRate{.1} {}; + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(GeneticPar, + unsigned int, popSize, + unsigned int, maxGen, + unsigned int, maxCstGen, + double , mutationRate); + }; private: struct ModuleInfo { @@ -109,13 +123,13 @@ public: // memory profile const MemoryProfile &getMemoryProfile(void); // garbage collector - GarbageSchedule makeGarbageSchedule(const std::vector &p) const; + GarbageSchedule makeGarbageSchedule(const Program &p) const; // high-water memory function - Size memoryNeeded(const std::vector &p, - const GarbageSchedule &g); - Size memoryNeeded(const std::vector &p); + Size memoryNeeded(const Program &p); + // genetic scheduler + Program schedule(const GeneticPar &par); // general execution - void executeProgram(const std::vector &p) const; + void executeProgram(const Program &p) const; void executeProgram(const std::vector &p) const; private: // environment shortcut From 842754bea9f8c4ba42c9295854342c6857f061bf Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Wed, 13 Dec 2017 19:41:41 +0000 Subject: [PATCH 81/86] Hadrons: most modules ported to the new interface, compiles but untested --- extras/Hadrons/Module.hpp | 4 +- extras/Hadrons/Modules.hpp | 38 +++++------ extras/Hadrons/Modules/MAction/DWF.hpp | 11 ++-- extras/Hadrons/Modules/MAction/Wilson.hpp | 1 + .../Hadrons/Modules/MContraction/Baryon.hpp | 32 +++++++--- .../Hadrons/Modules/MContraction/DiscLoop.hpp | 17 +++-- .../Hadrons/Modules/MContraction/Gamma3pt.hpp | 21 +++++-- extras/Hadrons/Modules/MContraction/Meson.hpp | 11 ++-- .../Modules/MContraction/WardIdentity.hpp | 36 ++++++++--- .../Modules/MContraction/WeakHamiltonian.hpp | 1 + .../MContraction/WeakHamiltonianEye.cc | 41 ++++++++---- .../MContraction/WeakHamiltonianNonEye.cc | 44 ++++++++----- .../MContraction/WeakNeutral4ptDisc.cc | 39 ++++++++---- extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 16 ++--- extras/Hadrons/Modules/MGauge/Load.cc | 19 ++++-- extras/Hadrons/Modules/MGauge/Load.hpp | 1 + extras/Hadrons/Modules/MGauge/Random.cc | 16 ++++- extras/Hadrons/Modules/MGauge/Random.hpp | 1 + extras/Hadrons/Modules/MGauge/StochEm.cc | 29 +++++---- extras/Hadrons/Modules/MGauge/StochEm.hpp | 1 + extras/Hadrons/Modules/MGauge/Unit.cc | 1 + extras/Hadrons/Modules/MLoop/NoiseLoop.hpp | 18 ++++-- extras/Hadrons/Modules/MSink/Point.hpp | 13 ++-- extras/Hadrons/Modules/MSink/Smear.hpp | 23 ++++--- extras/Hadrons/Modules/MSource/Point.hpp | 11 ++-- .../Hadrons/Modules/MSource/SeqConserved.hpp | 17 +++-- extras/Hadrons/Modules/MSource/SeqGamma.hpp | 53 +++++++++++----- extras/Hadrons/Modules/MSource/Wall.hpp | 49 ++++++++++----- extras/Hadrons/Modules/MSource/Z2.hpp | 38 ++++++++--- .../Modules/MUtilities/TestSeqConserved.hpp | 44 ++++++++----- .../Modules/MUtilities/TestSeqGamma.hpp | 28 ++++++--- extras/Hadrons/modules.inc | 63 +++++++++---------- tests/hadrons/Test_hadrons.hpp | 40 ++++++------ 33 files changed, 504 insertions(+), 273 deletions(-) diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index 25c0ac05..390573d8 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -92,8 +92,8 @@ static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance; #define envGet(type, name)\ *env().template getObject(name) -#define envGetTmp(type, name)\ -*env().template getObject(getName() + "_tmp_" + name) +#define envGetTmp(type, var)\ +type &var = *env().template getObject(getName() + "_tmp_" + #var) #define envHasType(type, name)\ env().template isObjectOfType(name) diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index bb574a14..61a20058 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -30,31 +30,31 @@ See the full license in the file "LICENSE" in the top level distribution directo #include #include -// #include -// #include -// #include +#include +#include +#include #include -// #include -// #include -// #include -// #include -// #include +#include +#include +#include +#include +#include #include -// #include -// #include -// #include +#include +#include +#include #include -// #include +#include // #include // #include // #include #include -// #include +#include #include #include -// #include -// #include -// #include -// #include -// #include -// #include +#include +#include +#include +#include +#include +#include diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index 91e4ec94..0cb9a4cb 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -119,12 +119,13 @@ void TDWF::setup(void) << std::endl; LOG(Message) << "Fermion boundary conditions: " << par().boundary << std::endl; + env().createGrid(par().Ls); - auto &U = envGet(LatticeGaugeField, par().gauge); - auto &g4 = *env().getGrid(); - auto &grb4 = *env().getRbGrid(); - auto &g5 = *env().getGrid(par().Ls); - auto &grb5 = *env().getRbGrid(par().Ls); + auto &U = envGet(LatticeGaugeField, par().gauge); + auto &g4 = *env().getGrid(); + auto &grb4 = *env().getRbGrid(); + auto &g5 = *env().getGrid(par().Ls); + auto &grb5 = *env().getRbGrid(par().Ls); std::vector boundary = strToVec(par().boundary); typename DomainWallFermion::ImplParams implParams(boundary); envCreateDerived(FMat, DomainWallFermion, getName(), par().Ls, U, g5, diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index 1ca3bf59..a6b3f0d6 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -115,6 +115,7 @@ void TWilson::setup(void) << " using gauge field '" << par().gauge << "'" << std::endl; LOG(Message) << "Fermion boundary conditions: " << par().boundary << std::endl; + auto &U = envGet(LatticeGaugeField, par().gauge); auto &grid = *env().getGrid(); auto &gridRb = *env().getRbGrid(); diff --git a/extras/Hadrons/Modules/MContraction/Baryon.hpp b/extras/Hadrons/Modules/MContraction/Baryon.hpp index da927391..28f6aa51 100644 --- a/extras/Hadrons/Modules/MContraction/Baryon.hpp +++ b/extras/Hadrons/Modules/MContraction/Baryon.hpp @@ -71,8 +71,11 @@ public: virtual ~TBaryon(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: + // setup + virtual void setup(void); // execution virtual void execute(void); }; @@ -97,14 +100,29 @@ std::vector TBaryon::getInput(void) return input; } +template +std::vector TBaryon::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TBaryon::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } +// setup /////////////////////////////////////////////////////////////////////// +template +void TBaryon::setup(void) +{ + envTmpLat(LatticeComplex, "c"); +} + // execution /////////////////////////////////////////////////////////////////// template void TBaryon::execute(void) @@ -113,12 +131,12 @@ void TBaryon::execute(void) << " quarks '" << par().q1 << "', '" << par().q2 << "', and '" << par().q3 << "'" << std::endl; - CorrWriter writer(par().output); - PropagatorField1 &q1 = *env().template getObject(par().q1); - PropagatorField2 &q2 = *env().template getObject(par().q2); - PropagatorField3 &q3 = *env().template getObject(par().q2); - LatticeComplex c(env().getGrid()); - Result result; + CorrWriter writer(par().output); + auto &q1 = envGet(PropagatorField1, par().q1); + auto &q2 = envGet(PropagatorField2, par().q2); + auto &q3 = envGet(PropagatorField3, par().q2); + envGetTmp(LatticeComplex, c); + Result result; // FIXME: do contractions diff --git a/extras/Hadrons/Modules/MContraction/DiscLoop.hpp b/extras/Hadrons/Modules/MContraction/DiscLoop.hpp index f8da3943..c0fbe296 100644 --- a/extras/Hadrons/Modules/MContraction/DiscLoop.hpp +++ b/extras/Hadrons/Modules/MContraction/DiscLoop.hpp @@ -67,6 +67,7 @@ public: virtual ~TDiscLoop(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -95,10 +96,18 @@ std::vector TDiscLoop::getInput(void) return in; } +template +std::vector TDiscLoop::getReference(void) +{ + std::vector out = {}; + + return out; +} + template std::vector TDiscLoop::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } @@ -107,7 +116,7 @@ std::vector TDiscLoop::getOutput(void) template void TDiscLoop::setup(void) { - + envTmpLat(LatticeComplex, "c"); } // execution /////////////////////////////////////////////////////////////////// @@ -119,12 +128,12 @@ void TDiscLoop::execute(void) << " insertion." << std::endl; CorrWriter writer(par().output); - PropagatorField &q_loop = *env().template getObject(par().q_loop); - LatticeComplex c(env().getGrid()); + auto &q_loop = envGet(PropagatorField, par().q_loop); Gamma gamma(par().gamma); std::vector buf; Result result; + envGetTmp(LatticeComplex, c); c = trace(gamma*q_loop); sliceSum(c, buf, Tp); diff --git a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp index a8653186..4a6baf3e 100644 --- a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp +++ b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp @@ -98,6 +98,7 @@ public: virtual ~TGamma3pt(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -126,10 +127,18 @@ std::vector TGamma3pt::getInput(void) return in; } +template +std::vector TGamma3pt::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TGamma3pt::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } @@ -138,7 +147,7 @@ std::vector TGamma3pt::getOutput(void) template void TGamma3pt::setup(void) { - + envTmpLat(LatticeComplex, "c"); } // execution /////////////////////////////////////////////////////////////////// @@ -153,10 +162,9 @@ void TGamma3pt::execute(void) // Initialise variables. q2 and q3 are normal propagators, q1 may be // sink smeared. CorrWriter writer(par().output); - SlicedPropagator1 &q1 = *env().template getObject(par().q1); - PropagatorField2 &q2 = *env().template getObject(par().q2); - PropagatorField3 &q3 = *env().template getObject(par().q3); - LatticeComplex c(env().getGrid()); + auto &q1 = envGet(SlicedPropagator1, par().q1); + auto &q2 = envGet(PropagatorField2, par().q2); + auto &q3 = envGet(PropagatorField2, par().q3); Gamma g5(Gamma::Algebra::Gamma5); Gamma gamma(par().gamma); std::vector buf; @@ -165,6 +173,7 @@ void TGamma3pt::execute(void) // Extract relevant timeslice of sinked propagator q1, then contract & // sum over all spacial positions of gamma insertion. SitePropagator1 q1Snk = q1[par().tSnk]; + envGetTmp(LatticeComplex, c); c = trace(g5*q1Snk*adj(q2)*(g5*gamma)*q3); sliceSum(c, buf, Tp); diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 3c179d44..1fd86d3a 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -161,6 +161,7 @@ void TMeson::parseGammaString(std::vector &gammaList) // Parse individual contractions from input string. gammaList = strToVec(par().gammas); } + envTmpLat(LatticeComplex, "c"); } // execution /////////////////////////////////////////////////////////////////// @@ -192,8 +193,8 @@ void TMeson::execute(void) if (envHasType(SlicedPropagator1, par().q1) and envHasType(SlicedPropagator2, par().q2)) { - SlicedPropagator1 &q1 = envGet(SlicedPropagator1, par().q1); - SlicedPropagator2 &q2 = envGet(SlicedPropagator2, par().q2); + auto &q1 = envGet(SlicedPropagator1, par().q1); + auto &q2 = envGet(SlicedPropagator2, par().q2); LOG(Message) << "(propagator already sinked)" << std::endl; for (unsigned int i = 0; i < result.size(); ++i) @@ -209,10 +210,10 @@ void TMeson::execute(void) } else { - PropagatorField1 &q1 = envGet(PropagatorField1, par().q1); - PropagatorField2 &q2 = envGet(PropagatorField2, par().q2); - LatticeComplex c(env().getGrid()); + auto &q1 = envGet(PropagatorField1, par().q1); + auto &q2 = envGet(PropagatorField2, par().q2); + envGetTmp(LatticeComplex, c); LOG(Message) << "(using sink '" << par().sink << "')" << std::endl; for (unsigned int i = 0; i < result.size(); ++i) { diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index 90922c27..c92c7243 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -73,6 +73,7 @@ public: virtual ~TWardIdentity(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -103,10 +104,18 @@ std::vector TWardIdentity::getInput(void) return in; } +template +std::vector TWardIdentity::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TWardIdentity::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } @@ -120,6 +129,15 @@ void TWardIdentity::setup(void) { HADRON_ERROR(Size, "Ls mismatch between quark action and propagator"); } + envTmpLat(PropagatorField, "tmp"); + envTmpLat(PropagatorField, "vector_WI"); + if (par().test_axial) + { + envTmpLat(PropagatorField, "psi"); + envTmpLat(LatticeComplex, "PP"); + envTmpLat(LatticeComplex, "axial_defect"); + envTmpLat(LatticeComplex, "PJ5q"); + } } // execution /////////////////////////////////////////////////////////////////// @@ -129,12 +147,13 @@ void TWardIdentity::execute(void) LOG(Message) << "Performing Ward Identity checks for quark '" << par().q << "'." << std::endl; - PropagatorField tmp(env().getGrid()), vector_WI(env().getGrid()); - PropagatorField &q = *env().template getObject(par().q); - FMat &act = *(env().template getObject(par().action)); - Gamma g5(Gamma::Algebra::Gamma5); + auto &q = envGet(PropagatorField, par().q); + auto &act = envGet(FMat, par().action); + Gamma g5(Gamma::Algebra::Gamma5); // Compute D_mu V_mu, D here is backward derivative. + envGetTmp(PropagatorField, tmp); + envGetTmp(PropagatorField, vector_WI); vector_WI = zero; for (unsigned int mu = 0; mu < Nd; ++mu) { @@ -149,9 +168,10 @@ void TWardIdentity::execute(void) if (par().test_axial) { - PropagatorField psi(env().getGrid()); - LatticeComplex PP(env().getGrid()), axial_defect(env().getGrid()), - PJ5q(env().getGrid()); + envGetTmp(PropagatorField, psi); + envGetTmp(LatticeComplex, PP); + envGetTmp(LatticeComplex, axial_defect); + envGetTmp(LatticeComplex, PJ5q); std::vector axial_buf; // Compute , D is backwards derivative. diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp index 7df40370..2b53c87a 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp @@ -99,6 +99,7 @@ public:\ virtual ~T##modname(void) = default;\ /* dependency relation */ \ virtual std::vector getInput(void);\ + virtual std::vector getReference(void);\ virtual std::vector getOutput(void);\ public:\ std::vector VA_label = {"V", "A"};\ diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc b/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc index 314b080a..7a73a7e3 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc @@ -74,9 +74,16 @@ std::vector TWeakHamiltonianEye::getInput(void) return in; } +std::vector TWeakHamiltonianEye::getReference(void) +{ + std::vector out = {}; + + return out; +} + std::vector TWeakHamiltonianEye::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } @@ -84,7 +91,15 @@ std::vector TWeakHamiltonianEye::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TWeakHamiltonianEye::setup(void) { + unsigned int ndim = env().getNd(); + envTmpLat(LatticeComplex, "expbuf"); + envTmpLat(PropagatorField, "tmp1"); + envTmpLat(LatticeComplex, "tmp2"); + envTmp(std::vector, "S_body", 1, ndim, PropagatorField(env().getGrid())); + envTmp(std::vector, "S_loop", 1, ndim, PropagatorField(env().getGrid())); + envTmp(std::vector, "E_body", 1, ndim, LatticeComplex(env().getGrid())); + envTmp(std::vector, "E_loop", 1, ndim, LatticeComplex(env().getGrid())); } // execution /////////////////////////////////////////////////////////////////// @@ -96,22 +111,22 @@ void TWeakHamiltonianEye::execute(void) << "'." << std::endl; CorrWriter writer(par().output); - SlicedPropagator &q1 = *env().template getObject(par().q1); - PropagatorField &q2 = *env().template getObject(par().q2); - PropagatorField &q3 = *env().template getObject(par().q3); - PropagatorField &q4 = *env().template getObject(par().q4); - Gamma g5 = Gamma(Gamma::Algebra::Gamma5); - LatticeComplex expbuf(env().getGrid()); + auto &q1 = envGet(SlicedPropagator, par().q1); + auto &q2 = envGet(PropagatorField, par().q2); + auto &q3 = envGet(PropagatorField, par().q3); + auto &q4 = envGet(PropagatorField, par().q4); + Gamma g5 = Gamma(Gamma::Algebra::Gamma5); std::vector corrbuf; std::vector result(n_eye_diag); unsigned int ndim = env().getNd(); - PropagatorField tmp1(env().getGrid()); - LatticeComplex tmp2(env().getGrid()); - std::vector S_body(ndim, tmp1); - std::vector S_loop(ndim, tmp1); - std::vector E_body(ndim, tmp2); - std::vector E_loop(ndim, tmp2); + envGetTmp(LatticeComplex, expbuf); + envGetTmp(PropagatorField, tmp1); + envGetTmp(LatticeComplex, tmp2); + envGetTmp(std::vector, S_body); + envGetTmp(std::vector, S_loop); + envGetTmp(std::vector, E_body); + envGetTmp(std::vector, E_loop); // Get sink timeslice of q1. SitePropagator q1Snk = q1[par().tSnk]; diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc b/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc index 2c4df68a..c333713d 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc @@ -74,9 +74,15 @@ std::vector TWeakHamiltonianNonEye::getInput(void) return in; } +std::vector TWeakHamiltonianNonEye::getReference(void) +{ + std::vector out = {}; + + return out; +} std::vector TWeakHamiltonianNonEye::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } @@ -84,7 +90,15 @@ std::vector TWeakHamiltonianNonEye::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TWeakHamiltonianNonEye::setup(void) { + unsigned int ndim = env().getNd(); + envTmpLat(LatticeComplex, "expbuf"); + envTmpLat(PropagatorField, "tmp1"); + envTmpLat(LatticeComplex, "tmp2"); + envTmp(std::vector, "C_i_side_loop", 1, ndim, PropagatorField(env().getGrid())); + envTmp(std::vector, "C_f_side_loop", 1, ndim, PropagatorField(env().getGrid())); + envTmp(std::vector, "W_i_side_loop", 1, ndim, LatticeComplex(env().getGrid())); + envTmp(std::vector, "W_f_side_loop", 1, ndim, LatticeComplex(env().getGrid())); } // execution /////////////////////////////////////////////////////////////////// @@ -95,23 +109,23 @@ void TWeakHamiltonianNonEye::execute(void) << par().q2 << ", '" << par().q3 << "' and '" << par().q4 << "'." << std::endl; - CorrWriter writer(par().output); - PropagatorField &q1 = *env().template getObject(par().q1); - PropagatorField &q2 = *env().template getObject(par().q2); - PropagatorField &q3 = *env().template getObject(par().q3); - PropagatorField &q4 = *env().template getObject(par().q4); - Gamma g5 = Gamma(Gamma::Algebra::Gamma5); - LatticeComplex expbuf(env().getGrid()); + CorrWriter writer(par().output); + auto &q1 = envGet(PropagatorField, par().q1); + auto &q2 = envGet(PropagatorField, par().q2); + auto &q3 = envGet(PropagatorField, par().q3); + auto &q4 = envGet(PropagatorField, par().q4); + Gamma g5 = Gamma(Gamma::Algebra::Gamma5); std::vector corrbuf; std::vector result(n_noneye_diag); - unsigned int ndim = env().getNd(); + unsigned int ndim = env().getNd(); - PropagatorField tmp1(env().getGrid()); - LatticeComplex tmp2(env().getGrid()); - std::vector C_i_side_loop(ndim, tmp1); - std::vector C_f_side_loop(ndim, tmp1); - std::vector W_i_side_loop(ndim, tmp2); - std::vector W_f_side_loop(ndim, tmp2); + envGetTmp(LatticeComplex, expbuf); + envGetTmp(PropagatorField, tmp1); + envGetTmp(LatticeComplex, tmp2); + envGetTmp(std::vector, C_i_side_loop); + envGetTmp(std::vector, C_f_side_loop); + envGetTmp(std::vector, W_i_side_loop); + envGetTmp(std::vector, W_f_side_loop); // Setup for C-type contractions. for (int mu = 0; mu < ndim; ++mu) diff --git a/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc b/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc index 6685f292..e0f07f6c 100644 --- a/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc +++ b/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc @@ -76,9 +76,16 @@ std::vector TWeakNeutral4ptDisc::getInput(void) return in; } +std::vector TWeakNeutral4ptDisc::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + std::vector TWeakNeutral4ptDisc::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {}; return out; } @@ -86,7 +93,13 @@ std::vector TWeakNeutral4ptDisc::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TWeakNeutral4ptDisc::setup(void) { + unsigned int ndim = env().getNd(); + envTmpLat(LatticeComplex, "expbuf"); + envTmpLat(PropagatorField, "tmp"); + envTmpLat(LatticeComplex, "curr"); + envTmp(std::vector, "meson", 1, ndim, PropagatorField(env().getGrid())); + envTmp(std::vector, "loop", 1, ndim, PropagatorField(env().getGrid())); } // execution /////////////////////////////////////////////////////////////////// @@ -97,21 +110,21 @@ void TWeakNeutral4ptDisc::execute(void) << par().q2 << ", '" << par().q3 << "' and '" << par().q4 << "'." << std::endl; - CorrWriter writer(par().output); - PropagatorField &q1 = *env().template getObject(par().q1); - PropagatorField &q2 = *env().template getObject(par().q2); - PropagatorField &q3 = *env().template getObject(par().q3); - PropagatorField &q4 = *env().template getObject(par().q4); - Gamma g5 = Gamma(Gamma::Algebra::Gamma5); - LatticeComplex expbuf(env().getGrid()); + CorrWriter writer(par().output); + auto &q1 = envGet(PropagatorField, par().q1); + auto &q2 = envGet(PropagatorField, par().q2); + auto &q3 = envGet(PropagatorField, par().q3); + auto &q4 = envGet(PropagatorField, par().q4); + Gamma g5 = Gamma(Gamma::Algebra::Gamma5); std::vector corrbuf; std::vector result(n_neut_disc_diag); - unsigned int ndim = env().getNd(); + unsigned int ndim = env().getNd(); - PropagatorField tmp(env().getGrid()); - std::vector meson(ndim, tmp); - std::vector loop(ndim, tmp); - LatticeComplex curr(env().getGrid()); + envGetTmp(LatticeComplex, expbuf); + envGetTmp(PropagatorField, tmp); + envGetTmp(LatticeComplex, curr); + envGetTmp(std::vector, meson); + envGetTmp(std::vector, loop); // Setup for type 1 contractions. for (int mu = 0; mu < ndim; ++mu) diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index 4d08841d..e77df287 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -154,21 +154,21 @@ void TGaugeProp::execute(void) LOG(Message) << "Computing quark propagator '" << getName() << "'" << std::endl; - FermionField &source = envGetTmp(FermionField, "source"); - FermionField &sol = envGetTmp(FermionField, "sol"); - FermionField &tmp = envGetTmp(FermionField, "tmp"); - std::string propName = (Ls_ == 1) ? getName() : (getName() + "_5d"); - PropagatorField &prop = envGet(PropagatorField, propName); - PropagatorField &fullSrc = envGet(PropagatorField, par().source); - SolverFn &solver = envGet(SolverFn, par().solver); + std::string propName = (Ls_ == 1) ? getName() : (getName() + "_5d"); + auto &prop = envGet(PropagatorField, propName); + auto &fullSrc = envGet(PropagatorField, par().source); + auto &solver = envGet(SolverFn, par().solver); + envGetTmp(FermionField, source); + envGetTmp(FermionField, sol); + envGetTmp(FermionField, tmp); LOG(Message) << "Inverting using solver '" << par().solver << "' on source '" << par().source << "'" << std::endl; for (unsigned int s = 0; s < Ns; ++s) for (unsigned int c = 0; c < Nc; ++c) { LOG(Message) << "Inversion for spin= " << s << ", color= " << c - << std::endl; + << std::endl; // source conversion for 4D sources if (!env().isObject5d(par().source)) { diff --git a/extras/Hadrons/Modules/MGauge/Load.cc b/extras/Hadrons/Modules/MGauge/Load.cc index 062e7e98..c2fd49de 100644 --- a/extras/Hadrons/Modules/MGauge/Load.cc +++ b/extras/Hadrons/Modules/MGauge/Load.cc @@ -49,6 +49,13 @@ std::vector TLoad::getInput(void) return in; } +std::vector TLoad::getReference(void) +{ + std::vector ref; + + return ref; +} + std::vector TLoad::getOutput(void) { std::vector out = {getName()}; @@ -59,19 +66,19 @@ std::vector TLoad::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TLoad::setup(void) { - env().registerLattice(getName()); + envCreateLat(LatticeGaugeField, getName()); } // execution /////////////////////////////////////////////////////////////////// void TLoad::execute(void) { - FieldMetaData header; - std::string fileName = par().file + "." - + std::to_string(env().getTrajectory()); - + FieldMetaData header; + std::string fileName = par().file + "." + + std::to_string(vm().getTrajectory()); LOG(Message) << "Loading NERSC configuration from file '" << fileName << "'" << std::endl; - LatticeGaugeField &U = *env().createLattice(getName()); + + auto &U = envGet(LatticeGaugeField, getName()); NerscIO::readConfiguration(U, header, fileName); LOG(Message) << "NERSC header:" << std::endl; dump_meta_data(header, LOG(Message)); diff --git a/extras/Hadrons/Modules/MGauge/Load.hpp b/extras/Hadrons/Modules/MGauge/Load.hpp index a338af79..a967d714 100644 --- a/extras/Hadrons/Modules/MGauge/Load.hpp +++ b/extras/Hadrons/Modules/MGauge/Load.hpp @@ -57,6 +57,7 @@ public: virtual ~TLoad(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MGauge/Random.cc b/extras/Hadrons/Modules/MGauge/Random.cc index c10fdfc3..fdb0d145 100644 --- a/extras/Hadrons/Modules/MGauge/Random.cc +++ b/extras/Hadrons/Modules/MGauge/Random.cc @@ -44,7 +44,16 @@ TRandom::TRandom(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TRandom::getInput(void) { - return std::vector(); + std::vector in; + + return in; +} + +std::vector TRandom::getReference(void) +{ + std::vector ref; + + return ref; } std::vector TRandom::getOutput(void) @@ -57,13 +66,14 @@ std::vector TRandom::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TRandom::setup(void) { - env().registerLattice(getName()); + envCreateLat(LatticeGaugeField, getName()); } // execution /////////////////////////////////////////////////////////////////// void TRandom::execute(void) { LOG(Message) << "Generating random gauge configuration" << std::endl; - LatticeGaugeField &U = *env().createLattice(getName()); + + auto &U = envGet(LatticeGaugeField, getName()); SU3::HotConfiguration(*env().get4dRng(), U); } diff --git a/extras/Hadrons/Modules/MGauge/Random.hpp b/extras/Hadrons/Modules/MGauge/Random.hpp index a07130e4..30525113 100644 --- a/extras/Hadrons/Modules/MGauge/Random.hpp +++ b/extras/Hadrons/Modules/MGauge/Random.hpp @@ -50,6 +50,7 @@ public: virtual ~TRandom(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MGauge/StochEm.cc b/extras/Hadrons/Modules/MGauge/StochEm.cc index c7a9fc4f..a878ae2f 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.cc +++ b/extras/Hadrons/Modules/MGauge/StochEm.cc @@ -47,6 +47,13 @@ std::vector TStochEm::getInput(void) return in; } +std::vector TStochEm::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + std::vector TStochEm::getOutput(void) { std::vector out = {getName()}; @@ -57,32 +64,28 @@ std::vector TStochEm::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TStochEm::setup(void) { - if (!env().hasRegisteredObject("_" + getName() + "_weight")) + if (!env().hasCreatedObject("_" + getName() + "_weight")) { - env().registerLattice("_" + getName() + "_weight"); + envCacheLat(EmComp, "_" + getName() + "_weight"); } - env().registerLattice(getName()); + envCreateLat(EmField, getName()); } // execution /////////////////////////////////////////////////////////////////// void TStochEm::execute(void) { + LOG(Message) << "Generating stochatic EM potential..." << std::endl; + PhotonR photon(par().gauge, par().zmScheme); - EmField &a = *env().createLattice(getName()); - EmComp *w; + auto &a = envGet(EmField, getName()); + auto &w = envGet(EmComp, "_" + getName() + "_weight"); if (!env().hasCreatedObject("_" + getName() + "_weight")) { LOG(Message) << "Caching stochatic EM potential weight (gauge: " << par().gauge << ", zero-mode scheme: " << par().zmScheme << ")..." << std::endl; - w = env().createLattice("_" + getName() + "_weight"); - photon.StochasticWeight(*w); + photon.StochasticWeight(w); } - else - { - w = env().getObject("_" + getName() + "_weight"); - } - LOG(Message) << "Generating stochatic EM potential..." << std::endl; - photon.StochasticField(a, *env().get4dRng(), *w); + photon.StochasticField(a, *env().get4dRng(), w); } diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index bacb5172..efc2e39b 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -59,6 +59,7 @@ public: virtual ~TStochEm(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MGauge/Unit.cc b/extras/Hadrons/Modules/MGauge/Unit.cc index bc05a785..af31f124 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.cc +++ b/extras/Hadrons/Modules/MGauge/Unit.cc @@ -71,6 +71,7 @@ void TUnit::setup(void) void TUnit::execute(void) { LOG(Message) << "Creating unit gauge configuration" << std::endl; + auto &U = envGet(LatticeGaugeField, getName()); SU3::ColdConfiguration(*env().get4dRng(), U); } diff --git a/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp b/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp index 1f40dd48..0feb5efb 100644 --- a/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp +++ b/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp @@ -73,6 +73,7 @@ public: virtual ~TNoiseLoop(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -101,6 +102,15 @@ std::vector TNoiseLoop::getInput(void) return in; } + +template +std::vector TNoiseLoop::getReference(void) +{ + std::vector out = {}; + + return out; +} + template std::vector TNoiseLoop::getOutput(void) { @@ -113,16 +123,16 @@ std::vector TNoiseLoop::getOutput(void) template void TNoiseLoop::setup(void) { - env().template registerLattice(getName()); + envCreateLat(PropagatorField, getName()); } // execution /////////////////////////////////////////////////////////////////// template void TNoiseLoop::execute(void) { - PropagatorField &loop = *env().template createLattice(getName()); - PropagatorField &q = *env().template getObject(par().q); - PropagatorField &eta = *env().template getObject(par().eta); + auto &loop = envGet(PropagatorField, getName()); + auto &q = envGet(PropagatorField, par().q); + auto &eta = envGet(PropagatorField, par().eta); loop = q*adj(eta); } diff --git a/extras/Hadrons/Modules/MSink/Point.hpp b/extras/Hadrons/Modules/MSink/Point.hpp index 16b89434..42cae4f6 100644 --- a/extras/Hadrons/Modules/MSink/Point.hpp +++ b/extras/Hadrons/Modules/MSink/Point.hpp @@ -122,18 +122,19 @@ void TPoint::setup(void) // execution /////////////////////////////////////////////////////////////////// template void TPoint::execute(void) -{ - std::vector p = strToVec(par().mom); - LatticeComplex &ph = envGet(LatticeComplex, momphName_); - Complex i(0.0,1.0); - +{ LOG(Message) << "Setting up point sink function for momentum [" << par().mom << "]" << std::endl; + auto &ph = envGet(LatticeComplex, momphName_); + if (!hasPhase_) { - LatticeComplex &coor = envGetTmp(LatticeComplex, "coor"); + Complex i(0.0,1.0); + std::vector p; + envGetTmp(LatticeComplex, coor); + p = strToVec(par().mom); ph = zero; for(unsigned int mu = 0; mu < env().getNd(); mu++) { diff --git a/extras/Hadrons/Modules/MSink/Smear.hpp b/extras/Hadrons/Modules/MSink/Smear.hpp index b51d2f49..03cc861a 100644 --- a/extras/Hadrons/Modules/MSink/Smear.hpp +++ b/extras/Hadrons/Modules/MSink/Smear.hpp @@ -61,6 +61,7 @@ public: virtual ~TSmear(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -89,6 +90,14 @@ std::vector TSmear::getInput(void) return in; } +template +std::vector TSmear::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TSmear::getOutput(void) { @@ -101,9 +110,7 @@ std::vector TSmear::getOutput(void) template void TSmear::setup(void) { - unsigned int nt = env().getDim(Tp); - unsigned int size = nt * sizeof(SitePropagator); - env().registerObject(getName(), size); + envCreate(SlicedPropagator, getName(), 1, env().getDim(Tp)); } // execution /////////////////////////////////////////////////////////////////// @@ -114,11 +121,11 @@ void TSmear::execute(void) << "' using sink function '" << par().sink << "'." << std::endl; - SinkFn &sink = *env().template getObject(par().sink); - PropagatorField &q = *env().template getObject(par().q); - SlicedPropagator *out = new SlicedPropagator(env().getDim(Tp)); - *out = sink(q); - env().setObject(getName(), out); + auto &sink = envGet(SinkFn, par().sink); + auto &q = envGet(PropagatorField, par().q); + auto &out = envGet(SlicedPropagator, getName()); + + out = sink(q); } END_MODULE_NAMESPACE diff --git a/extras/Hadrons/Modules/MSource/Point.hpp b/extras/Hadrons/Modules/MSource/Point.hpp index 3fab41c0..6470c77f 100644 --- a/extras/Hadrons/Modules/MSource/Point.hpp +++ b/extras/Hadrons/Modules/MSource/Point.hpp @@ -128,12 +128,13 @@ void TPoint::setup(void) template void TPoint::execute(void) { - std::vector position = strToVec(par().position); - SitePropagator id; - LOG(Message) << "Creating point source at position [" << par().position - << "]" << std::endl; - PropagatorField &src = envGet(PropagatorField, getName()); + << "]" << std::endl; + + std::vector position = strToVec(par().position); + auto &src = envGet(PropagatorField, getName()); + SitePropagator id; + id = 1.; src = zero; pokeSite(id, src, position); diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index e8f91be1..9ccbee1b 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -82,6 +82,7 @@ public: virtual ~TSeqConserved(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -110,6 +111,14 @@ std::vector TSeqConserved::getInput(void) return in; } +template +std::vector TSeqConserved::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TSeqConserved::getOutput(void) { @@ -123,7 +132,7 @@ template void TSeqConserved::setup(void) { auto Ls_ = env().getObjectLs(par().action); - env().template registerLattice(getName(), Ls_); + envCreateLat(PropagatorField, getName(), Ls_); } // execution /////////////////////////////////////////////////////////////////// @@ -143,9 +152,9 @@ void TSeqConserved::execute(void) << par().mu << ") for " << par().tA << " <= t <= " << par().tB << std::endl; } - PropagatorField &src = *env().template createLattice(getName()); - PropagatorField &q = *env().template getObject(par().q); - FMat &mat = *(env().template getObject(par().action)); + auto &src = envGet(PropagatorField, getName()); + auto &q = envGet(PropagatorField, par().q); + auto &mat = envGet(FMat, par().action); std::vector mom = strToVec(par().mom); mat.SeqConservedCurrent(q, src, par().curr_type, par().mu, diff --git a/extras/Hadrons/Modules/MSource/SeqGamma.hpp b/extras/Hadrons/Modules/MSource/SeqGamma.hpp index 8f67f8fa..d2b3c958 100644 --- a/extras/Hadrons/Modules/MSource/SeqGamma.hpp +++ b/extras/Hadrons/Modules/MSource/SeqGamma.hpp @@ -80,12 +80,16 @@ public: virtual ~TSeqGamma(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup virtual void setup(void); // execution virtual void execute(void); +private: + bool hasPhase_{false}; + std::string momphName_, tName_; }; MODULE_REGISTER_NS(SeqGamma, TSeqGamma, MSource); @@ -97,6 +101,8 @@ MODULE_REGISTER_NS(SeqGamma, TSeqGamma, MSource); template TSeqGamma::TSeqGamma(const std::string name) : Module(name) +, momphName_ (name + "_momph") +, tName_ (name + "_t") {} // dependencies/products /////////////////////////////////////////////////////// @@ -108,6 +114,14 @@ std::vector TSeqGamma::getInput(void) return in; } +template +std::vector TSeqGamma::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TSeqGamma::getOutput(void) { @@ -120,7 +134,10 @@ std::vector TSeqGamma::getOutput(void) template void TSeqGamma::setup(void) { - env().template registerLattice(getName()); + envCreateLat(PropagatorField, getName()); + envCacheLat(Lattice>, tName_); + envCacheLat(LatticeComplex, momphName_); + envTmpLat(LatticeComplex, "coor"); } // execution /////////////////////////////////////////////////////////////////// @@ -138,23 +155,29 @@ void TSeqGamma::execute(void) << " sequential source for " << par().tA << " <= t <= " << par().tB << std::endl; } - PropagatorField &src = *env().template createLattice(getName()); - PropagatorField &q = *env().template getObject(par().q); - Lattice> t(env().getGrid()); - LatticeComplex ph(env().getGrid()), coor(env().getGrid()); - Gamma g(par().gamma); - std::vector p; - Complex i(0.0,1.0); + auto &src = envGet(PropagatorField, getName()); + auto &q = envGet(PropagatorField, par().q); + auto &ph = envGet(LatticeComplex, momphName_); + auto &t = envGet(Lattice>, tName_); + Gamma g(par().gamma); - p = strToVec(par().mom); - ph = zero; - for(unsigned int mu = 0; mu < env().getNd(); mu++) + if (!hasPhase_) { - LatticeCoordinate(coor, mu); - ph = ph + p[mu]*coor*((1./(env().getGrid()->_fdimensions[mu]))); + Complex i(0.0,1.0); + std::vector p; + + envGetTmp(LatticeComplex, coor); + p = strToVec(par().mom); + ph = zero; + for(unsigned int mu = 0; mu < env().getNd(); mu++) + { + LatticeCoordinate(coor, mu); + ph = ph + (p[mu]/env().getGrid()->_fdimensions[mu])*coor; + } + ph = exp((Real)(2*M_PI)*i*ph); + LatticeCoordinate(t, Tp); + hasPhase_ = true; } - ph = exp((Real)(2*M_PI)*i*ph); - LatticeCoordinate(t, Tp); src = where((t >= par().tA) and (t <= par().tB), ph*(g*q), 0.*q); } diff --git a/extras/Hadrons/Modules/MSource/Wall.hpp b/extras/Hadrons/Modules/MSource/Wall.hpp index 57dee06d..d9814d9e 100644 --- a/extras/Hadrons/Modules/MSource/Wall.hpp +++ b/extras/Hadrons/Modules/MSource/Wall.hpp @@ -72,12 +72,16 @@ public: virtual ~TWall(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup virtual void setup(void); // execution virtual void execute(void); +private: + bool hasPhase_{false}; + std::string momphName_, tName_; }; MODULE_REGISTER_NS(Wall, TWall, MSource); @@ -89,17 +93,27 @@ MODULE_REGISTER_NS(Wall, TWall, MSource); template TWall::TWall(const std::string name) : Module(name) +, momphName_ (name + "_momph") +, tName_ (name + "_t") {} // dependencies/products /////////////////////////////////////////////////////// template std::vector TWall::getInput(void) { - std::vector in; + std::vector in = {}; return in; } +template +std::vector TWall::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TWall::getOutput(void) { @@ -112,7 +126,7 @@ std::vector TWall::getOutput(void) template void TWall::setup(void) { - env().template registerLattice(getName()); + envCreateLat(PropagatorField, getName()); } // execution /////////////////////////////////////////////////////////////////// @@ -122,21 +136,28 @@ void TWall::execute(void) LOG(Message) << "Generating wall source at t = " << par().tW << " with momentum " << par().mom << std::endl; - PropagatorField &src = *env().template createLattice(getName()); - Lattice> t(env().getGrid()); - LatticeComplex ph(env().getGrid()), coor(env().getGrid()); - std::vector p; - Complex i(0.0,1.0); + auto &src = envGet(PropagatorField, getName()); + auto &ph = envGet(LatticeComplex, momphName_); + auto &t = envGet(Lattice>, tName_); - p = strToVec(par().mom); - ph = zero; - for(unsigned int mu = 0; mu < Nd; mu++) + if (!hasPhase_) { - LatticeCoordinate(coor, mu); - ph = ph + p[mu]*coor*((1./(env().getGrid()->_fdimensions[mu]))); + Complex i(0.0,1.0); + std::vector p; + + envGetTmp(LatticeComplex, coor); + p = strToVec(par().mom); + ph = zero; + for(unsigned int mu = 0; mu < env().getNd(); mu++) + { + LatticeCoordinate(coor, mu); + ph = ph + (p[mu]/env().getGrid()->_fdimensions[mu])*coor; + } + ph = exp((Real)(2*M_PI)*i*ph); + LatticeCoordinate(t, Tp); + hasPhase_ = true; } - ph = exp((Real)(2*M_PI)*i*ph); - LatticeCoordinate(t, Tp); + src = 1.; src = where((t == par().tW), src*ph, 0.*src); } diff --git a/extras/Hadrons/Modules/MSource/Z2.hpp b/extras/Hadrons/Modules/MSource/Z2.hpp index e2cc4f34..2e864ff0 100644 --- a/extras/Hadrons/Modules/MSource/Z2.hpp +++ b/extras/Hadrons/Modules/MSource/Z2.hpp @@ -75,12 +75,16 @@ public: virtual ~TZ2(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup virtual void setup(void); // execution virtual void execute(void); +private: + bool hasT_{false}; + std::string tName_; }; MODULE_REGISTER_NS(Z2, TZ2, MSource); @@ -93,6 +97,7 @@ MODULE_REGISTER_NS(ScalarZ2, TZ2, MSource); template TZ2::TZ2(const std::string name) : Module(name) +, tName_ (name + "_t") {} // dependencies/products /////////////////////////////////////////////////////// @@ -104,6 +109,14 @@ std::vector TZ2::getInput(void) return in; } +template +std::vector TZ2::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TZ2::getOutput(void) { @@ -116,29 +129,36 @@ std::vector TZ2::getOutput(void) template void TZ2::setup(void) { - env().template registerLattice(getName()); + envCreateLat(PropagatorField, getName()); + envCacheLat(Lattice>, tName_); + envTmpLat(LatticeComplex, "eta"); } // execution /////////////////////////////////////////////////////////////////// template void TZ2::execute(void) { - Lattice> t(env().getGrid()); - LatticeComplex eta(env().getGrid()); - Complex shift(1., 1.); - if (par().tA == par().tB) { LOG(Message) << "Generating Z_2 wall source at t= " << par().tA - << std::endl; + << std::endl; } else { LOG(Message) << "Generating Z_2 band for " << par().tA << " <= t <= " - << par().tB << std::endl; + << par().tB << std::endl; } - PropagatorField &src = *env().template createLattice(getName()); - LatticeCoordinate(t, Tp); + + auto &src = envGet(PropagatorField, getName()); + auto &t = envGet(Lattice>, getName()); + Complex shift(1., 1.); + + if (!hasT_) + { + LatticeCoordinate(t, Tp); + hasT_ = true; + } + envGetTmp(LatticeComplex, eta); bernoulli(*env().get4dRng(), eta); eta = (2.*eta - shift)*(1./::sqrt(2.)); eta = where((t >= par().tA) and (t <= par().tB), eta, 0.*eta); diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index b0f2846f..081d2911 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -79,6 +79,7 @@ public: virtual ~TTestSeqConserved(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -107,6 +108,14 @@ std::vector TTestSeqConserved::getInput(void) return in; } +template +std::vector TTestSeqConserved::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TTestSeqConserved::getOutput(void) { @@ -124,36 +133,37 @@ void TTestSeqConserved::setup(void) { HADRON_ERROR(Size, "Ls mismatch between quark action and propagator"); } + envTmpLat(PropagatorField, "tmp"); + envTmpLat(LatticeComplex, "c"); } // execution /////////////////////////////////////////////////////////////////// template void TTestSeqConserved::execute(void) { - PropagatorField tmp(env().getGrid()); - PropagatorField &q = *env().template getObject(par().q); - PropagatorField &qSeq = *env().template getObject(par().qSeq); - FMat &act = *(env().template getObject(par().action)); - Gamma g5(Gamma::Algebra::Gamma5); - Gamma::Algebra gA = (par().curr == Current::Axial) ? - Gamma::Algebra::Gamma5 : - Gamma::Algebra::Identity; - Gamma g(gA); - SitePropagator qSite; - Complex test_S, test_V, check_S, check_V; - std::vector check_buf; - LatticeComplex c(env().getGrid()); - // Check sequential insertion of current gives same result as conserved // current sink upon contraction. Assume q uses a point source. - std::vector siteCoord; + + auto &q = envGet(PropagatorField, par().q); + auto &qSeq = envGet(PropagatorField, par().qSeq); + auto &act = envGet(FMat, par().action); + Gamma g5(Gamma::Algebra::Gamma5); + Gamma::Algebra gA = (par().curr == Current::Axial) ? + Gamma::Algebra::Gamma5 : + Gamma::Algebra::Identity; + Gamma g(gA); + SitePropagator qSite; + Complex test_S, test_V, check_S, check_V; + std::vector check_buf; + std::vector siteCoord; + + envGetTmp(PropagatorField, tmp); + envGetTmp(LatticeComplex, c); siteCoord = strToVec(par().origin); peekSite(qSite, qSeq, siteCoord); test_S = trace(qSite*g); test_V = trace(qSite*g*Gamma::gmu[par().mu]); - act.ContractConservedCurrent(q, q, tmp, par().curr, par().mu); - c = trace(tmp*g); sliceSum(c, check_buf, Tp); check_S = TensorRemove(check_buf[par().t_J]); diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp index 9736ab54..30bd4b69 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -63,6 +63,7 @@ public: virtual ~TTestSeqGamma(void) = default; // dependency relation virtual std::vector getInput(void); + virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -91,6 +92,14 @@ std::vector TTestSeqGamma::getInput(void) return in; } +template +std::vector TTestSeqGamma::getReference(void) +{ + std::vector ref = {}; + + return ref; +} + template std::vector TTestSeqGamma::getOutput(void) { @@ -103,26 +112,27 @@ std::vector TTestSeqGamma::getOutput(void) template void TTestSeqGamma::setup(void) { - + envTmpLat(LatticeComplex, "c"); } // execution /////////////////////////////////////////////////////////////////// template void TTestSeqGamma::execute(void) { - PropagatorField &q = *env().template getObject(par().q); - PropagatorField &qSeq = *env().template getObject(par().qSeq); - LatticeComplex c(env().getGrid()); - Gamma g5(Gamma::Algebra::Gamma5); - Gamma g(par().gamma); - SitePropagator qSite; - Complex test, check; + auto &q = envGet(PropagatorField, par().q); + auto &qSeq = envGet(PropagatorField, par().qSeq); + Gamma g5(Gamma::Algebra::Gamma5); + Gamma g(par().gamma); + SitePropagator qSite; + Complex test, check; std::vector check_buf; + std::vector siteCoord; // Check sequential insertion of gamma matrix gives same result as // insertion of gamma at sink upon contraction. Assume q uses a point // source. - std::vector siteCoord; + + envGetTmp(LatticeComplex, c); siteCoord = strToVec(par().origin); peekSite(qSite, qSeq, siteCoord); test = trace(g*qSite); diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 5ce2435f..2f4d183e 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -1,45 +1,38 @@ modules_cc =\ - Modules/MGauge/Unit.cc - # Modules/MContraction/WeakHamiltonianEye.cc \ - # Modules/MContraction/WeakHamiltonianNonEye.cc \ - # Modules/MContraction/WeakNeutral4ptDisc.cc \ - # Modules/MGauge/Load.cc \ - # Modules/MGauge/Random.cc \ - # Modules/MGauge/StochEm.cc \ - # Modules/MScalar/ChargedProp.cc \ - # Modules/MScalar/FreeProp.cc + Modules/MGauge/Unit.cc \ + Modules/MContraction/WeakHamiltonianEye.cc \ + Modules/MContraction/WeakHamiltonianNonEye.cc \ + Modules/MContraction/WeakNeutral4ptDisc.cc \ + Modules/MGauge/Load.cc \ + Modules/MGauge/Random.cc \ + Modules/MGauge/StochEm.cc modules_hpp =\ Modules/MAction/DWF.hpp \ Modules/MAction/Wilson.hpp \ Modules/MSink/Point.hpp \ Modules/MSource/Point.hpp \ + Modules/MGauge/Load.hpp \ + Modules/MGauge/Random.hpp \ + Modules/MGauge/StochEm.hpp \ Modules/MGauge/Unit.hpp \ Modules/MSolver/RBPrecCG.hpp \ Modules/MFermion/GaugeProp.hpp \ - Modules/MContraction/Meson.hpp - - # Modules/MContraction/Baryon.hpp \ - # Modules/MContraction/DiscLoop.hpp \ - # Modules/MContraction/Gamma3pt.hpp \ - # Modules/MContraction/WardIdentity.hpp \ - # Modules/MContraction/WeakHamiltonian.hpp \ - # Modules/MContraction/WeakHamiltonianEye.hpp \ - # Modules/MContraction/WeakHamiltonianNonEye.hpp \ - # Modules/MContraction/WeakNeutral4ptDisc.hpp \ - # Modules/MFermion/GaugeProp.hpp \ - # Modules/MGauge/Load.hpp \ - # Modules/MGauge/Random.hpp \ - # Modules/MGauge/StochEm.hpp \ - # Modules/MLoop/NoiseLoop.hpp \ - # Modules/MScalar/ChargedProp.hpp \ - # Modules/MScalar/FreeProp.hpp \ - # Modules/MScalar/Scalar.hpp \ - # Modules/MSink/Smear.hpp \ - # Modules/MSolver/RBPrecCG.hpp \ - # Modules/MSource/SeqConserved.hpp \ - # Modules/MSource/SeqGamma.hpp \ - # Modules/MSource/Wall.hpp \ - # Modules/MSource/Z2.hpp \ - # Modules/MUtilities/TestSeqConserved.hpp \ - # Modules/MUtilities/TestSeqGamma.hpp + Modules/MContraction/Baryon.hpp \ + Modules/MContraction/DiscLoop.hpp \ + Modules/MContraction/Gamma3pt.hpp \ + Modules/MContraction/Meson.hpp \ + Modules/MContraction/WardIdentity.hpp \ + Modules/MContraction/WeakHamiltonian.hpp \ + Modules/MContraction/WeakHamiltonianEye.hpp \ + Modules/MContraction/WeakHamiltonianNonEye.hpp \ + Modules/MContraction/WeakNeutral4ptDisc.hpp \ + Modules/MLoop/NoiseLoop.hpp \ + Modules/MSink/Smear.hpp \ + Modules/MSolver/RBPrecCG.hpp \ + Modules/MSource/SeqConserved.hpp \ + Modules/MSource/SeqGamma.hpp \ + Modules/MSource/Wall.hpp \ + Modules/MSource/Z2.hpp \ + Modules/MUtilities/TestSeqConserved.hpp \ + Modules/MUtilities/TestSeqGamma.hpp diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp index 9bd3ee0a..0265f5a6 100644 --- a/tests/hadrons/Test_hadrons.hpp +++ b/tests/hadrons/Test_hadrons.hpp @@ -118,7 +118,7 @@ inline void makeWilsonAction(Application &application, std::string actionName, std::string &gaugeField, double mass, std::string boundary = "1 1 1 -1") { - if (!(Environment::getInstance().hasModule(actionName))) + if (!(VirtualMachine::getInstance().hasModule(actionName))) { MAction::Wilson::Par actionPar; actionPar.gauge = gaugeField; @@ -144,7 +144,7 @@ inline void makeDWFAction(Application &application, std::string actionName, std::string &gaugeField, double mass, double M5, unsigned int Ls, std::string boundary = "1 1 1 -1") { - if (!(Environment::getInstance().hasModule(actionName))) + if (!(VirtualMachine::getInstance().hasModule(actionName))) { MAction::DWF::Par actionPar; actionPar.gauge = gaugeField; @@ -173,7 +173,7 @@ inline void makeDWFAction(Application &application, std::string actionName, inline void makeRBPrecCGSolver(Application &application, std::string &solverName, std::string &actionName, double residual = 1e-8) { - if (!(Environment::getInstance().hasModule(solverName))) + if (!(VirtualMachine::getInstance().hasModule(solverName))) { MSolver::RBPrecCG::Par solverPar; solverPar.action = actionName; @@ -195,7 +195,7 @@ inline void makePointSource(Application &application, std::string srcName, std::string pos) { // If the source already exists, don't make the module again. - if (!(Environment::getInstance().hasModule(srcName))) + if (!(VirtualMachine::getInstance().hasModule(srcName))) { MSource::Point::Par pointPar; pointPar.position = pos; @@ -219,7 +219,7 @@ inline void makeSequentialSource(Application &application, std::string srcName, std::string mom = ZERO_MOM) { // If the source already exists, don't make the module again. - if (!(Environment::getInstance().hasModule(srcName))) + if (!(VirtualMachine::getInstance().hasModule(srcName))) { MSource::SeqGamma::Par seqPar; seqPar.q = qSrc; @@ -255,7 +255,7 @@ inline void makeConservedSequentialSource(Application &application, std::string mom = ZERO_MOM) { // If the source already exists, don't make the module again. - if (!(Environment::getInstance().hasModule(srcName))) + if (!(VirtualMachine::getInstance().hasModule(srcName))) { MSource::SeqConserved::Par seqPar; seqPar.q = qSrc; @@ -280,7 +280,7 @@ inline void makeConservedSequentialSource(Application &application, inline void makeNoiseSource(Application &application, std::string &srcName, unsigned int tA, unsigned int tB) { - if (!(Environment::getInstance().hasModule(srcName))) + if (!(VirtualMachine::getInstance().hasModule(srcName))) { MSource::Z2::Par noisePar; noisePar.tA = tA; @@ -302,7 +302,7 @@ inline void makeWallSource(Application &application, std::string &srcName, unsigned int tW, std::string mom = ZERO_MOM) { // If the source already exists, don't make the module again. - if (!(Environment::getInstance().hasModule(srcName))) + if (!(VirtualMachine::getInstance().hasModule(srcName))) { MSource::Wall::Par wallPar; wallPar.tW = tW; @@ -324,7 +324,7 @@ inline void makePointSink(Application &application, std::string &sinkFnct, std::string mom = ZERO_MOM) { // If the sink function already exists, don't make it again. - if (!(Environment::getInstance().hasModule(sinkFnct))) + if (!(VirtualMachine::getInstance().hasModule(sinkFnct))) { MSink::Point::Par pointPar; pointPar.mom = mom; @@ -345,7 +345,7 @@ inline void sinkSmear(Application &application, std::string &sinkFnct, std::string &propName, std::string &smearedProp) { // If the propagator has already been smeared, don't smear it again. - if (!(Environment::getInstance().hasModule(smearedProp))) + if (!(VirtualMachine::getInstance().hasModule(smearedProp))) { MSink::Smear::Par smearPar; smearPar.q = propName; @@ -367,7 +367,7 @@ inline void makePropagator(Application &application, std::string &propName, std::string &srcName, std::string &solver) { // If the propagator already exists, don't make the module again. - if (!(Environment::getInstance().hasModule(propName))) + if (!(VirtualMachine::getInstance().hasModule(propName))) { MFermion::GaugeProp::Par quarkPar; quarkPar.source = srcName; @@ -390,7 +390,7 @@ inline void makeLoop(Application &application, std::string &propName, std::string &srcName, std::string &resName) { // If the loop propagator already exists, don't make the module again. - if (!(Environment::getInstance().hasModule(propName))) + if (!(VirtualMachine::getInstance().hasModule(propName))) { MLoop::NoiseLoop::Par loopPar; loopPar.q = resName; @@ -421,7 +421,7 @@ inline void mesonContraction(Application &application, std::string &sink, std::string gammas = "") { - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MContraction::Meson::Par mesPar; mesPar.output = output; @@ -453,7 +453,7 @@ inline void gamma3ptContraction(Application &application, unsigned int npt, Gamma::Algebra gamma = Gamma::Algebra::Identity) { std::string modName = std::to_string(npt) + "pt_" + label; - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MContraction::Gamma3pt::Par gamma3ptPar; gamma3ptPar.output = std::to_string(npt) + "pt/" + label; @@ -487,7 +487,7 @@ inline void weakContraction##top(Application &application, unsigned int npt,\ std::string &label, unsigned int tSnk = 0)\ {\ std::string modName = std::to_string(npt) + "pt_" + label;\ - if (!(Environment::getInstance().hasModule(modName)))\ + if (!(VirtualMachine::getInstance().hasModule(modName)))\ {\ MContraction::WeakHamiltonian##top::Par weakPar;\ weakPar.output = std::to_string(npt) + "pt/" + label;\ @@ -521,7 +521,7 @@ inline void disc0Contraction(Application &application, std::string &label) { std::string modName = "4pt_" + label; - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MContraction::WeakNeutral4ptDisc::Par disc0Par; disc0Par.output = "4pt/" + label; @@ -547,7 +547,7 @@ inline void discLoopContraction(Application &application, std::string &q_loop, std::string &modName, Gamma::Algebra gamma = Gamma::Algebra::Identity) { - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MContraction::DiscLoop::Par discPar; discPar.output = "disc/" + modName; @@ -574,7 +574,7 @@ inline void makeWITest(Application &application, std::string &modName, std::string &propName, std::string &actionName, double mass, unsigned int Ls = 1, bool test_axial = false) { - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MContraction::WardIdentity::Par wiPar; if (Ls > 1) @@ -613,7 +613,7 @@ inline void makeSeqCurrComparison(Application &application, std::string &modName std::string &actionName, std::string &origin, unsigned int t_J, unsigned int mu, Current curr) { - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MUtilities::TestSeqConserved::Par seqPar; seqPar.q = propName; @@ -646,7 +646,7 @@ inline void makeSeqGamComparison(Application &application, std::string &modName, std::string &origin, Gamma::Algebra gamma, unsigned int t_g) { - if (!(Environment::getInstance().hasModule(modName))) + if (!(VirtualMachine::getInstance().hasModule(modName))) { MUtilities::TestSeqGamma::Par seqPar; seqPar.q = propName; From 591a38c487acc0f0abc7dd099e09f26f661f913c Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Thu, 14 Dec 2017 19:42:16 +0000 Subject: [PATCH 82/86] Hadrons: VM fixes --- extras/Hadrons/Modules/MSource/Z2.hpp | 2 +- extras/Hadrons/VirtualMachine.cc | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/extras/Hadrons/Modules/MSource/Z2.hpp b/extras/Hadrons/Modules/MSource/Z2.hpp index 2e864ff0..39840319 100644 --- a/extras/Hadrons/Modules/MSource/Z2.hpp +++ b/extras/Hadrons/Modules/MSource/Z2.hpp @@ -150,7 +150,7 @@ void TZ2::execute(void) } auto &src = envGet(PropagatorField, getName()); - auto &t = envGet(Lattice>, getName()); + auto &t = envGet(Lattice>, tName_); Complex shift(1., 1.); if (!hasT_) diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 8a6bd149..8b2ea516 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -83,6 +83,24 @@ void VirtualMachine::pushModule(VirtualMachine::ModPt &pt) } m.input.push_back(env().getObjectAddress(ref)); } + auto inCopy = m.input; + // if module has inputs with references, they need to be added as + // an input + for (auto &in: inCopy) + { + int inm = env().getObjectModule(in); + + if (inm > 0) + { + if (getModule(inm)->getReference().size() > 0) + { + for (auto &rin: getModule(inm)->getReference()) + { + m.input.push_back(env().getObjectAddress(rin)); + } + } + } + } module_.push_back(std::move(m)); address = static_cast(module_.size() - 1); moduleAddress_[name] = address; From bcf6f3890c38420eba6449f5190fc688b006fbf7 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Thu, 14 Dec 2017 21:14:10 +0000 Subject: [PATCH 83/86] Hadrons: more fixes after test --- extras/Hadrons/Modules/MContraction/Meson.hpp | 12 ++++++++++-- extras/Hadrons/VirtualMachine.cc | 4 ++-- extras/Hadrons/VirtualMachine.hpp | 2 +- 3 files changed, 13 insertions(+), 5 deletions(-) diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 1fd86d3a..3b250a3b 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -99,6 +99,8 @@ public: virtual std::vector getOutput(void); virtual void parseGammaString(std::vector &gammaList); protected: + // execution + virtual void setup(void); // execution virtual void execute(void); }; @@ -160,8 +162,14 @@ void TMeson::parseGammaString(std::vector &gammaList) { // Parse individual contractions from input string. gammaList = strToVec(par().gammas); - } - envTmpLat(LatticeComplex, "c"); + } +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TMeson::setup(void) +{ + envTmpLat(LatticeComplex, "c"); } // execution /////////////////////////////////////////////////////////////////// diff --git a/extras/Hadrons/VirtualMachine.cc b/extras/Hadrons/VirtualMachine.cc index 8b2ea516..e0035bc1 100644 --- a/extras/Hadrons/VirtualMachine.cc +++ b/extras/Hadrons/VirtualMachine.cc @@ -579,8 +579,8 @@ void VirtualMachine::executeProgram(const Program &p) const { // execute module LOG(Message) << SEP << " Measurement step " << i + 1 << "/" - << p.size() << " (module '" << module_[p[i]].name - << "') " << SEP << std::endl; + << p.size() << " (module '" << module_[p[i]].name + << "') " << SEP << std::endl; (*module_[p[i]].data)(); sizeBefore = env().getTotalSize(); // print used memory after execution diff --git a/extras/Hadrons/VirtualMachine.hpp b/extras/Hadrons/VirtualMachine.hpp index a411c108..3af7d914 100644 --- a/extras/Hadrons/VirtualMachine.hpp +++ b/extras/Hadrons/VirtualMachine.hpp @@ -59,7 +59,7 @@ public: { Size size; Environment::Storage storage; - unsigned int module; + int module; }; struct MemoryProfile { From e2fe97277bc0dcc65700645f16c547fe3d6b429e Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Tue, 19 Dec 2017 20:28:04 +0000 Subject: [PATCH 84/86] Hadrons: getReference use is rare, empty by default --- extras/Hadrons/Module.hpp | 5 ++++- extras/Hadrons/Modules/MAction/DWF.hpp | 9 --------- extras/Hadrons/Modules/MAction/Wilson.hpp | 9 --------- extras/Hadrons/Modules/MContraction/Baryon.hpp | 9 --------- extras/Hadrons/Modules/MContraction/DiscLoop.hpp | 9 --------- extras/Hadrons/Modules/MContraction/Gamma3pt.hpp | 9 --------- extras/Hadrons/Modules/MContraction/Meson.hpp | 9 --------- extras/Hadrons/Modules/MContraction/WardIdentity.hpp | 9 --------- .../Hadrons/Modules/MContraction/WeakHamiltonian.hpp | 1 - .../Hadrons/Modules/MContraction/WeakHamiltonianEye.cc | 7 ------- .../Modules/MContraction/WeakHamiltonianNonEye.cc | 6 ------ .../Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc | 7 ------- extras/Hadrons/Modules/MFermion/GaugeProp.hpp | 9 --------- extras/Hadrons/Modules/MGauge/Load.cc | 7 ------- extras/Hadrons/Modules/MGauge/Load.hpp | 1 - extras/Hadrons/Modules/MGauge/Random.cc | 7 ------- extras/Hadrons/Modules/MGauge/Random.hpp | 1 - extras/Hadrons/Modules/MGauge/StochEm.cc | 7 ------- extras/Hadrons/Modules/MGauge/StochEm.hpp | 1 - extras/Hadrons/Modules/MGauge/Unit.cc | 7 ------- extras/Hadrons/Modules/MGauge/Unit.hpp | 1 - extras/Hadrons/Modules/MLoop/NoiseLoop.hpp | 10 ---------- extras/Hadrons/Modules/MSink/Point.hpp | 9 --------- extras/Hadrons/Modules/MSink/Smear.hpp | 9 --------- extras/Hadrons/Modules/MSource/Point.hpp | 9 --------- extras/Hadrons/Modules/MSource/SeqConserved.hpp | 9 --------- extras/Hadrons/Modules/MSource/SeqGamma.hpp | 9 --------- extras/Hadrons/Modules/MSource/Wall.hpp | 9 --------- extras/Hadrons/Modules/MSource/Z2.hpp | 9 --------- extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp | 9 --------- extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp | 9 --------- extras/Hadrons/Modules/templates/Module.cc.template | 8 -------- extras/Hadrons/Modules/templates/Module.hpp.template | 1 - .../Hadrons/Modules/templates/Module_in_NS.cc.template | 8 -------- .../Modules/templates/Module_in_NS.hpp.template | 1 - .../Hadrons/Modules/templates/Module_tmp.hpp.template | 1 - .../Modules/templates/Module_tmp_in_NS.hpp.template | 9 --------- 37 files changed, 4 insertions(+), 245 deletions(-) diff --git a/extras/Hadrons/Module.hpp b/extras/Hadrons/Module.hpp index 390573d8..b71f779d 100644 --- a/extras/Hadrons/Module.hpp +++ b/extras/Hadrons/Module.hpp @@ -155,7 +155,10 @@ public: virtual std::string getRegisteredName(void); // dependencies/products virtual std::vector getInput(void) = 0; - virtual std::vector getReference(void) = 0; + virtual std::vector getReference(void) + { + return std::vector(0); + }; virtual std::vector getOutput(void) = 0; // parse parameters virtual void parseParameters(XmlReader &reader, const std::string name) = 0; diff --git a/extras/Hadrons/Modules/MAction/DWF.hpp b/extras/Hadrons/Modules/MAction/DWF.hpp index 0cb9a4cb..d99f1165 100644 --- a/extras/Hadrons/Modules/MAction/DWF.hpp +++ b/extras/Hadrons/Modules/MAction/DWF.hpp @@ -64,7 +64,6 @@ public: virtual ~TDWF(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -93,14 +92,6 @@ std::vector TDWF::getInput(void) return in; } -template -std::vector TDWF::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TDWF::getOutput(void) { diff --git a/extras/Hadrons/Modules/MAction/Wilson.hpp b/extras/Hadrons/Modules/MAction/Wilson.hpp index a6b3f0d6..8ef755bb 100644 --- a/extras/Hadrons/Modules/MAction/Wilson.hpp +++ b/extras/Hadrons/Modules/MAction/Wilson.hpp @@ -62,7 +62,6 @@ public: virtual ~TWilson(void) = default; // dependencies/products virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -91,14 +90,6 @@ std::vector TWilson::getInput(void) return in; } -template -std::vector TWilson::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TWilson::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/Baryon.hpp b/extras/Hadrons/Modules/MContraction/Baryon.hpp index 28f6aa51..1ef2e257 100644 --- a/extras/Hadrons/Modules/MContraction/Baryon.hpp +++ b/extras/Hadrons/Modules/MContraction/Baryon.hpp @@ -71,7 +71,6 @@ public: virtual ~TBaryon(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -100,14 +99,6 @@ std::vector TBaryon::getInput(void) return input; } -template -std::vector TBaryon::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TBaryon::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/DiscLoop.hpp b/extras/Hadrons/Modules/MContraction/DiscLoop.hpp index c0fbe296..ef50061c 100644 --- a/extras/Hadrons/Modules/MContraction/DiscLoop.hpp +++ b/extras/Hadrons/Modules/MContraction/DiscLoop.hpp @@ -67,7 +67,6 @@ public: virtual ~TDiscLoop(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -96,14 +95,6 @@ std::vector TDiscLoop::getInput(void) return in; } -template -std::vector TDiscLoop::getReference(void) -{ - std::vector out = {}; - - return out; -} - template std::vector TDiscLoop::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp index 4a6baf3e..fb9a9d4b 100644 --- a/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp +++ b/extras/Hadrons/Modules/MContraction/Gamma3pt.hpp @@ -98,7 +98,6 @@ public: virtual ~TGamma3pt(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -127,14 +126,6 @@ std::vector TGamma3pt::getInput(void) return in; } -template -std::vector TGamma3pt::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TGamma3pt::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/Meson.hpp b/extras/Hadrons/Modules/MContraction/Meson.hpp index 3b250a3b..46bbdb2e 100644 --- a/extras/Hadrons/Modules/MContraction/Meson.hpp +++ b/extras/Hadrons/Modules/MContraction/Meson.hpp @@ -95,7 +95,6 @@ public: virtual ~TMeson(void) = default; // dependencies/products virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); virtual void parseGammaString(std::vector &gammaList); protected: @@ -125,14 +124,6 @@ std::vector TMeson::getInput(void) return input; } -template -std::vector TMeson::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TMeson::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp index c92c7243..556450a8 100644 --- a/extras/Hadrons/Modules/MContraction/WardIdentity.hpp +++ b/extras/Hadrons/Modules/MContraction/WardIdentity.hpp @@ -73,7 +73,6 @@ public: virtual ~TWardIdentity(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -104,14 +103,6 @@ std::vector TWardIdentity::getInput(void) return in; } -template -std::vector TWardIdentity::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TWardIdentity::getOutput(void) { diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp index 2b53c87a..7df40370 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp @@ -99,7 +99,6 @@ public:\ virtual ~T##modname(void) = default;\ /* dependency relation */ \ virtual std::vector getInput(void);\ - virtual std::vector getReference(void);\ virtual std::vector getOutput(void);\ public:\ std::vector VA_label = {"V", "A"};\ diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc b/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc index 7a73a7e3..43dfa609 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc @@ -74,13 +74,6 @@ std::vector TWeakHamiltonianEye::getInput(void) return in; } -std::vector TWeakHamiltonianEye::getReference(void) -{ - std::vector out = {}; - - return out; -} - std::vector TWeakHamiltonianEye::getOutput(void) { std::vector out = {}; diff --git a/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc b/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc index c333713d..8a7113e3 100644 --- a/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc +++ b/extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc @@ -74,12 +74,6 @@ std::vector TWeakHamiltonianNonEye::getInput(void) return in; } -std::vector TWeakHamiltonianNonEye::getReference(void) -{ - std::vector out = {}; - - return out; -} std::vector TWeakHamiltonianNonEye::getOutput(void) { std::vector out = {}; diff --git a/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc b/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc index e0f07f6c..18423f3e 100644 --- a/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc +++ b/extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc @@ -76,13 +76,6 @@ std::vector TWeakNeutral4ptDisc::getInput(void) return in; } -std::vector TWeakNeutral4ptDisc::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - std::vector TWeakNeutral4ptDisc::getOutput(void) { std::vector out = {}; diff --git a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp index e77df287..05b3d17a 100644 --- a/extras/Hadrons/Modules/MFermion/GaugeProp.hpp +++ b/extras/Hadrons/Modules/MFermion/GaugeProp.hpp @@ -84,7 +84,6 @@ public: virtual ~TGaugeProp(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -116,14 +115,6 @@ std::vector TGaugeProp::getInput(void) return in; } -template -std::vector TGaugeProp::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TGaugeProp::getOutput(void) { diff --git a/extras/Hadrons/Modules/MGauge/Load.cc b/extras/Hadrons/Modules/MGauge/Load.cc index c2fd49de..b168a010 100644 --- a/extras/Hadrons/Modules/MGauge/Load.cc +++ b/extras/Hadrons/Modules/MGauge/Load.cc @@ -49,13 +49,6 @@ std::vector TLoad::getInput(void) return in; } -std::vector TLoad::getReference(void) -{ - std::vector ref; - - return ref; -} - std::vector TLoad::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/MGauge/Load.hpp b/extras/Hadrons/Modules/MGauge/Load.hpp index a967d714..a338af79 100644 --- a/extras/Hadrons/Modules/MGauge/Load.hpp +++ b/extras/Hadrons/Modules/MGauge/Load.hpp @@ -57,7 +57,6 @@ public: virtual ~TLoad(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MGauge/Random.cc b/extras/Hadrons/Modules/MGauge/Random.cc index fdb0d145..97afd338 100644 --- a/extras/Hadrons/Modules/MGauge/Random.cc +++ b/extras/Hadrons/Modules/MGauge/Random.cc @@ -49,13 +49,6 @@ std::vector TRandom::getInput(void) return in; } -std::vector TRandom::getReference(void) -{ - std::vector ref; - - return ref; -} - std::vector TRandom::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/MGauge/Random.hpp b/extras/Hadrons/Modules/MGauge/Random.hpp index 30525113..a07130e4 100644 --- a/extras/Hadrons/Modules/MGauge/Random.hpp +++ b/extras/Hadrons/Modules/MGauge/Random.hpp @@ -50,7 +50,6 @@ public: virtual ~TRandom(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MGauge/StochEm.cc b/extras/Hadrons/Modules/MGauge/StochEm.cc index a878ae2f..c5318573 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.cc +++ b/extras/Hadrons/Modules/MGauge/StochEm.cc @@ -47,13 +47,6 @@ std::vector TStochEm::getInput(void) return in; } -std::vector TStochEm::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - std::vector TStochEm::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index efc2e39b..bacb5172 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -59,7 +59,6 @@ public: virtual ~TStochEm(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MGauge/Unit.cc b/extras/Hadrons/Modules/MGauge/Unit.cc index af31f124..8bee1ecc 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.cc +++ b/extras/Hadrons/Modules/MGauge/Unit.cc @@ -47,13 +47,6 @@ std::vector TUnit::getInput(void) return std::vector(); } -std::vector TUnit::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - std::vector TUnit::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/MGauge/Unit.hpp b/extras/Hadrons/Modules/MGauge/Unit.hpp index 4b69f0ce..c1650cc7 100644 --- a/extras/Hadrons/Modules/MGauge/Unit.hpp +++ b/extras/Hadrons/Modules/MGauge/Unit.hpp @@ -50,7 +50,6 @@ public: virtual ~TUnit(void) = default; // dependencies/products virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup diff --git a/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp b/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp index 0feb5efb..512c731a 100644 --- a/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp +++ b/extras/Hadrons/Modules/MLoop/NoiseLoop.hpp @@ -73,7 +73,6 @@ public: virtual ~TNoiseLoop(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -102,15 +101,6 @@ std::vector TNoiseLoop::getInput(void) return in; } - -template -std::vector TNoiseLoop::getReference(void) -{ - std::vector out = {}; - - return out; -} - template std::vector TNoiseLoop::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSink/Point.hpp b/extras/Hadrons/Modules/MSink/Point.hpp index 42cae4f6..43be3009 100644 --- a/extras/Hadrons/Modules/MSink/Point.hpp +++ b/extras/Hadrons/Modules/MSink/Point.hpp @@ -60,7 +60,6 @@ public: virtual ~TPoint(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -94,14 +93,6 @@ std::vector TPoint::getInput(void) return in; } -template -std::vector TPoint::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TPoint::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSink/Smear.hpp b/extras/Hadrons/Modules/MSink/Smear.hpp index 03cc861a..e85ab263 100644 --- a/extras/Hadrons/Modules/MSink/Smear.hpp +++ b/extras/Hadrons/Modules/MSink/Smear.hpp @@ -61,7 +61,6 @@ public: virtual ~TSmear(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -90,14 +89,6 @@ std::vector TSmear::getInput(void) return in; } -template -std::vector TSmear::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TSmear::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSource/Point.hpp b/extras/Hadrons/Modules/MSource/Point.hpp index 6470c77f..1d8241cf 100644 --- a/extras/Hadrons/Modules/MSource/Point.hpp +++ b/extras/Hadrons/Modules/MSource/Point.hpp @@ -71,7 +71,6 @@ public: virtual ~TPoint(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -101,14 +100,6 @@ std::vector TPoint::getInput(void) return in; } -template -std::vector TPoint::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TPoint::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSource/SeqConserved.hpp b/extras/Hadrons/Modules/MSource/SeqConserved.hpp index 9ccbee1b..3e8ef457 100644 --- a/extras/Hadrons/Modules/MSource/SeqConserved.hpp +++ b/extras/Hadrons/Modules/MSource/SeqConserved.hpp @@ -82,7 +82,6 @@ public: virtual ~TSeqConserved(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -111,14 +110,6 @@ std::vector TSeqConserved::getInput(void) return in; } -template -std::vector TSeqConserved::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TSeqConserved::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSource/SeqGamma.hpp b/extras/Hadrons/Modules/MSource/SeqGamma.hpp index d2b3c958..abad5ace 100644 --- a/extras/Hadrons/Modules/MSource/SeqGamma.hpp +++ b/extras/Hadrons/Modules/MSource/SeqGamma.hpp @@ -80,7 +80,6 @@ public: virtual ~TSeqGamma(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -114,14 +113,6 @@ std::vector TSeqGamma::getInput(void) return in; } -template -std::vector TSeqGamma::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TSeqGamma::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSource/Wall.hpp b/extras/Hadrons/Modules/MSource/Wall.hpp index d9814d9e..9d5f1f46 100644 --- a/extras/Hadrons/Modules/MSource/Wall.hpp +++ b/extras/Hadrons/Modules/MSource/Wall.hpp @@ -72,7 +72,6 @@ public: virtual ~TWall(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -106,14 +105,6 @@ std::vector TWall::getInput(void) return in; } -template -std::vector TWall::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TWall::getOutput(void) { diff --git a/extras/Hadrons/Modules/MSource/Z2.hpp b/extras/Hadrons/Modules/MSource/Z2.hpp index 39840319..3593cb34 100644 --- a/extras/Hadrons/Modules/MSource/Z2.hpp +++ b/extras/Hadrons/Modules/MSource/Z2.hpp @@ -75,7 +75,6 @@ public: virtual ~TZ2(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -109,14 +108,6 @@ std::vector TZ2::getInput(void) return in; } -template -std::vector TZ2::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TZ2::getOutput(void) { diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp index 081d2911..0647884c 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqConserved.hpp @@ -79,7 +79,6 @@ public: virtual ~TTestSeqConserved(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -108,14 +107,6 @@ std::vector TTestSeqConserved::getInput(void) return in; } -template -std::vector TTestSeqConserved::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TTestSeqConserved::getOutput(void) { diff --git a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp index 30bd4b69..fd53eab8 100644 --- a/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp +++ b/extras/Hadrons/Modules/MUtilities/TestSeqGamma.hpp @@ -63,7 +63,6 @@ public: virtual ~TTestSeqGamma(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); protected: // setup @@ -92,14 +91,6 @@ std::vector TTestSeqGamma::getInput(void) return in; } -template -std::vector TTestSeqGamma::getReference(void) -{ - std::vector ref = {}; - - return ref; -} - template std::vector TTestSeqGamma::getOutput(void) { diff --git a/extras/Hadrons/Modules/templates/Module.cc.template b/extras/Hadrons/Modules/templates/Module.cc.template index 29edadfb..0c509d6d 100644 --- a/extras/Hadrons/Modules/templates/Module.cc.template +++ b/extras/Hadrons/Modules/templates/Module.cc.template @@ -19,14 +19,6 @@ std::vector T___FILEBASENAME___::getInput(void) return in; } -template -std::vector T___FILEBASENAME___::getReference(void) -{ - std::vector in = {}; - - return in; -} - std::vector T___FILEBASENAME___::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/templates/Module.hpp.template b/extras/Hadrons/Modules/templates/Module.hpp.template index b59e168f..fb43260f 100644 --- a/extras/Hadrons/Modules/templates/Module.hpp.template +++ b/extras/Hadrons/Modules/templates/Module.hpp.template @@ -26,7 +26,6 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); diff --git a/extras/Hadrons/Modules/templates/Module_in_NS.cc.template b/extras/Hadrons/Modules/templates/Module_in_NS.cc.template index 880129bd..8b2a0ec0 100644 --- a/extras/Hadrons/Modules/templates/Module_in_NS.cc.template +++ b/extras/Hadrons/Modules/templates/Module_in_NS.cc.template @@ -20,14 +20,6 @@ std::vector T___FILEBASENAME___::getInput(void) return in; } -template -std::vector T___FILEBASENAME___::getReference(void) -{ - std::vector in = {}; - - return in; -} - std::vector T___FILEBASENAME___::getOutput(void) { std::vector out = {getName()}; diff --git a/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template b/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template index f90cb052..ea77b12a 100644 --- a/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template +++ b/extras/Hadrons/Modules/templates/Module_in_NS.hpp.template @@ -28,7 +28,6 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); diff --git a/extras/Hadrons/Modules/templates/Module_tmp.hpp.template b/extras/Hadrons/Modules/templates/Module_tmp.hpp.template index b4e7f87f..2ee053a9 100644 --- a/extras/Hadrons/Modules/templates/Module_tmp.hpp.template +++ b/extras/Hadrons/Modules/templates/Module_tmp.hpp.template @@ -27,7 +27,6 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); diff --git a/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template b/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template index 9aef1c92..b79c0ad3 100644 --- a/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template +++ b/extras/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template @@ -29,7 +29,6 @@ public: virtual ~T___FILEBASENAME___(void) = default; // dependency relation virtual std::vector getInput(void); - virtual std::vector getReference(void); virtual std::vector getOutput(void); // setup virtual void setup(void); @@ -57,14 +56,6 @@ std::vector T___FILEBASENAME___::getInput(void) return in; } -template -std::vector T___FILEBASENAME___::getReference(void) -{ - std::vector in = {}; - - return in; -} - template std::vector T___FILEBASENAME___::getOutput(void) { From 65d4f17976ec7920aeccb880a50ad852e7fe7290 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Tue, 19 Dec 2017 20:28:32 +0000 Subject: [PATCH 85/86] Hadrons: no errors when trying to recreate a cache --- extras/Hadrons/Environment.hpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/extras/Hadrons/Environment.hpp b/extras/Hadrons/Environment.hpp index adea13ce..7f1bc26d 100644 --- a/extras/Hadrons/Environment.hpp +++ b/extras/Hadrons/Environment.hpp @@ -228,7 +228,11 @@ void Environment::createDerivedObject(const std::string name, MemoryProfiler::stats = nullptr; } } - else + // object already exists, no error if it is a cache, error otherwise + else if ((object_[address].storage != Storage::cache) or + (object_[address].storage != storage) or + (object_[address].name != name) or + (object_[address].type != &typeid(T))) { HADRON_ERROR(Definition, "object '" + name + "' already allocated"); } From 67c3fa0f5f2adda473b7543121a7ad6041547259 Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Thu, 21 Dec 2017 11:39:07 +0000 Subject: [PATCH 86/86] Hadrons: all modules are now ported, more tests need to be done --- extras/Hadrons/Modules.hpp | 40 ++--- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 153 +++++++++--------- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 6 +- extras/Hadrons/Modules/MScalar/FreeProp.cc | 27 ++-- extras/Hadrons/Modules/MScalar/FreeProp.hpp | 1 + extras/Hadrons/make_module_list.sh | 30 ++++ extras/Hadrons/modules.inc | 49 +++--- 7 files changed, 165 insertions(+), 141 deletions(-) diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 61a20058..cf381d0f 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -28,33 +28,33 @@ See the full license in the file "LICENSE" in the top level distribution directo *************************************************************************************/ /* END LEGAL */ -#include -#include #include -#include -#include #include -#include #include -#include #include +#include #include +#include +#include +#include #include -#include -#include -#include -#include -#include -// #include -// #include -// #include -#include -#include -#include -#include -#include #include +#include #include #include -#include +#include +#include +#include +#include +#include +#include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index cd8dc244..6cb75a28 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -37,90 +37,44 @@ void TChargedProp::setup(void) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); } - GFSrcName_ = "_" + getName() + "_DinvSrc"; - if (!env().hasRegisteredObject(freeMomPropName_)) + GFSrcName_ = getName() + "_DinvSrc"; + fftName_ = getName() + "_fft"; + + freeMomPropDone_ = env().hasCreatedObject(freeMomPropName_); + GFSrcDone_ = env().hasCreatedObject(GFSrcName_); + phasesDone_ = env().hasCreatedObject(phaseName_[0]); + envCacheLat(ScalarField, freeMomPropName_); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - env().registerLattice(freeMomPropName_); + envCacheLat(ScalarField, phaseName_[mu]); } - if (!env().hasRegisteredObject(phaseName_[0])) - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - env().registerLattice(phaseName_[mu]); - } - } - if (!env().hasRegisteredObject(GFSrcName_)) - { - env().registerLattice(GFSrcName_); - } - env().registerLattice(getName()); + envCacheLat(ScalarField, GFSrcName_); + envCreateLat(ScalarField, getName()); + envTmpLat(ScalarField, "buf"); + envTmpLat(ScalarField, "result"); + envTmpLat(ScalarField, "Amu"); + envCache(FFT, fftName_, 1, env().getGrid()); } // execution /////////////////////////////////////////////////////////////////// void TChargedProp::execute(void) { // CACHING ANALYTIC EXPRESSIONS - ScalarField &source = *env().getObject(par().source); - Complex ci(0.0,1.0); - FFT fft(env().getGrid()); - - // cache free scalar propagator - if (!env().hasCreatedObject(freeMomPropName_)) - { - LOG(Message) << "Caching momentum space free scalar propagator" - << " (mass= " << par().mass << ")..." << std::endl; - freeMomProp_ = env().createLattice(freeMomPropName_); - SIMPL::MomentumSpacePropagator(*freeMomProp_, par().mass); - } - else - { - freeMomProp_ = env().getObject(freeMomPropName_); - } - // cache G*F*src - if (!env().hasCreatedObject(GFSrcName_)) - - { - GFSrc_ = env().createLattice(GFSrcName_); - fft.FFT_all_dim(*GFSrc_, source, FFT::forward); - *GFSrc_ = (*freeMomProp_)*(*GFSrc_); - } - else - { - GFSrc_ = env().getObject(GFSrcName_); - } - // cache phases - if (!env().hasCreatedObject(phaseName_[0])) - { - std::vector &l = env().getGrid()->_fdimensions; - - LOG(Message) << "Caching shift phases..." << std::endl; - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - Real twoPiL = M_PI*2./l[mu]; - - phase_.push_back(env().createLattice(phaseName_[mu])); - LatticeCoordinate(*(phase_[mu]), mu); - *(phase_[mu]) = exp(ci*twoPiL*(*(phase_[mu]))); - } - } - else - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - phase_.push_back(env().getObject(phaseName_[mu])); - } - } + makeCaches(); // PROPAGATOR CALCULATION LOG(Message) << "Computing charged scalar propagator" << " (mass= " << par().mass << ", charge= " << par().charge << ")..." << std::endl; - ScalarField &prop = *env().createLattice(getName()); - ScalarField buf(env().getGrid()); - ScalarField &GFSrc = *GFSrc_, &G = *freeMomProp_; - double q = par().charge; - + auto &prop = envGet(ScalarField, getName()); + auto &GFSrc = envGet(ScalarField, GFSrcName_); + auto &G = envGet(ScalarField, freeMomPropName_); + auto &fft = envGet(FFT, fftName_); + double q = par().charge; + envGetTmp(ScalarField, result); + envGetTmp(ScalarField, buf); + // G*F*Src prop = GFSrc; @@ -146,7 +100,7 @@ void TChargedProp::execute(void) if (!par().output.empty()) { std::string filename = par().output + "." + - std::to_string(env().getTrajectory()); + std::to_string(vm().getTrajectory()); LOG(Message) << "Saving zero-momentum projection to '" << filename << "'..." << std::endl; @@ -166,15 +120,55 @@ void TChargedProp::execute(void) } } +void TChargedProp::makeCaches(void) +{ + auto &freeMomProp = envGet(ScalarField, freeMomPropName_); + auto &GFSrc = envGet(ScalarField, GFSrcName_); + auto &fft = envGet(FFT, fftName_); + + if (!freeMomPropDone_) + { + LOG(Message) << "Caching momentum space free scalar propagator" + << " (mass= " << par().mass << ")..." << std::endl; + SIMPL::MomentumSpacePropagator(freeMomProp, par().mass); + } + if (!GFSrcDone_) + { + FFT fft(env().getGrid()); + auto &source = envGet(ScalarField, par().source); + + LOG(Message) << "Caching G*F*src..." << std::endl; + fft.FFT_all_dim(GFSrc, source, FFT::forward); + GFSrc = freeMomProp*GFSrc; + } + if (!phasesDone_) + { + std::vector &l = env().getGrid()->_fdimensions; + Complex ci(0.0,1.0); + + LOG(Message) << "Caching shift phases..." << std::endl; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + Real twoPiL = M_PI*2./l[mu]; + auto &phmu = envGet(ScalarField, phaseName_[mu]); + + LatticeCoordinate(phmu, mu); + phmu = exp(ci*twoPiL*phmu); + phase_.push_back(&phmu); + } + } +} + void TChargedProp::momD1(ScalarField &s, FFT &fft) { - EmField &A = *env().getObject(par().emField); - ScalarField buf(env().getGrid()), result(env().getGrid()), - Amu(env().getGrid()); + auto &A = envGet(EmField, par().emField); Complex ci(0.0,1.0); - result = zero; + envGetTmp(ScalarField, buf); + envGetTmp(ScalarField, result); + envGetTmp(ScalarField, Amu); + result = zero; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { Amu = peekLorentz(A, mu); @@ -198,12 +192,13 @@ void TChargedProp::momD1(ScalarField &s, FFT &fft) void TChargedProp::momD2(ScalarField &s, FFT &fft) { - EmField &A = *env().getObject(par().emField); - ScalarField buf(env().getGrid()), result(env().getGrid()), - Amu(env().getGrid()); + auto &A = envGet(EmField, par().emField); + + envGetTmp(ScalarField, buf); + envGetTmp(ScalarField, result); + envGetTmp(ScalarField, Amu); result = zero; - for (unsigned int mu = 0; mu < env().getNd(); ++mu) { Amu = peekLorentz(A, mu); diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index ab6a0184..cfcce28e 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -43,14 +43,14 @@ protected: // execution virtual void execute(void); private: + void makeCaches(void); void momD1(ScalarField &s, FFT &fft); void momD2(ScalarField &s, FFT &fft); private: - std::string freeMomPropName_, GFSrcName_; + bool freeMomPropDone_, GFSrcDone_, phasesDone_; + std::string freeMomPropName_, GFSrcName_, fftName_; std::vector phaseName_; - ScalarField *freeMomProp_, *GFSrc_; std::vector phase_; - EmField *A; }; MODULE_REGISTER_NS(ChargedProp, TChargedProp, MScalar); diff --git a/extras/Hadrons/Modules/MScalar/FreeProp.cc b/extras/Hadrons/Modules/MScalar/FreeProp.cc index 674867e3..924db288 100644 --- a/extras/Hadrons/Modules/MScalar/FreeProp.cc +++ b/extras/Hadrons/Modules/MScalar/FreeProp.cc @@ -33,38 +33,31 @@ void TFreeProp::setup(void) { freeMomPropName_ = FREEMOMPROP(par().mass); - if (!env().hasRegisteredObject(freeMomPropName_)) - { - env().registerLattice(freeMomPropName_); - } - env().registerLattice(getName()); + freePropDone_ = env().hasCreatedObject(freeMomPropName_); + envCacheLat(ScalarField, freeMomPropName_); + envCreateLat(ScalarField, getName()); } // execution /////////////////////////////////////////////////////////////////// void TFreeProp::execute(void) { - ScalarField &prop = *env().createLattice(getName()); - ScalarField &source = *env().getObject(par().source); - ScalarField *freeMomProp; + auto &freeMomProp = envGet(ScalarField, freeMomPropName_); + auto &prop = envGet(ScalarField, getName()); + auto &source = envGet(ScalarField, par().source); - if (!env().hasCreatedObject(freeMomPropName_)) + if (!freePropDone_) { LOG(Message) << "Caching momentum space free scalar propagator" << " (mass= " << par().mass << ")..." << std::endl; - freeMomProp = env().createLattice(freeMomPropName_); - SIMPL::MomentumSpacePropagator(*freeMomProp, par().mass); - } - else - { - freeMomProp = env().getObject(freeMomPropName_); + SIMPL::MomentumSpacePropagator(freeMomProp, par().mass); } LOG(Message) << "Computing free scalar propagator..." << std::endl; - SIMPL::FreePropagator(source, prop, *freeMomProp); + SIMPL::FreePropagator(source, prop, freeMomProp); if (!par().output.empty()) { TextWriter writer(par().output + "." + - std::to_string(env().getTrajectory())); + std::to_string(vm().getTrajectory())); std::vector buf; std::vector result; diff --git a/extras/Hadrons/Modules/MScalar/FreeProp.hpp b/extras/Hadrons/Modules/MScalar/FreeProp.hpp index 38372a0c..6b956134 100644 --- a/extras/Hadrons/Modules/MScalar/FreeProp.hpp +++ b/extras/Hadrons/Modules/MScalar/FreeProp.hpp @@ -40,6 +40,7 @@ protected: virtual void execute(void); private: std::string freeMomPropName_; + bool freePropDone_; }; MODULE_REGISTER_NS(FreeProp, TFreeProp, MScalar); diff --git a/extras/Hadrons/make_module_list.sh b/extras/Hadrons/make_module_list.sh index ddc56ff6..8c6fa4da 100755 --- a/extras/Hadrons/make_module_list.sh +++ b/extras/Hadrons/make_module_list.sh @@ -7,6 +7,36 @@ echo 'modules_hpp =\' >> modules.inc find Modules -name '*.hpp' -type f -print | sed 's/^/ /;$q;s/$/ \\/' >> modules.inc echo '' >> modules.inc rm -f Modules.hpp +echo "/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules.hpp + +Copyright (C) 2015 +Copyright (C) 2016 +Copyright (C) 2017 + +Author: Antonin Portelli + +This program 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 2 of the License, or +(at your option) any later version. + +This program 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 this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file \"LICENSE\" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ +" > Modules.hpp for f in `find Modules -name '*.hpp'`; do echo "#include " >> Modules.hpp done diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 2f4d183e..199bb5cd 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -1,38 +1,43 @@ modules_cc =\ - Modules/MGauge/Unit.cc \ Modules/MContraction/WeakHamiltonianEye.cc \ - Modules/MContraction/WeakHamiltonianNonEye.cc \ Modules/MContraction/WeakNeutral4ptDisc.cc \ + Modules/MContraction/WeakHamiltonianNonEye.cc \ Modules/MGauge/Load.cc \ + Modules/MGauge/Unit.cc \ + Modules/MGauge/StochEm.cc \ Modules/MGauge/Random.cc \ - Modules/MGauge/StochEm.cc + Modules/MScalar/FreeProp.cc \ + Modules/MScalar/ChargedProp.cc modules_hpp =\ - Modules/MAction/DWF.hpp \ - Modules/MAction/Wilson.hpp \ - Modules/MSink/Point.hpp \ - Modules/MSource/Point.hpp \ - Modules/MGauge/Load.hpp \ - Modules/MGauge/Random.hpp \ - Modules/MGauge/StochEm.hpp \ - Modules/MGauge/Unit.hpp \ - Modules/MSolver/RBPrecCG.hpp \ - Modules/MFermion/GaugeProp.hpp \ Modules/MContraction/Baryon.hpp \ - Modules/MContraction/DiscLoop.hpp \ - Modules/MContraction/Gamma3pt.hpp \ Modules/MContraction/Meson.hpp \ - Modules/MContraction/WardIdentity.hpp \ Modules/MContraction/WeakHamiltonian.hpp \ - Modules/MContraction/WeakHamiltonianEye.hpp \ Modules/MContraction/WeakHamiltonianNonEye.hpp \ + Modules/MContraction/DiscLoop.hpp \ Modules/MContraction/WeakNeutral4ptDisc.hpp \ - Modules/MLoop/NoiseLoop.hpp \ - Modules/MSink/Smear.hpp \ - Modules/MSolver/RBPrecCG.hpp \ - Modules/MSource/SeqConserved.hpp \ + Modules/MContraction/Gamma3pt.hpp \ + Modules/MContraction/WardIdentity.hpp \ + Modules/MContraction/WeakHamiltonianEye.hpp \ + Modules/MFermion/GaugeProp.hpp \ Modules/MSource/SeqGamma.hpp \ + Modules/MSource/Point.hpp \ Modules/MSource/Wall.hpp \ Modules/MSource/Z2.hpp \ + Modules/MSource/SeqConserved.hpp \ + Modules/MSink/Smear.hpp \ + Modules/MSink/Point.hpp \ + Modules/MSolver/RBPrecCG.hpp \ + Modules/MGauge/Load.hpp \ + Modules/MGauge/Unit.hpp \ + Modules/MGauge/Random.hpp \ + Modules/MGauge/StochEm.hpp \ + Modules/MUtilities/TestSeqGamma.hpp \ Modules/MUtilities/TestSeqConserved.hpp \ - Modules/MUtilities/TestSeqGamma.hpp + Modules/MLoop/NoiseLoop.hpp \ + Modules/MScalar/FreeProp.hpp \ + Modules/MScalar/Scalar.hpp \ + Modules/MScalar/ChargedProp.hpp \ + Modules/MAction/DWF.hpp \ + Modules/MAction/Wilson.hpp +