From 871ebb4c2cf301c32cf455c0ee510df3111f3589 Mon Sep 17 00:00:00 2001 From: Lukas Abelt Date: Wed, 11 Oct 2023 13:08:32 +0200 Subject: [PATCH 1/3] Added configuration tags for HyTeg --- HyTeg/p1_cg_sor.info | 18 ++++++++++++++++++ HyTeg/p1_cg_sor.patch | 18 ++++++++++++++++++ HyTeg/p1_cg_symmetric.info | 18 ++++++++++++++++++ HyTeg/p1_cg_symmetric.patch | 18 ++++++++++++++++++ HyTeg/p1_gmres_sor.info | 18 ++++++++++++++++++ HyTeg/p1_gmres_sor.patch | 18 ++++++++++++++++++ HyTeg/p1_gmres_symmetric.info | 18 ++++++++++++++++++ HyTeg/p1_gmres_symmetric.patch | 18 ++++++++++++++++++ HyTeg/p1_minres_sor.info | 18 ++++++++++++++++++ HyTeg/p1_minres_sor.patch | 18 ++++++++++++++++++ HyTeg/p1_minres_symmetric.info | 18 ++++++++++++++++++ HyTeg/p1_minres_symmetric.patch | 27 +++++++++++++++++++++++++++ HyTeg/p2_cg_sor.info | 18 ++++++++++++++++++ HyTeg/p2_cg_sor.patch | 18 ++++++++++++++++++ HyTeg/p2_cg_symmetric.info | 18 ++++++++++++++++++ HyTeg/p2_cg_symmetric.patch | 18 ++++++++++++++++++ HyTeg/p2_gmres_sor.info | 18 ++++++++++++++++++ HyTeg/p2_gmres_sor.patch | 18 ++++++++++++++++++ HyTeg/p2_gmres_symmetric.info | 18 ++++++++++++++++++ HyTeg/p2_gmres_symmetric.patch | 18 ++++++++++++++++++ HyTeg/p2_minres_sor.info | 18 ++++++++++++++++++ HyTeg/p2_minres_sor.patch | 18 ++++++++++++++++++ HyTeg/p2_minres_symmetric.info | 18 ++++++++++++++++++ HyTeg/p2_minres_symmetric.patch | 18 ++++++++++++++++++ 24 files changed, 441 insertions(+) create mode 100644 HyTeg/p1_cg_sor.info create mode 100644 HyTeg/p1_cg_sor.patch create mode 100644 HyTeg/p1_cg_symmetric.info create mode 100644 HyTeg/p1_cg_symmetric.patch create mode 100644 HyTeg/p1_gmres_sor.info create mode 100644 HyTeg/p1_gmres_sor.patch create mode 100644 HyTeg/p1_gmres_symmetric.info create mode 100644 HyTeg/p1_gmres_symmetric.patch create mode 100644 HyTeg/p1_minres_sor.info create mode 100644 HyTeg/p1_minres_sor.patch create mode 100644 HyTeg/p1_minres_symmetric.info create mode 100644 HyTeg/p1_minres_symmetric.patch create mode 100644 HyTeg/p2_cg_sor.info create mode 100644 HyTeg/p2_cg_sor.patch create mode 100644 HyTeg/p2_cg_symmetric.info create mode 100644 HyTeg/p2_cg_symmetric.patch create mode 100644 HyTeg/p2_gmres_sor.info create mode 100644 HyTeg/p2_gmres_sor.patch create mode 100644 HyTeg/p2_gmres_symmetric.info create mode 100644 HyTeg/p2_gmres_symmetric.patch create mode 100644 HyTeg/p2_minres_sor.info create mode 100644 HyTeg/p2_minres_sor.patch create mode 100644 HyTeg/p2_minres_symmetric.info create mode 100644 HyTeg/p2_minres_symmetric.patch diff --git a/HyTeg/p1_cg_sor.info b/HyTeg/p1_cg_sor.info new file mode 100644 index 0000000..16e4af8 --- /dev/null +++ b/HyTeg/p1_cg_sor.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the CGSolver + with the SORSmoother. +feature_tags: +- SORSmoother +- CGSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p1_cg_sor.patch +project_name: HyTeg +shortname: p1_cg_sor +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SORSmoother +- CGSolver diff --git a/HyTeg/p1_cg_sor.patch b/HyTeg/p1_cg_sor.patch new file mode 100644 index 0000000..ed1dc4d --- /dev/null +++ b/HyTeg/p1_cg_sor.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..6997b4d4a 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,8 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( ++ hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( + minLevel, maxLevel, 2, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p1_cg_symmetric.info b/HyTeg/p1_cg_symmetric.info new file mode 100644 index 0000000..c9bcdaf --- /dev/null +++ b/HyTeg/p1_cg_symmetric.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the CGSolver + with the SymmetricSORSmoother. +feature_tags: +- SymmetricSORSmoother +- CGSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p1_cg_symmetric.patch +project_name: HyTeg +shortname: p1_cg_symmetric +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SymmetricSORSmoother +- CGSolver diff --git a/HyTeg/p1_cg_symmetric.patch b/HyTeg/p1_cg_symmetric.patch new file mode 100644 index 0000000..0fac840 --- /dev/null +++ b/HyTeg/p1_cg_symmetric.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..bfaf76de9 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,8 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( ++ hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( + minLevel, maxLevel, 2, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p1_gmres_sor.info b/HyTeg/p1_gmres_sor.info new file mode 100644 index 0000000..be079a9 --- /dev/null +++ b/HyTeg/p1_gmres_sor.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the GMRESSolver + with the SORSmoother. +feature_tags: +- SORSmoother +- GMRESSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p1_gmres_sor.patch +project_name: HyTeg +shortname: p1_gmres_sor +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SORSmoother +- GMRESSolver diff --git a/HyTeg/p1_gmres_sor.patch b/HyTeg/p1_gmres_sor.patch new file mode 100644 index 0000000..d84c819 --- /dev/null +++ b/HyTeg/p1_gmres_sor.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..edede6447 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,8 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( ++ hyteg::solvePoisson< hyteg::P1conf< hyteg::GMRESSolver< P1op >, hyteg::SORSmoother< P1op > > >( + minLevel, maxLevel, 2, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p1_gmres_symmetric.info b/HyTeg/p1_gmres_symmetric.info new file mode 100644 index 0000000..75b8406 --- /dev/null +++ b/HyTeg/p1_gmres_symmetric.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the GMRESSolver + with the SymmetricSORSmoother. +feature_tags: +- SymmetricSORSmoother +- GMRESSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p1_gmres_symmetric.patch +project_name: HyTeg +shortname: p1_gmres_symmetric +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SymmetricSORSmoother +- GMRESSolver diff --git a/HyTeg/p1_gmres_symmetric.patch b/HyTeg/p1_gmres_symmetric.patch new file mode 100644 index 0000000..5221ff0 --- /dev/null +++ b/HyTeg/p1_gmres_symmetric.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..fc3b1fdc3 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,8 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( ++ hyteg::solvePoisson< hyteg::P1conf< hyteg::GMRESSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( + minLevel, maxLevel, 2, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p1_minres_sor.info b/HyTeg/p1_minres_sor.info new file mode 100644 index 0000000..b556269 --- /dev/null +++ b/HyTeg/p1_minres_sor.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the MinResSolver + with the SORSmoother. +feature_tags: +- SORSmoother +- MinResSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p1_minres_sor.patch +project_name: HyTeg +shortname: p1_minres_sor +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SORSmoother +- MinResSolver diff --git a/HyTeg/p1_minres_sor.patch b/HyTeg/p1_minres_sor.patch new file mode 100644 index 0000000..b7eb6c3 --- /dev/null +++ b/HyTeg/p1_minres_sor.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..8263da85a 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,8 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( ++ hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SORSmoother< P1op > > >( + minLevel, maxLevel, 2, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p1_minres_symmetric.info b/HyTeg/p1_minres_symmetric.info new file mode 100644 index 0000000..fc8eb66 --- /dev/null +++ b/HyTeg/p1_minres_symmetric.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the MinResSolver + with the SymmetricSORSmoother. +feature_tags: +- SymmetricSORSmoother +- MinResSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p1_minres_symmetric.patch +project_name: HyTeg +shortname: p1_minres_symmetric +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SymmetricSORSmoother +- MinResSolver diff --git a/HyTeg/p1_minres_symmetric.patch b/HyTeg/p1_minres_symmetric.patch new file mode 100644 index 0000000..5d59075 --- /dev/null +++ b/HyTeg/p1_minres_symmetric.patch @@ -0,0 +1,27 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..11edf6c49 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,8 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); + hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( + minLevel, maxLevel, 2, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file +diff --git a/src/hyteg/p1functionspace/P1Function.hpp b/src/hyteg/p1functionspace/P1Function.hpp +index 51935b981..397a44aa5 100644 +--- a/src/hyteg/p1functionspace/P1Function.hpp ++++ b/src/hyteg/p1functionspace/P1Function.hpp +@@ -1,4 +1,4 @@ +-/* ++/*t's hard to recommend brands now bc it seems like they'll vary by store or randomly go to shit as the brand cheaps out. + * Copyright (c) 2017-2019 Boerge Struempfel, Daniel Drzisga, Dominik Thoennes, Nils Kohl. + * + * This file is part of HyTeG diff --git a/HyTeg/p2_cg_sor.info b/HyTeg/p2_cg_sor.info new file mode 100644 index 0000000..d3fe02a --- /dev/null +++ b/HyTeg/p2_cg_sor.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the CGSolver + with the SORSmoother. +feature_tags: +- SORSmoother +- CGSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p2_cg_sor.patch +project_name: HyTeg +shortname: p2_cg_sor +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SORSmoother +- CGSolver diff --git a/HyTeg/p2_cg_sor.patch b/HyTeg/p2_cg_sor.patch new file mode 100644 index 0000000..3a758d4 --- /dev/null +++ b/HyTeg/p2_cg_sor.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..321d20dab 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,7 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( +- minLevel, maxLevel, 2, 0.3 ); ++ hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p2_cg_symmetric.info b/HyTeg/p2_cg_symmetric.info new file mode 100644 index 0000000..e941f7e --- /dev/null +++ b/HyTeg/p2_cg_symmetric.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the CGSolver + with the SymmetricSORSmoother. +feature_tags: +- SymmetricSORSmoother +- CGSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p2_cg_symmetric.patch +project_name: HyTeg +shortname: p2_cg_symmetric +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SymmetricSORSmoother +- CGSolver diff --git a/HyTeg/p2_cg_symmetric.patch b/HyTeg/p2_cg_symmetric.patch new file mode 100644 index 0000000..cd88e3d --- /dev/null +++ b/HyTeg/p2_cg_symmetric.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..a85432d8e 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,7 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( +- minLevel, maxLevel, 2, 0.3 ); ++ hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SymmetricSORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p2_gmres_sor.info b/HyTeg/p2_gmres_sor.info new file mode 100644 index 0000000..853f766 --- /dev/null +++ b/HyTeg/p2_gmres_sor.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the GMRESSolver + with the SORSmoother. +feature_tags: +- SORSmoother +- GMRESSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p2_gmres_sor.patch +project_name: HyTeg +shortname: p2_gmres_sor +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SORSmoother +- GMRESSolver diff --git a/HyTeg/p2_gmres_sor.patch b/HyTeg/p2_gmres_sor.patch new file mode 100644 index 0000000..1be7273 --- /dev/null +++ b/HyTeg/p2_gmres_sor.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..d613fb4aa 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,7 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( +- minLevel, maxLevel, 2, 0.3 ); +- +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); + hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); ++ + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p2_gmres_symmetric.info b/HyTeg/p2_gmres_symmetric.info new file mode 100644 index 0000000..51da821 --- /dev/null +++ b/HyTeg/p2_gmres_symmetric.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the GMRESSolver + with the SymmetricSORSmoother. +feature_tags: +- SymmetricSORSmoother +- GMRESSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p2_gmres_symmetric.patch +project_name: HyTeg +shortname: p2_gmres_symmetric +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SymmetricSORSmoother +- GMRESSolver diff --git a/HyTeg/p2_gmres_symmetric.patch b/HyTeg/p2_gmres_symmetric.patch new file mode 100644 index 0000000..bf201e1 --- /dev/null +++ b/HyTeg/p2_gmres_symmetric.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..37e36efa4 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,7 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( +- minLevel, maxLevel, 2, 0.3 ); ++ hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SymmetricSORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p2_minres_sor.info b/HyTeg/p2_minres_sor.info new file mode 100644 index 0000000..6744a14 --- /dev/null +++ b/HyTeg/p2_minres_sor.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the MinResSolver + with the SORSmoother. +feature_tags: +- SORSmoother +- MinResSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p2_minres_sor.patch +project_name: HyTeg +shortname: p2_minres_sor +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SORSmoother +- MinResSolver diff --git a/HyTeg/p2_minres_sor.patch b/HyTeg/p2_minres_sor.patch new file mode 100644 index 0000000..7253394 --- /dev/null +++ b/HyTeg/p2_minres_sor.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..aa9cb22b3 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,7 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( +- minLevel, maxLevel, 2, 0.3 ); ++ hyteg::solvePoisson< hyteg::P2conf< hyteg::MinResSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file diff --git a/HyTeg/p2_minres_symmetric.info b/HyTeg/p2_minres_symmetric.info new file mode 100644 index 0000000..7b2561c --- /dev/null +++ b/HyTeg/p2_minres_symmetric.info @@ -0,0 +1,18 @@ +description: Changes the configuration of the HyTeg profiling app to use the MinResSolver + with the SymmetricSORSmoother. +feature_tags: +- SymmetricSORSmoother +- MinResSolver +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: p2_minres_symmetric.patch +project_name: HyTeg +shortname: p2_minres_symmetric +tags: +- HyTeg +- configuration +- compile-time +- synthetic +- SymmetricSORSmoother +- MinResSolver diff --git a/HyTeg/p2_minres_symmetric.patch b/HyTeg/p2_minres_symmetric.patch new file mode 100644 index 0000000..32954c0 --- /dev/null +++ b/HyTeg/p2_minres_symmetric.patch @@ -0,0 +1,18 @@ +diff --git a/apps/profiling/ProfilingApp.cpp b/apps/profiling/ProfilingApp.cpp +index 540f9d6da..69bf1fa78 100644 +--- a/apps/profiling/ProfilingApp.cpp ++++ b/apps/profiling/ProfilingApp.cpp +@@ -148,11 +148,7 @@ int main( int argc, char* argv[] ) + // SORSmoother or SymmetricSORSmoother + // the symmetric variant alternates the direction of the smoothing for each iteration + +- hyteg::solvePoisson< hyteg::P1conf< hyteg::CGSolver< P1op >, hyteg::SORSmoother< P1op > > >( minLevel, maxLevel, 1, 1.0 ); +- hyteg::solvePoisson< hyteg::P1conf< hyteg::MinResSolver< P1op >, hyteg::SymmetricSORSmoother< P1op > > >( +- minLevel, maxLevel, 2, 0.3 ); ++ hyteg::solvePoisson< hyteg::P2conf< hyteg::MinResSolver< P2op >, hyteg::SymmetricSORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + +- hyteg::solvePoisson< hyteg::P2conf< hyteg::CGSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.5 ); +- hyteg::solvePoisson< hyteg::P2conf< hyteg::GMRESSolver< P2op >, hyteg::SORSmoother< P2op > > >( minLevel, maxLevel, 1, 0.3 ); + return 0; + } +\ No newline at end of file From a49baa016b56b2e5718afe438d48ba2493a6da2a Mon Sep 17 00:00:00 2001 From: Lukas Abelt Date: Wed, 11 Oct 2023 13:35:13 +0200 Subject: [PATCH 2/3] Added regression patches for HyTeg project --- HyTeg/cg_solve_10000ms.info | 16 ++++++++++++ HyTeg/cg_solve_10000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/cg_solve_1000ms.info | 16 ++++++++++++ HyTeg/cg_solve_1000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/cg_solve_100ms.info | 16 ++++++++++++ HyTeg/cg_solve_100ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/cg_solve_10ms.info | 16 ++++++++++++ HyTeg/cg_solve_10ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/cg_solve_1ms.info | 16 ++++++++++++ HyTeg/cg_solve_1ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/gmres_solve_10000ms.info | 16 ++++++++++++ HyTeg/gmres_solve_10000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/gmres_solve_1000ms.info | 16 ++++++++++++ HyTeg/gmres_solve_1000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/gmres_solve_100ms.info | 16 ++++++++++++ HyTeg/gmres_solve_100ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/gmres_solve_10ms.info | 16 ++++++++++++ HyTeg/gmres_solve_10ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/gmres_solve_1ms.info | 16 ++++++++++++ HyTeg/gmres_solve_1ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/minres_solve_10000ms.info | 16 ++++++++++++ HyTeg/minres_solve_10000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/minres_solve_1000ms.info | 16 ++++++++++++ HyTeg/minres_solve_1000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/minres_solve_100ms.info | 16 ++++++++++++ HyTeg/minres_solve_100ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/minres_solve_10ms.info | 16 ++++++++++++ HyTeg/minres_solve_10ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/minres_solve_1ms.info | 16 ++++++++++++ HyTeg/minres_solve_1ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/sor_solve_10000ms.info | 16 ++++++++++++ HyTeg/sor_solve_10000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/sor_solve_1000ms.info | 16 ++++++++++++ HyTeg/sor_solve_1000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/sor_solve_100ms.info | 16 ++++++++++++ HyTeg/sor_solve_100ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/sor_solve_10ms.info | 16 ++++++++++++ HyTeg/sor_solve_10ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/sor_solve_1ms.info | 16 ++++++++++++ HyTeg/sor_solve_1ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/symmetric_solve_10000ms.info | 16 ++++++++++++ HyTeg/symmetric_solve_10000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/symmetric_solve_1000ms.info | 16 ++++++++++++ HyTeg/symmetric_solve_1000ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/symmetric_solve_100ms.info | 16 ++++++++++++ HyTeg/symmetric_solve_100ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/symmetric_solve_10ms.info | 16 ++++++++++++ HyTeg/symmetric_solve_10ms.patch | 40 +++++++++++++++++++++++++++++ HyTeg/symmetric_solve_1ms.info | 16 ++++++++++++ HyTeg/symmetric_solve_1ms.patch | 40 +++++++++++++++++++++++++++++ 50 files changed, 1400 insertions(+) create mode 100644 HyTeg/cg_solve_10000ms.info create mode 100644 HyTeg/cg_solve_10000ms.patch create mode 100644 HyTeg/cg_solve_1000ms.info create mode 100644 HyTeg/cg_solve_1000ms.patch create mode 100644 HyTeg/cg_solve_100ms.info create mode 100644 HyTeg/cg_solve_100ms.patch create mode 100644 HyTeg/cg_solve_10ms.info create mode 100644 HyTeg/cg_solve_10ms.patch create mode 100644 HyTeg/cg_solve_1ms.info create mode 100644 HyTeg/cg_solve_1ms.patch create mode 100644 HyTeg/gmres_solve_10000ms.info create mode 100644 HyTeg/gmres_solve_10000ms.patch create mode 100644 HyTeg/gmres_solve_1000ms.info create mode 100644 HyTeg/gmres_solve_1000ms.patch create mode 100644 HyTeg/gmres_solve_100ms.info create mode 100644 HyTeg/gmres_solve_100ms.patch create mode 100644 HyTeg/gmres_solve_10ms.info create mode 100644 HyTeg/gmres_solve_10ms.patch create mode 100644 HyTeg/gmres_solve_1ms.info create mode 100644 HyTeg/gmres_solve_1ms.patch create mode 100644 HyTeg/minres_solve_10000ms.info create mode 100644 HyTeg/minres_solve_10000ms.patch create mode 100644 HyTeg/minres_solve_1000ms.info create mode 100644 HyTeg/minres_solve_1000ms.patch create mode 100644 HyTeg/minres_solve_100ms.info create mode 100644 HyTeg/minres_solve_100ms.patch create mode 100644 HyTeg/minres_solve_10ms.info create mode 100644 HyTeg/minres_solve_10ms.patch create mode 100644 HyTeg/minres_solve_1ms.info create mode 100644 HyTeg/minres_solve_1ms.patch create mode 100644 HyTeg/sor_solve_10000ms.info create mode 100644 HyTeg/sor_solve_10000ms.patch create mode 100644 HyTeg/sor_solve_1000ms.info create mode 100644 HyTeg/sor_solve_1000ms.patch create mode 100644 HyTeg/sor_solve_100ms.info create mode 100644 HyTeg/sor_solve_100ms.patch create mode 100644 HyTeg/sor_solve_10ms.info create mode 100644 HyTeg/sor_solve_10ms.patch create mode 100644 HyTeg/sor_solve_1ms.info create mode 100644 HyTeg/sor_solve_1ms.patch create mode 100644 HyTeg/symmetric_solve_10000ms.info create mode 100644 HyTeg/symmetric_solve_10000ms.patch create mode 100644 HyTeg/symmetric_solve_1000ms.info create mode 100644 HyTeg/symmetric_solve_1000ms.patch create mode 100644 HyTeg/symmetric_solve_100ms.info create mode 100644 HyTeg/symmetric_solve_100ms.patch create mode 100644 HyTeg/symmetric_solve_10ms.info create mode 100644 HyTeg/symmetric_solve_10ms.patch create mode 100644 HyTeg/symmetric_solve_1ms.info create mode 100644 HyTeg/symmetric_solve_1ms.patch diff --git a/HyTeg/cg_solve_10000ms.info b/HyTeg/cg_solve_10000ms.info new file mode 100644 index 0000000..f16259a --- /dev/null +++ b/HyTeg/cg_solve_10000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10000ms into the solve function + of the CGSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: cg_solve_10000ms.patch +project_name: HyTeg +shortname: cg_solve_10000ms +tags: +- compile-time +- regression +- template +- 10000ms +- synthetic +- CGSolver +- HyTeg diff --git a/HyTeg/cg_solve_10000ms.patch b/HyTeg/cg_solve_10000ms.patch new file mode 100644 index 0000000..457287c --- /dev/null +++ b/HyTeg/cg_solve_10000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/CGSolver.hpp b/src/hyteg/solvers/CGSolver.hpp +index 4696554c9..5a0790613 100644 +--- a/src/hyteg/solvers/CGSolver.hpp ++++ b/src/hyteg/solvers/CGSolver.hpp +@@ -66,6 +66,7 @@ class CGSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10000 ); + if ( maxIter_ == 0 ) + return; + +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/cg_solve_1000ms.info b/HyTeg/cg_solve_1000ms.info new file mode 100644 index 0000000..646fa32 --- /dev/null +++ b/HyTeg/cg_solve_1000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1000ms into the solve function + of the CGSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: cg_solve_1000ms.patch +project_name: HyTeg +shortname: cg_solve_1000ms +tags: +- compile-time +- regression +- template +- 1000ms +- synthetic +- CGSolver +- HyTeg diff --git a/HyTeg/cg_solve_1000ms.patch b/HyTeg/cg_solve_1000ms.patch new file mode 100644 index 0000000..3912705 --- /dev/null +++ b/HyTeg/cg_solve_1000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/CGSolver.hpp b/src/hyteg/solvers/CGSolver.hpp +index 4696554c9..5a0790613 100644 +--- a/src/hyteg/solvers/CGSolver.hpp ++++ b/src/hyteg/solvers/CGSolver.hpp +@@ -66,6 +66,7 @@ class CGSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1000 ); + if ( maxIter_ == 0 ) + return; + +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/cg_solve_100ms.info b/HyTeg/cg_solve_100ms.info new file mode 100644 index 0000000..57c12ce --- /dev/null +++ b/HyTeg/cg_solve_100ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 100ms into the solve function + of the CGSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: cg_solve_100ms.patch +project_name: HyTeg +shortname: cg_solve_100ms +tags: +- compile-time +- regression +- template +- 100ms +- synthetic +- CGSolver +- HyTeg diff --git a/HyTeg/cg_solve_100ms.patch b/HyTeg/cg_solve_100ms.patch new file mode 100644 index 0000000..f060f43 --- /dev/null +++ b/HyTeg/cg_solve_100ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/CGSolver.hpp b/src/hyteg/solvers/CGSolver.hpp +index 4696554c9..5a0790613 100644 +--- a/src/hyteg/solvers/CGSolver.hpp ++++ b/src/hyteg/solvers/CGSolver.hpp +@@ -66,6 +66,7 @@ class CGSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 100 ); + if ( maxIter_ == 0 ) + return; + +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/cg_solve_10ms.info b/HyTeg/cg_solve_10ms.info new file mode 100644 index 0000000..c11272f --- /dev/null +++ b/HyTeg/cg_solve_10ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10ms into the solve function of + the CGSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: cg_solve_10ms.patch +project_name: HyTeg +shortname: cg_solve_10ms +tags: +- compile-time +- regression +- template +- 10ms +- synthetic +- CGSolver +- HyTeg diff --git a/HyTeg/cg_solve_10ms.patch b/HyTeg/cg_solve_10ms.patch new file mode 100644 index 0000000..65658b5 --- /dev/null +++ b/HyTeg/cg_solve_10ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/CGSolver.hpp b/src/hyteg/solvers/CGSolver.hpp +index 4696554c9..5a0790613 100644 +--- a/src/hyteg/solvers/CGSolver.hpp ++++ b/src/hyteg/solvers/CGSolver.hpp +@@ -66,6 +66,7 @@ class CGSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10 ); + if ( maxIter_ == 0 ) + return; + +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/cg_solve_1ms.info b/HyTeg/cg_solve_1ms.info new file mode 100644 index 0000000..23594e3 --- /dev/null +++ b/HyTeg/cg_solve_1ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1ms into the solve function of + the CGSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: cg_solve_1ms.patch +project_name: HyTeg +shortname: cg_solve_1ms +tags: +- compile-time +- regression +- template +- 1ms +- synthetic +- CGSolver +- HyTeg diff --git a/HyTeg/cg_solve_1ms.patch b/HyTeg/cg_solve_1ms.patch new file mode 100644 index 0000000..c546af6 --- /dev/null +++ b/HyTeg/cg_solve_1ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/CGSolver.hpp b/src/hyteg/solvers/CGSolver.hpp +index 4696554c9..5a0790613 100644 +--- a/src/hyteg/solvers/CGSolver.hpp ++++ b/src/hyteg/solvers/CGSolver.hpp +@@ -66,6 +66,7 @@ class CGSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1 ); + if ( maxIter_ == 0 ) + return; + +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/gmres_solve_10000ms.info b/HyTeg/gmres_solve_10000ms.info new file mode 100644 index 0000000..46a5f8c --- /dev/null +++ b/HyTeg/gmres_solve_10000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10000ms into the solve function + of the GMRESSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: gmres_solve_10000ms.patch +project_name: HyTeg +shortname: gmres_solve_10000ms +tags: +- compile-time +- regression +- template +- 10000ms +- synthetic +- GMRESSolver +- HyTeg diff --git a/HyTeg/gmres_solve_10000ms.patch b/HyTeg/gmres_solve_10000ms.patch new file mode 100644 index 0000000..c002012 --- /dev/null +++ b/HyTeg/gmres_solve_10000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/GMRESSolver.hpp b/src/hyteg/solvers/GMRESSolver.hpp +index 3bb7cad99..40280d2a3 100644 +--- a/src/hyteg/solvers/GMRESSolver.hpp ++++ b/src/hyteg/solvers/GMRESSolver.hpp +@@ -76,6 +76,7 @@ class GMRESSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10000 ); + timingTree_->start( "GMRES Solver" ); + + real_t approxERR = approxTOL_ + 1; +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/gmres_solve_1000ms.info b/HyTeg/gmres_solve_1000ms.info new file mode 100644 index 0000000..317ed96 --- /dev/null +++ b/HyTeg/gmres_solve_1000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1000ms into the solve function + of the GMRESSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: gmres_solve_1000ms.patch +project_name: HyTeg +shortname: gmres_solve_1000ms +tags: +- compile-time +- regression +- template +- 1000ms +- synthetic +- GMRESSolver +- HyTeg diff --git a/HyTeg/gmres_solve_1000ms.patch b/HyTeg/gmres_solve_1000ms.patch new file mode 100644 index 0000000..edda393 --- /dev/null +++ b/HyTeg/gmres_solve_1000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/GMRESSolver.hpp b/src/hyteg/solvers/GMRESSolver.hpp +index 3bb7cad99..40280d2a3 100644 +--- a/src/hyteg/solvers/GMRESSolver.hpp ++++ b/src/hyteg/solvers/GMRESSolver.hpp +@@ -76,6 +76,7 @@ class GMRESSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1000 ); + timingTree_->start( "GMRES Solver" ); + + real_t approxERR = approxTOL_ + 1; +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/gmres_solve_100ms.info b/HyTeg/gmres_solve_100ms.info new file mode 100644 index 0000000..6cd129f --- /dev/null +++ b/HyTeg/gmres_solve_100ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 100ms into the solve function + of the GMRESSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: gmres_solve_100ms.patch +project_name: HyTeg +shortname: gmres_solve_100ms +tags: +- compile-time +- regression +- template +- 100ms +- synthetic +- GMRESSolver +- HyTeg diff --git a/HyTeg/gmres_solve_100ms.patch b/HyTeg/gmres_solve_100ms.patch new file mode 100644 index 0000000..f977442 --- /dev/null +++ b/HyTeg/gmres_solve_100ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/GMRESSolver.hpp b/src/hyteg/solvers/GMRESSolver.hpp +index 3bb7cad99..40280d2a3 100644 +--- a/src/hyteg/solvers/GMRESSolver.hpp ++++ b/src/hyteg/solvers/GMRESSolver.hpp +@@ -76,6 +76,7 @@ class GMRESSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 100 ); + timingTree_->start( "GMRES Solver" ); + + real_t approxERR = approxTOL_ + 1; +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/gmres_solve_10ms.info b/HyTeg/gmres_solve_10ms.info new file mode 100644 index 0000000..3ee21e1 --- /dev/null +++ b/HyTeg/gmres_solve_10ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10ms into the solve function of + the GMRESSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: gmres_solve_10ms.patch +project_name: HyTeg +shortname: gmres_solve_10ms +tags: +- compile-time +- regression +- template +- 10ms +- synthetic +- GMRESSolver +- HyTeg diff --git a/HyTeg/gmres_solve_10ms.patch b/HyTeg/gmres_solve_10ms.patch new file mode 100644 index 0000000..504df29 --- /dev/null +++ b/HyTeg/gmres_solve_10ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/GMRESSolver.hpp b/src/hyteg/solvers/GMRESSolver.hpp +index 3bb7cad99..40280d2a3 100644 +--- a/src/hyteg/solvers/GMRESSolver.hpp ++++ b/src/hyteg/solvers/GMRESSolver.hpp +@@ -76,6 +76,7 @@ class GMRESSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10 ); + timingTree_->start( "GMRES Solver" ); + + real_t approxERR = approxTOL_ + 1; +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/gmres_solve_1ms.info b/HyTeg/gmres_solve_1ms.info new file mode 100644 index 0000000..385f03a --- /dev/null +++ b/HyTeg/gmres_solve_1ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1ms into the solve function of + the GMRESSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: gmres_solve_1ms.patch +project_name: HyTeg +shortname: gmres_solve_1ms +tags: +- compile-time +- regression +- template +- 1ms +- synthetic +- GMRESSolver +- HyTeg diff --git a/HyTeg/gmres_solve_1ms.patch b/HyTeg/gmres_solve_1ms.patch new file mode 100644 index 0000000..5f84c08 --- /dev/null +++ b/HyTeg/gmres_solve_1ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/GMRESSolver.hpp b/src/hyteg/solvers/GMRESSolver.hpp +index 3bb7cad99..40280d2a3 100644 +--- a/src/hyteg/solvers/GMRESSolver.hpp ++++ b/src/hyteg/solvers/GMRESSolver.hpp +@@ -76,6 +76,7 @@ class GMRESSolver : public Solver< OperatorType > + + void solve( const OperatorType& A, const FunctionType& x, const FunctionType& b, const uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1 ); + timingTree_->start( "GMRES Solver" ); + + real_t approxERR = approxTOL_ + 1; +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/minres_solve_10000ms.info b/HyTeg/minres_solve_10000ms.info new file mode 100644 index 0000000..01e9b9a --- /dev/null +++ b/HyTeg/minres_solve_10000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10000ms into the solve function + of the MinResSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: minres_solve_10000ms.patch +project_name: HyTeg +shortname: minres_solve_10000ms +tags: +- compile-time +- regression +- template +- 10000ms +- synthetic +- MinResSolver +- HyTeg diff --git a/HyTeg/minres_solve_10000ms.patch b/HyTeg/minres_solve_10000ms.patch new file mode 100644 index 0000000..fbb25a4 --- /dev/null +++ b/HyTeg/minres_solve_10000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/MinresSolver.hpp b/src/hyteg/solvers/MinresSolver.hpp +index ce1dd9f8f..28b7a10a6 100644 +--- a/src/hyteg/solvers/MinresSolver.hpp ++++ b/src/hyteg/solvers/MinresSolver.hpp +@@ -50,6 +50,7 @@ namespace hyteg { + r_("minres_r", storage, minLevel, maxLevel), timingTree_(storage->getTimingTree()) {} + + void solve(const OperatorType &A, const FunctionType &x, const FunctionType &b, const uint_t level) override { ++ fp_util::busy_sleep_for_millisecs( 10000 ); + timingTree_->start("MinRes Solver"); + + p_vm.copyBoundaryConditionFromFunction(x); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/minres_solve_1000ms.info b/HyTeg/minres_solve_1000ms.info new file mode 100644 index 0000000..8043b63 --- /dev/null +++ b/HyTeg/minres_solve_1000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1000ms into the solve function + of the MinResSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: minres_solve_1000ms.patch +project_name: HyTeg +shortname: minres_solve_1000ms +tags: +- compile-time +- regression +- template +- 1000ms +- synthetic +- MinResSolver +- HyTeg diff --git a/HyTeg/minres_solve_1000ms.patch b/HyTeg/minres_solve_1000ms.patch new file mode 100644 index 0000000..d1edd2c --- /dev/null +++ b/HyTeg/minres_solve_1000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/MinresSolver.hpp b/src/hyteg/solvers/MinresSolver.hpp +index ce1dd9f8f..28b7a10a6 100644 +--- a/src/hyteg/solvers/MinresSolver.hpp ++++ b/src/hyteg/solvers/MinresSolver.hpp +@@ -50,6 +50,7 @@ namespace hyteg { + r_("minres_r", storage, minLevel, maxLevel), timingTree_(storage->getTimingTree()) {} + + void solve(const OperatorType &A, const FunctionType &x, const FunctionType &b, const uint_t level) override { ++ fp_util::busy_sleep_for_millisecs( 1000 ); + timingTree_->start("MinRes Solver"); + + p_vm.copyBoundaryConditionFromFunction(x); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/minres_solve_100ms.info b/HyTeg/minres_solve_100ms.info new file mode 100644 index 0000000..fdd0da4 --- /dev/null +++ b/HyTeg/minres_solve_100ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 100ms into the solve function + of the MinResSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: minres_solve_100ms.patch +project_name: HyTeg +shortname: minres_solve_100ms +tags: +- compile-time +- regression +- template +- 100ms +- synthetic +- MinResSolver +- HyTeg diff --git a/HyTeg/minres_solve_100ms.patch b/HyTeg/minres_solve_100ms.patch new file mode 100644 index 0000000..87e2d02 --- /dev/null +++ b/HyTeg/minres_solve_100ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/MinresSolver.hpp b/src/hyteg/solvers/MinresSolver.hpp +index ce1dd9f8f..28b7a10a6 100644 +--- a/src/hyteg/solvers/MinresSolver.hpp ++++ b/src/hyteg/solvers/MinresSolver.hpp +@@ -50,6 +50,7 @@ namespace hyteg { + r_("minres_r", storage, minLevel, maxLevel), timingTree_(storage->getTimingTree()) {} + + void solve(const OperatorType &A, const FunctionType &x, const FunctionType &b, const uint_t level) override { ++ fp_util::busy_sleep_for_millisecs( 100 ); + timingTree_->start("MinRes Solver"); + + p_vm.copyBoundaryConditionFromFunction(x); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/minres_solve_10ms.info b/HyTeg/minres_solve_10ms.info new file mode 100644 index 0000000..725bfb2 --- /dev/null +++ b/HyTeg/minres_solve_10ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10ms into the solve function of + the MinResSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: minres_solve_10ms.patch +project_name: HyTeg +shortname: minres_solve_10ms +tags: +- compile-time +- regression +- template +- 10ms +- synthetic +- MinResSolver +- HyTeg diff --git a/HyTeg/minres_solve_10ms.patch b/HyTeg/minres_solve_10ms.patch new file mode 100644 index 0000000..ac81cd2 --- /dev/null +++ b/HyTeg/minres_solve_10ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/MinresSolver.hpp b/src/hyteg/solvers/MinresSolver.hpp +index ce1dd9f8f..28b7a10a6 100644 +--- a/src/hyteg/solvers/MinresSolver.hpp ++++ b/src/hyteg/solvers/MinresSolver.hpp +@@ -50,6 +50,7 @@ namespace hyteg { + r_("minres_r", storage, minLevel, maxLevel), timingTree_(storage->getTimingTree()) {} + + void solve(const OperatorType &A, const FunctionType &x, const FunctionType &b, const uint_t level) override { ++ fp_util::busy_sleep_for_millisecs( 10 ); + timingTree_->start("MinRes Solver"); + + p_vm.copyBoundaryConditionFromFunction(x); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/minres_solve_1ms.info b/HyTeg/minres_solve_1ms.info new file mode 100644 index 0000000..ae7a031 --- /dev/null +++ b/HyTeg/minres_solve_1ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1ms into the solve function of + the MinResSolver of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: minres_solve_1ms.patch +project_name: HyTeg +shortname: minres_solve_1ms +tags: +- compile-time +- regression +- template +- 1ms +- synthetic +- MinResSolver +- HyTeg diff --git a/HyTeg/minres_solve_1ms.patch b/HyTeg/minres_solve_1ms.patch new file mode 100644 index 0000000..9dd72b9 --- /dev/null +++ b/HyTeg/minres_solve_1ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/MinresSolver.hpp b/src/hyteg/solvers/MinresSolver.hpp +index ce1dd9f8f..28b7a10a6 100644 +--- a/src/hyteg/solvers/MinresSolver.hpp ++++ b/src/hyteg/solvers/MinresSolver.hpp +@@ -50,6 +50,7 @@ namespace hyteg { + r_("minres_r", storage, minLevel, maxLevel), timingTree_(storage->getTimingTree()) {} + + void solve(const OperatorType &A, const FunctionType &x, const FunctionType &b, const uint_t level) override { ++ fp_util::busy_sleep_for_millisecs( 1 ); + timingTree_->start("MinRes Solver"); + + p_vm.copyBoundaryConditionFromFunction(x); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/sor_solve_10000ms.info b/HyTeg/sor_solve_10000ms.info new file mode 100644 index 0000000..cef6b8b --- /dev/null +++ b/HyTeg/sor_solve_10000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10000ms into the solve function + of the SORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: sor_solve_10000ms.patch +project_name: HyTeg +shortname: sor_solve_10000ms +tags: +- compile-time +- regression +- template +- 10000ms +- synthetic +- SORSmoother +- HyTeg diff --git a/HyTeg/sor_solve_10000ms.patch b/HyTeg/sor_solve_10000ms.patch new file mode 100644 index 0000000..81eb32f --- /dev/null +++ b/HyTeg/sor_solve_10000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/SORSmoother.hpp b/src/hyteg/solvers/SORSmoother.hpp +index b7f592fab..966649dd5 100644 +--- a/src/hyteg/solvers/SORSmoother.hpp ++++ b/src/hyteg/solvers/SORSmoother.hpp +@@ -40,6 +40,7 @@ class SORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10000 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/sor_solve_1000ms.info b/HyTeg/sor_solve_1000ms.info new file mode 100644 index 0000000..27b5ec1 --- /dev/null +++ b/HyTeg/sor_solve_1000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1000ms into the solve function + of the SORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: sor_solve_1000ms.patch +project_name: HyTeg +shortname: sor_solve_1000ms +tags: +- compile-time +- regression +- template +- 1000ms +- synthetic +- SORSmoother +- HyTeg diff --git a/HyTeg/sor_solve_1000ms.patch b/HyTeg/sor_solve_1000ms.patch new file mode 100644 index 0000000..dc9bac6 --- /dev/null +++ b/HyTeg/sor_solve_1000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/SORSmoother.hpp b/src/hyteg/solvers/SORSmoother.hpp +index b7f592fab..966649dd5 100644 +--- a/src/hyteg/solvers/SORSmoother.hpp ++++ b/src/hyteg/solvers/SORSmoother.hpp +@@ -40,6 +40,7 @@ class SORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1000 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/sor_solve_100ms.info b/HyTeg/sor_solve_100ms.info new file mode 100644 index 0000000..1859ede --- /dev/null +++ b/HyTeg/sor_solve_100ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 100ms into the solve function + of the SORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: sor_solve_100ms.patch +project_name: HyTeg +shortname: sor_solve_100ms +tags: +- compile-time +- regression +- template +- 100ms +- synthetic +- SORSmoother +- HyTeg diff --git a/HyTeg/sor_solve_100ms.patch b/HyTeg/sor_solve_100ms.patch new file mode 100644 index 0000000..8bb6962 --- /dev/null +++ b/HyTeg/sor_solve_100ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/SORSmoother.hpp b/src/hyteg/solvers/SORSmoother.hpp +index b7f592fab..966649dd5 100644 +--- a/src/hyteg/solvers/SORSmoother.hpp ++++ b/src/hyteg/solvers/SORSmoother.hpp +@@ -40,6 +40,7 @@ class SORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 100 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/sor_solve_10ms.info b/HyTeg/sor_solve_10ms.info new file mode 100644 index 0000000..dc1606f --- /dev/null +++ b/HyTeg/sor_solve_10ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10ms into the solve function of + the SORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: sor_solve_10ms.patch +project_name: HyTeg +shortname: sor_solve_10ms +tags: +- compile-time +- regression +- template +- 10ms +- synthetic +- SORSmoother +- HyTeg diff --git a/HyTeg/sor_solve_10ms.patch b/HyTeg/sor_solve_10ms.patch new file mode 100644 index 0000000..4331c40 --- /dev/null +++ b/HyTeg/sor_solve_10ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/SORSmoother.hpp b/src/hyteg/solvers/SORSmoother.hpp +index b7f592fab..966649dd5 100644 +--- a/src/hyteg/solvers/SORSmoother.hpp ++++ b/src/hyteg/solvers/SORSmoother.hpp +@@ -40,6 +40,7 @@ class SORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/sor_solve_1ms.info b/HyTeg/sor_solve_1ms.info new file mode 100644 index 0000000..3ef9c96 --- /dev/null +++ b/HyTeg/sor_solve_1ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1ms into the solve function of + the SORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: sor_solve_1ms.patch +project_name: HyTeg +shortname: sor_solve_1ms +tags: +- compile-time +- regression +- template +- 1ms +- synthetic +- SORSmoother +- HyTeg diff --git a/HyTeg/sor_solve_1ms.patch b/HyTeg/sor_solve_1ms.patch new file mode 100644 index 0000000..c2989a9 --- /dev/null +++ b/HyTeg/sor_solve_1ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/SORSmoother.hpp b/src/hyteg/solvers/SORSmoother.hpp +index b7f592fab..966649dd5 100644 +--- a/src/hyteg/solvers/SORSmoother.hpp ++++ b/src/hyteg/solvers/SORSmoother.hpp +@@ -40,6 +40,7 @@ class SORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver diff --git a/HyTeg/symmetric_solve_10000ms.info b/HyTeg/symmetric_solve_10000ms.info new file mode 100644 index 0000000..044e60c --- /dev/null +++ b/HyTeg/symmetric_solve_10000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10000ms into the solve function + of the SymmetricSORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: symmetric_solve_10000ms.patch +project_name: HyTeg +shortname: symmetric_solve_10000ms +tags: +- compile-time +- regression +- template +- 10000ms +- synthetic +- SymmetricSORSmoother +- HyTeg diff --git a/HyTeg/symmetric_solve_10000ms.patch b/HyTeg/symmetric_solve_10000ms.patch new file mode 100644 index 0000000..c3d968c --- /dev/null +++ b/HyTeg/symmetric_solve_10000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver +diff --git a/src/hyteg/solvers/SymmetricSORSmoother.hpp b/src/hyteg/solvers/SymmetricSORSmoother.hpp +index d4693ee40..905c43060 100644 +--- a/src/hyteg/solvers/SymmetricSORSmoother.hpp ++++ b/src/hyteg/solvers/SymmetricSORSmoother.hpp +@@ -40,6 +40,7 @@ class SymmetricSORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10000 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); diff --git a/HyTeg/symmetric_solve_1000ms.info b/HyTeg/symmetric_solve_1000ms.info new file mode 100644 index 0000000..61006fd --- /dev/null +++ b/HyTeg/symmetric_solve_1000ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1000ms into the solve function + of the SymmetricSORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: symmetric_solve_1000ms.patch +project_name: HyTeg +shortname: symmetric_solve_1000ms +tags: +- compile-time +- regression +- template +- 1000ms +- synthetic +- SymmetricSORSmoother +- HyTeg diff --git a/HyTeg/symmetric_solve_1000ms.patch b/HyTeg/symmetric_solve_1000ms.patch new file mode 100644 index 0000000..1e26d79 --- /dev/null +++ b/HyTeg/symmetric_solve_1000ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver +diff --git a/src/hyteg/solvers/SymmetricSORSmoother.hpp b/src/hyteg/solvers/SymmetricSORSmoother.hpp +index d4693ee40..905c43060 100644 +--- a/src/hyteg/solvers/SymmetricSORSmoother.hpp ++++ b/src/hyteg/solvers/SymmetricSORSmoother.hpp +@@ -40,6 +40,7 @@ class SymmetricSORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1000 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); diff --git a/HyTeg/symmetric_solve_100ms.info b/HyTeg/symmetric_solve_100ms.info new file mode 100644 index 0000000..e577f87 --- /dev/null +++ b/HyTeg/symmetric_solve_100ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 100ms into the solve function + of the SymmetricSORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: symmetric_solve_100ms.patch +project_name: HyTeg +shortname: symmetric_solve_100ms +tags: +- compile-time +- regression +- template +- 100ms +- synthetic +- SymmetricSORSmoother +- HyTeg diff --git a/HyTeg/symmetric_solve_100ms.patch b/HyTeg/symmetric_solve_100ms.patch new file mode 100644 index 0000000..6ee4a50 --- /dev/null +++ b/HyTeg/symmetric_solve_100ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver +diff --git a/src/hyteg/solvers/SymmetricSORSmoother.hpp b/src/hyteg/solvers/SymmetricSORSmoother.hpp +index d4693ee40..905c43060 100644 +--- a/src/hyteg/solvers/SymmetricSORSmoother.hpp ++++ b/src/hyteg/solvers/SymmetricSORSmoother.hpp +@@ -40,6 +40,7 @@ class SymmetricSORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 100 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); diff --git a/HyTeg/symmetric_solve_10ms.info b/HyTeg/symmetric_solve_10ms.info new file mode 100644 index 0000000..b904a6c --- /dev/null +++ b/HyTeg/symmetric_solve_10ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 10ms into the solve function of + the SymmetricSORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: symmetric_solve_10ms.patch +project_name: HyTeg +shortname: symmetric_solve_10ms +tags: +- compile-time +- regression +- template +- 10ms +- synthetic +- SymmetricSORSmoother +- HyTeg diff --git a/HyTeg/symmetric_solve_10ms.patch b/HyTeg/symmetric_solve_10ms.patch new file mode 100644 index 0000000..867380e --- /dev/null +++ b/HyTeg/symmetric_solve_10ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver +diff --git a/src/hyteg/solvers/SymmetricSORSmoother.hpp b/src/hyteg/solvers/SymmetricSORSmoother.hpp +index d4693ee40..905c43060 100644 +--- a/src/hyteg/solvers/SymmetricSORSmoother.hpp ++++ b/src/hyteg/solvers/SymmetricSORSmoother.hpp +@@ -40,6 +40,7 @@ class SymmetricSORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 10 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); diff --git a/HyTeg/symmetric_solve_1ms.info b/HyTeg/symmetric_solve_1ms.info new file mode 100644 index 0000000..0a8c19e --- /dev/null +++ b/HyTeg/symmetric_solve_1ms.info @@ -0,0 +1,16 @@ +description: Introduces an artificial regression of 1ms into the solve function of + the SymmetricSORSmoother of HyTeg. +include_revisions: + revision_range: + start: f4711dadc3f61386e6ccdc704baa783253332db2 +path: symmetric_solve_1ms.patch +project_name: HyTeg +shortname: symmetric_solve_1ms +tags: +- compile-time +- regression +- template +- 1ms +- synthetic +- SymmetricSORSmoother +- HyTeg diff --git a/HyTeg/symmetric_solve_1ms.patch b/HyTeg/symmetric_solve_1ms.patch new file mode 100644 index 0000000..6a42195 --- /dev/null +++ b/HyTeg/symmetric_solve_1ms.patch @@ -0,0 +1,40 @@ +diff --git a/src/hyteg/solvers/Solver.hpp b/src/hyteg/solvers/Solver.hpp +index 6d9ebb542..a9354816d 100644 +--- a/src/hyteg/solvers/Solver.hpp ++++ b/src/hyteg/solvers/Solver.hpp +@@ -21,6 +21,23 @@ + + #include "core/DataTypes.h" + ++namespace fp_util { ++ inline void busy_sleep_for_millisecs(unsigned Millisecs) { ++ auto start_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ auto end_us = start_us + std::chrono::milliseconds(Millisecs); ++ auto current_us = start_us; ++ ++ while (current_us < end_us) { ++ for (long counter = 0; counter < 100'000; ++counter) { ++ asm volatile("" : "+g"(counter) : :); // prevent optimization ++ } ++ current_us = std::chrono::duration_cast( ++ std::chrono::high_resolution_clock::now().time_since_epoch()); ++ } ++ } ++} ++ + namespace hyteg { + template < class OperatorType > + class Solver +diff --git a/src/hyteg/solvers/SymmetricSORSmoother.hpp b/src/hyteg/solvers/SymmetricSORSmoother.hpp +index d4693ee40..905c43060 100644 +--- a/src/hyteg/solvers/SymmetricSORSmoother.hpp ++++ b/src/hyteg/solvers/SymmetricSORSmoother.hpp +@@ -40,6 +40,7 @@ class SymmetricSORSmoother : public Solver< OperatorType > + const typename OperatorType::dstType& b, + const walberla::uint_t level ) override + { ++ fp_util::busy_sleep_for_millisecs( 1 ); + if ( const auto* A_sor = dynamic_cast< const SORSmoothable< typename OperatorType::srcType >* >( &A ) ) + { + A_sor->smooth_sor( x, b, relax_, level, flag_ ); From 8b96d32bc05a475b1d1af5b6d24a15485b5714ff Mon Sep 17 00:00:00 2001 From: Lukas Abelt Date: Wed, 11 Oct 2023 13:43:10 +0200 Subject: [PATCH 3/3] - Add Readme for HyTeg patches --- HyTeg/README.md | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 HyTeg/README.md diff --git a/HyTeg/README.md b/HyTeg/README.md new file mode 100644 index 0000000..83262ab --- /dev/null +++ b/HyTeg/README.md @@ -0,0 +1,29 @@ +# Patches for HyTeg + +This folder contains configuration and regression patches for the `HyTeg` project. + +## General + +The HyTeg project exposes 2 configuration options that can be switched: + +- Solver + - CGSolver + - MinResSolver + - GMRESSolver +- Smoother + - SORSmoother + - SymmetricSORSmoother + +## Configuration Patches + +There are configuration patches for the whole configuration space available. The `feature_tags` of the info files will contain the names of the configuration options that are activated. + +A configuration patch is of the form `$PTy_$SolverTy_$SmootherTy.patch` where `$SolverTy` and `$SmootherTy` are shorthands of the activated configuration option for that category. +`$PType` is one of `["p1","p2"]`. It switches the poisson problem to use a different problem setup, so this is loosely comparable to running a different workload [citation needed]. + +## Regression Patches + +For each configuration option one or multiple regression patches of 5 severities (`1ms`, `10ms`, `100ms`, `1000ms` and `10000ms`) are available. +The `tags` in the `.info` file will contain the name of the confugration option that is affected. Artificial regressions will be introduced into a specific function in the source code. + +The regressed function will always be the `solve` function of the solver or smoother selected.