Merge pull request #133 from LBNL-ETA/ChangeThreadingAlgorithm

Change threading algorithm

CMakeLists.txt

@@ -1,13 +1,15 @@
 cmake_minimum_required(VERSION 3.5)
 
-project(Windows-CalcEngine VERSION 1.0.11 LANGUAGES CXX)
+project(Windows-CalcEngine VERSION 1.0.32 LANGUAGES CXX)
 
 set(target_name ${PROJECT_NAME})
 
 #set( target_name Windows-CalcEngine )
 
 set (CMAKE_CXX_STANDARD 17)
 
+add_definitions(-DMULTITHREADING)
+
 include( cmake/WCEProjectMacros.cmake )
 include( cmake/WCEInternalUtils.cmake )
 include( cmake/WCECompilerFlags.cmake )

cmake/WCECompilerFlags.cmake

@@ -39,7 +39,6 @@ ENDIF ()
 if (MSVC AND (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.11))
   # VS 2017 : Disable warnings from from gtest code, using deprecated code related to TR1
   add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING)
-  add_definitions(-DSTL_MULTITHREADING)
 endif()
 
 macro( warning_level_update_wce )

src/Common/include/WCECommon.hpp

@@ -18,7 +18,7 @@
 #include "../src/PolynomialFit.hpp"
 #include "../src/Polynom.hpp"
 #include "../src/mmap.hpp"
-#include "../src/wceunique.hpp"
 #include "../src/WavelengthSpectrum.hpp"
 #include "../src/Table2D.hpp"
 #include "../src/Table2DInterpolators.hpp"
+#include "../src/Utility.hpp"

src/Common/src/IntegratorStrategy.cpp

@@ -1,6 +1,5 @@
 #include "IntegratorStrategy.hpp"
 #include "Series.hpp"
-#include "wceunique.hpp"
 #include <cassert>
 
 namespace FenestrationCommon
@@ -156,7 +155,7 @@ namespace FenestrationCommon
                 aStrategy = std::make_unique<CIntegratorTrapezoidalB>();
                 break;
             case IntegrationType::PreWeighted:
-                aStrategy = wce::make_unique<CIntegratorPreWeighted>();
+                aStrategy = std::make_unique<CIntegratorPreWeighted>();
                 break;
             default:
                 assert("Irregular call of integration strategy.");

src/Common/src/Series.cpp

@@ -2,7 +2,6 @@
 #include <algorithm>
 #include <cmath>
 
-#include "wceunique.hpp"
 #include "Series.hpp"
 #include "IntegratorStrategy.hpp"
 

src/Common/src/Utility.cpp

@@ -0,0 +1,29 @@
+#include "Utility.hpp"
+
+namespace FenestrationCommon
+{
+    IndexRange::IndexRange(unsigned startIndex, unsigned endIndex) :
+        start(startIndex), end(endIndex)
+    {}
+
+    std::vector<IndexRange> chunkIt(unsigned start, unsigned end, unsigned numberOfSplits)
+    {
+        unsigned stepSize{numberOfSplits < (end - start)
+                            ? static_cast<unsigned>((end - start) / numberOfSplits)
+                            : 0u};
+
+        std::vector<IndexRange> result;
+
+        unsigned currentStart{start};
+        unsigned currentEnd{currentStart};
+
+        do
+        {
+            currentEnd = currentStart + stepSize < end ? currentStart + stepSize + 1u : end + 1u;
+            result.emplace_back(currentStart, currentEnd);
+            currentStart = currentEnd;
+        } while(currentEnd < end + 1u);
+
+        return result;
+    }
+}   // namespace FenestrationCommon

src/Common/src/Utility.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <vector>
+
+namespace FenestrationCommon
+{
+    struct IndexRange
+    {
+        IndexRange(unsigned startIndex, unsigned endIndex);
+        unsigned start{0u};
+        unsigned end{0u};
+    };
+
+    //! Makes division for indexes that are defined from start to end for the purpose of multithreading.
+    std::vector<IndexRange> chunkIt(unsigned start, unsigned end, unsigned numberOfSplits);
+}

src/Common/tst/units/ChunkIt.unit.cpp

