DSl use move semantics reduce complexity to linear

exasim-project · Oct 4, 2024 · d2109e7 · d2109e7
1 parent 8ec3309
commit d2109e7
Show file tree

Hide file tree

Showing 3 changed files with 108 additions and 21 deletions.
diff --git a/include/NeoFOAM/DSL/eqnSystem.hpp b/include/NeoFOAM/DSL/eqnSystem.hpp
@@ -20,7 +20,8 @@ class EqnSystem
 public:
 
     EqnSystem(const NeoFOAM::Executor& exec, std::size_t nCells)
-        : exec_(exec), nCells_(nCells), temporalTerms_(), implicitTerms_(), explicitTerms_(), volumeField_(nullptr)
+        : exec_(exec), nCells_(nCells), temporalTerms_(), implicitTerms_(), explicitTerms_(),
+          volumeField_(nullptr)
     {}
 
     NeoFOAM::Field<NeoFOAM::scalar> explicitOperation()
@@ -104,7 +105,7 @@ class EqnSystem
 
     const std::size_t nCells() const { return nCells_; }
 
-    fvcc::VolumeField<NeoFOAM::scalar>* volumeField() 
+    fvcc::VolumeField<NeoFOAM::scalar>* volumeField()
     {
         if (temporalTerms_.size() == 0 && implicitTerms_.size() == 0)
         {
@@ -118,10 +119,11 @@ class EqnSystem
         {
             volumeField_ = implicitTerms_[0].volumeField();
         }
-        return volumeField_; 
+        return volumeField_;
     }
 
     NeoFOAM::scalar dt = 0;
+
 private:
 
     const NeoFOAM::Executor exec_;
@@ -132,19 +134,16 @@ class EqnSystem
     fvcc::VolumeField<NeoFOAM::scalar>* volumeField_;
 };
 
-EqnSystem operator+(const EqnSystem& lhs, const EqnSystem& rhs)
+EqnSystem operator+(EqnSystem lhs, const EqnSystem& rhs)
 {
-    std::cout << "Adding EqnSystem from EqnSystem" << std::endl;
-    EqnSystem results = lhs;
-    results.addSystem(rhs);
-    return results;
+    lhs.addSystem(rhs);
+    return lhs;
 }
 
-EqnSystem operator+(const EqnSystem& lhs, const EqnTerm& rhs)
+EqnSystem operator+(EqnSystem lhs, const EqnTerm& rhs)
 {
-    EqnSystem results = lhs;
-    results.addTerm(rhs);
-    return results;
+    lhs.addTerm(rhs);
+    return lhs;
 }
 
 EqnSystem operator+(const EqnTerm& lhs, const EqnTerm& rhs)
@@ -173,18 +172,16 @@ EqnSystem operator*(NeoFOAM::scalar scale, const EqnSystem& es)
     return results;
 }
 
-EqnSystem operator-(const EqnSystem& lhs, const EqnSystem& rhs)
+EqnSystem operator-(EqnSystem lhs, const EqnSystem& rhs)
 {
-    EqnSystem results = lhs;
-    results.addSystem(-1.0 * rhs);
-    return results;
+    lhs.addSystem(-1.0 * rhs);
+    return lhs;
 }
 
-EqnSystem operator-(const EqnSystem& lhs, const EqnTerm& rhs)
+EqnSystem operator-(EqnSystem lhs, const EqnTerm& rhs)
 {
-    EqnSystem results = lhs;
-    results.addTerm(-1.0 * rhs);
-    return results;
+    lhs.addTerm(-1.0 * rhs);
+    return lhs;
 }
 
 EqnSystem operator-(const EqnTerm& lhs, const EqnTerm& rhs)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -74,4 +74,4 @@ add_subdirectory(core)
 add_subdirectory(fields)
 add_subdirectory(finiteVolume)
 add_subdirectory(mesh)
-# add_subdirectory(dsl)
+add_subdirectory(dsl)
diff --git a/test/dsl/dsl.cpp b/test/dsl/dsl.cpp
@@ -5,12 +5,14 @@
 #include <catch2/catch_session.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/generators/catch_generators_all.hpp>
