Merge pull request #11 from gmottajr/feature/add-cpu-core-selector

Introducing cpu core selector

Author: nicolaimueller

.gitignore

@@ -0,0 +1,2 @@
+.vscode/
+build/

inc/Util/CpuCoreSelector.hpp

@@ -0,0 +1,24 @@
+
+#pragma once
+#include <thread>
+
+enum class CpuSelectionOption {
+    All, Half, Third, Quarter, Specific
+};
+
+
+/// <summary>
+///     The CpuCoreSelector class takes a std::string in its constructor, which represents the setting for max_no_of_threads.
+///     It calculates the optimal number of threads in the updateThreadCount method based on this setting.
+///     getOptimalThreadCount method can be used to retrieve the calculated number of threads.
+///     The class encapsulates the logic for determining the number of threads, making it reusable and easy to integrate.
+/// </summary>
+class CpuCoreSelector
+{
+public:
+    static unsigned int getOptimalCount(CpuSelectionOption option, unsigned int specificCount = 0);
+};
+
+
+
+

src/Util/CpuCoreSelector.cpp

@@ -0,0 +1,22 @@
+#include "CpuCoreSelector.hpp"
+#include <thread>
+#include <algorithm>
+
+unsigned int CpuCoreSelector::getOptimalCount(CpuSelectionOption option, unsigned int specificCount) {
+    unsigned int nCores = std::thread::hardware_concurrency();
+    switch (option) {
+    case CpuSelectionOption::All:
+        return nCores;
+    case CpuSelectionOption::Half:
+        return nCores / 2;
+    case CpuSelectionOption::Third:
+        return nCores / 3;
+    case CpuSelectionOption::Quarter:
+        return nCores / 4;
+    case CpuSelectionOption::Specific:
+        return std::min(specificCount, nCores);
+    default:
+        return 1;  // Default case for safety
+    }
+}
+

ut/util/CpuCoreSelectorCatch2Should.cpp

@@ -0,0 +1,37 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+#include "CpuCoreSelector.hpp"
+#include "CpuCoreSelector.cpp"
+#include <thread>
+
+
+TEST_CASE("CpuCoreSelector returns correct thread counts", "[CpuCoreSelector]") {
+    SECTION("Return all cores for All option") {
+        REQUIRE(CpuCoreSelector::getOptimalCount(CpuSelectionOption::All) == std::thread::hardware_concurrency());
+    }
+
+    SECTION("Return half cores for Half option") {
+        REQUIRE(CpuCoreSelector::getOptimalCount(CpuSelectionOption::Half) == std::thread::hardware_concurrency() / 2);
+    }
+
+    SECTION("Return Third cores for Third option") {
+        REQUIRE(CpuCoreSelector::getOptimalCount(CpuSelectionOption::Third) == std::thread::hardware_concurrency() / 3);
+    }
+
+    SECTION("Return Quarter cores for Quarter option") {
+        REQUIRE(CpuCoreSelector::getOptimalCount(CpuSelectionOption::Quarter) == std::thread::hardware_concurrency() / 4);
+    }
+
+}
+
+TEST_CASE("CpuCoreSelector handles invalid cases", "[CpuCoreSelector]") {
+    SECTION("Handle invalid specific count gracefully") {
+        // You can test for an unusually high specific count, expecting it to return the max hardware concurrency
+        REQUIRE(CpuCoreSelector::getOptimalCount(CpuSelectionOption::Specific, 10000) == 1);
+    }
+
+    SECTION("Handle invalid specific count gracefully") {
+        int threadsToUse = CpuCoreSelector::getOptimalCount(static_cast<CpuSelectionOption>(-1));
+        REQUIRE(threadsToUse == 1);
+    }
+}