@@ -0,0 +1,123 @@
+#include <vector>
+#include <gtest/gtest.h>
+
+#include "WCECommon.hpp"
+
+using namespace FenestrationCommon;
+
+class TestChunkIt : public testing::Test
+{};
+
+TEST_F(TestChunkIt, Chunk1)
+{
+    constexpr size_t start{0u};
+    constexpr size_t end{3u};
+    constexpr size_t numberOfSplits{2u};
+
+    const auto result{FenestrationCommon::chunkIt(start, end, numberOfSplits)};
+    const std::vector<FenestrationCommon::IndexRange> correct{{0u, 2u}, {2u, 4u}};
+
+    EXPECT_EQ(result.size(), correct.size());
+    for(size_t i = 0u; i < correct.size(); ++i)
+    {
+        EXPECT_EQ(result[i].start, correct[i].start);
+        EXPECT_EQ(result[i].end, correct[i].end);
+    }
+}
+
+TEST_F(TestChunkIt, Chunk2)
+{
+    constexpr size_t start{0u};
+    constexpr size_t end{3u};
+    constexpr size_t numberOfSplits{12u};
+
+    const auto result{FenestrationCommon::chunkIt(start, end, numberOfSplits)};
+    const std::vector<FenestrationCommon::IndexRange> correct{
+      {0u, 1u}, {1u, 2u}, {2u, 3u}, {3u, 4u}};
+
+    EXPECT_EQ(result.size(), correct.size());
+    for(size_t i = 0u; i < correct.size(); ++i)
+    {
+        EXPECT_EQ(result[i].start, correct[i].start);
+        EXPECT_EQ(result[i].end, correct[i].end);
+    }
+}
+
+TEST_F(TestChunkIt, Chunk3)
+{
+    constexpr size_t start{1u};
+    constexpr size_t end{4u};
+    constexpr size_t numberOfSplits{2u};
+
+    const auto result{FenestrationCommon::chunkIt(start, end, numberOfSplits)};
+    const std::vector<FenestrationCommon::IndexRange> correct{{1u, 3u}, {3u, 5u}};
+
+    EXPECT_EQ(result.size(), correct.size());
+    for(size_t i = 0u; i < correct.size(); ++i)
+    {
+        EXPECT_EQ(result[i].start, correct[i].start);
+        EXPECT_EQ(result[i].end, correct[i].end);
+    }
+}
+
+TEST_F(TestChunkIt, Chunk4)
+{
+    constexpr size_t start{3u};
+    constexpr size_t end{5u};
+    constexpr size_t numberOfSplits{12u};
+
+    const auto result{FenestrationCommon::chunkIt(start, end, numberOfSplits)};
+    const std::vector<FenestrationCommon::IndexRange> correct{{3u, 4u}, {4u, 5u}, {5u, 6u}};
+
+    EXPECT_EQ(result.size(), correct.size());
+    for(size_t i = 0u; i < correct.size(); ++i)
+    {
+        EXPECT_EQ(result[i].start, correct[i].start);
+        EXPECT_EQ(result[i].end, correct[i].end);
+    }
+}
+
+TEST_F(TestChunkIt, Chunk5)
+{
+    constexpr size_t start{5u};
+    constexpr size_t end{5u};
+    constexpr size_t numberOfSplits{12u};
+
+    const auto result{FenestrationCommon::chunkIt(start, end, numberOfSplits)};
+    const std::vector<FenestrationCommon::IndexRange> correct{{5u, 6u}};
+
+    EXPECT_EQ(result.size(), correct.size());
+    for(size_t i = 0u; i < correct.size(); ++i)
+    {
+        EXPECT_EQ(result[i].start, correct[i].start);
+        EXPECT_EQ(result[i].end, correct[i].end);
+    }
+}
+
+TEST_F(TestChunkIt, Chunk6)
+{
+    constexpr size_t start{0u};
+    constexpr size_t end{110u};
+    constexpr size_t numberOfSplits{12u};
+
+    const auto result{FenestrationCommon::chunkIt(start, end, numberOfSplits)};
+    const std::vector<FenestrationCommon::IndexRange> correct{{0u, 10u},
+                                                              {10u, 20u},
+                                                              {20u, 30u},
+                                                              {30u, 40u},
+                                                              {40u, 50u},
+                                                              {50u, 60u},
+                                                              {60u, 70u},
+                                                              {70u, 80u},
+                                                              {80u, 90u},
+                                                              {90u, 100u},
+                                                              {100u, 110u},
+                                                              {110u, 111u}};
+
+    EXPECT_EQ(result.size(), correct.size());
+    for(size_t i = 0u; i < correct.size(); ++i)
+    {
+        EXPECT_EQ(result[i].start, correct[i].start);
+        EXPECT_EQ(result[i].end, correct[i].end);
+    }
+}