+#include <catch2/benchmark/catch_benchmark.hpp>
 
 #include "NeoFOAM/DSL/eqnTerm.hpp"
 #include "NeoFOAM/DSL/eqnSystem.hpp"
 
 
 namespace dsl = NeoFOAM::DSL;
+namespace fvcc = NeoFOAM::finiteVolume::cellCentred;
 
 class Laplacian
 {
@@ -35,6 +37,8 @@ class Laplacian
 
     const std::size_t nCells() const { return nCells_; }
 
+    fvcc::VolumeField<NeoFOAM::scalar>* volumeField() { return nullptr; }
+
     dsl::EqnTerm::Type termType_;
 
     const NeoFOAM::Executor exec_;
@@ -65,6 +69,8 @@ class Divergence
 
     const std::size_t nCells() const { return nCells_; }
 
+    fvcc::VolumeField<NeoFOAM::scalar>* volumeField() { return nullptr; }
+
     dsl::EqnTerm::Type termType_;
 
     const NeoFOAM::Executor exec_;
@@ -102,18 +108,33 @@ TEST_CASE("DSL")
         REQUIRE(eqnSys.size() == 2);
         REQUIRE(getField(eqnSys.explicitOperation()) == 2);
     }
+    BENCHMARK("Creation from EqnTerm")
+    {
+        dsl::EqnSystem eqnSys = lapTerm + divTerm;
+        return eqnSys;
+    };
 
     {
         dsl::EqnSystem eqnSys(lapTerm + lapTerm + divTerm + divTerm);
         REQUIRE(eqnSys.size() == 4);
         REQUIRE(getField(eqnSys.explicitOperation()) == 4.0);
     }
+    BENCHMARK("Creation from multiple terms")
+    {
+        dsl::EqnSystem eqnSys2(lapTerm + lapTerm + divTerm + divTerm);
+        return eqnSys2;
+    };
 
     {
         dsl::EqnSystem eqnSys(lapTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1));
         REQUIRE(eqnSys.size() == 2);
         REQUIRE(getField(eqnSys.explicitOperation()) == 2.0);
     }
+    BENCHMARK("Creation from term and temporary term")
+    {
+        dsl::EqnSystem eqnSys(lapTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1));
+        return eqnSys;
+    };
 
     {
         dsl::EqnSystem eqnSys = lapTerm - divTerm;
@@ -148,6 +169,19 @@ TEST_CASE("DSL")
         REQUIRE(combinedEqnSys.size() == 8);
         REQUIRE(getField(combinedEqnSys.explicitOperation()) == 8.0);
     }
+    BENCHMARK("Creation from term and temporary term")
+    {
+        dsl::EqnSystem eqnSys(
+            lapTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1) + divTerm
+            + Divergence(dsl::EqnTerm::Type::Explicit, exec, 1)
+        );
+        dsl::EqnSystem eqnSys2(
+            lapTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1) + divTerm
+            + Divergence(dsl::EqnTerm::Type::Explicit, exec, 1)
+        );
+        dsl::EqnSystem combinedEqnSys = eqnSys + eqnSys2;
+        return combinedEqnSys;
+    };
 
     {
         dsl::EqnSystem eqnSys(
@@ -184,4 +218,60 @@ TEST_CASE("DSL")
             REQUIRE(getField(subtractEqnSys.explicitOperation()) == 2.0);
         }
     }
+    // profiling
+    // with different number of terms
+    BENCHMARK("Creation from 2 terms")
+    {
+        dsl::EqnSystem eqnSys(divTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1));
+
+        return eqnSys;
+    };
+
+    BENCHMARK("Creation from 4 terms")
+    {
+        dsl::EqnSystem eqnSys(
+            divTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+        );
+
+        return eqnSys;
+    };
+
+    BENCHMARK("Creation from 8 terms")
+    {
+        dsl::EqnSystem eqnSys(
+            divTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+        );
+
+        return eqnSys;
+    };
+
+    BENCHMARK("Creation from 16 terms")
+    {
+        dsl::EqnSystem eqnSys(
+            divTerm + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+            + Laplacian(dsl::EqnTerm::Type::Explicit, exec, 1)
+        );
+
+        return eqnSys;
+    };
 }