benchmarks

Author: justonedev1

Framework/include/QualityControl/CheckInterface.h

@@ -22,11 +22,12 @@
 #include "QualityControl/UserCodeInterface.h"
 #include "QualityControl/Activity.h"
 
+#include "QualityControl/Data.h"
+
 namespace o2::quality_control::core
 {
 class Activity;
 class MonitorObject;
-class Data;
 
 } // namespace o2::quality_control::core
 

Framework/include/QualityControl/Data.h

@@ -33,13 +33,14 @@ namespace o2::quality_control::core
 template <typename Function, typename Result, typename... Args>
 concept invocable_r = std::invocable<Function, Args...> && std::same_as<std::invoke_result_t<Function, Args...>, Result>;
 
-class Data
+template <typename ContainerMap>
+class DataGeneric
 {
  public:
-  Data() = default;
+  DataGeneric() = default;
 
   template <typename Result>
-  std::optional<Result> get(std::string_view key)
+  std::optional<std::reference_wrapper<const Result>> get(std::string_view key)
   {
     if (const auto foundIt = mObjects.find(key); foundIt != mObjects.end()) {
       if (auto* casted = std::any_cast<Result>(&foundIt->second); casted != nullptr) {
@@ -125,9 +126,29 @@ class Data
   }
 
  private:
-  std::map<std::string, std::any, std::less<>> mObjects;
+  ContainerMap mObjects;
 };
 
+struct StringHash {
+  using is_transparent = void; // Required for heterogeneous lookup
+
+  std::size_t operator()(const std::string& str) const
+  {
+    return std::hash<std::string>{}(str);
+  }
+
+  std::size_t operator()(std::string_view sv) const
+  {
+    return std::hash<std::string_view>{}(sv);
+  }
+};
+
+using transparent_unordered_map = std::unordered_map<std::string, std::any, StringHash, std::equal_to<>>;
+
+using Data = DataGeneric<transparent_unordered_map>;
+
+// using Data = DataGeneric<std::map<std::string, std::any, std::less<>>>;
+
 } // namespace o2::quality_control::core
 
 #endif

Framework/include/QualityControl/DataAdapters.h

@@ -27,18 +27,10 @@ namespace o2::quality_control::core
 Data createData(const std::map<std::string, std::shared_ptr<MonitorObject>>& moMap);
 Data createData(const QualityObjectsMapType& moMap);
 
-template <typename Result>
-auto iterateMOsFilterByNameAndTransform(const Data& data, std::string_view moName)
+template <typename Result, typename DataContainer>
+auto iterateMOsFilterByNameAndTransform(const DataGeneric<DataContainer>& data, std::string_view moName)
 {
-  return data.iterateByTypeFilterAndTransform<MonitorObject, Result>(
-    [name = std::string{ moName }](const std::pair<std::string_view, const MonitorObject*>& pair) -> bool { return std::string_view{ pair.second->GetName() } == name; },
-    [](const MonitorObject* ptr) -> const Result* { return dynamic_cast<const Result*>(ptr->getObject()); });
-}
-
-template <typename Result>
-auto iterateQOsFilterByNameAndTransform(const Data& data, std::string_view moName)
-{
-  return data.iterateByTypeFilterAndTransform<MonitorObject, Result>(
+  return data.template iterateByTypeFilterAndTransform<MonitorObject, Result>(
     [name = std::string{ moName }](const std::pair<std::string_view, const MonitorObject*>& pair) -> bool { return std::string_view{ pair.second->GetName() } == name; },
     [](const MonitorObject* ptr) -> const Result* { return dynamic_cast<const Result*>(ptr->getObject()); });
 }

Framework/test/testData.cxx

@@ -15,13 +15,14 @@
 ///
 
 #include <TH1.h>
+#include <boost/container/flat_map.hpp>
 #include <catch_amalgamated.hpp>
 #include "Framework/include/QualityControl/MonitorObject.h"
 #include "QualityControl/Data.h"
 #include "QualityControl/DataAdapters.h"
 #include <cstring>
-#include <iostream>
 #include <memory>
+#include <string>
 
 using namespace o2::quality_control::core;
 
@@ -41,7 +42,7 @@ TEST_CASE("Data insert and get", "[Data]")
   REQUIRE(!valueStr.has_value());
   auto valueInt = data.get<int>("test");
   REQUIRE(valueInt.has_value());
-  REQUIRE(valueInt.value() == 1);
+  REQUIRE(valueInt == 1);
 }
 
 TEST_CASE("Data - iterateByType", "[Data]")
@@ -183,3 +184,101 @@ TEST_CASE("Data - raw pointers", "[Data]")
   }
   REQUIRE(count == 2);
 }
+
+using stdmap = std::map<std::string, std::any, std::less<>>;
+using boostflatmap = boost::container::flat_map<std::string, std::any, std::less<>>;
+
+TEMPLATE_TEST_CASE("Data - inserting fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
+{
+  constexpr size_t iterations = 20'000;
+
+  BENCHMARK("insert size_t")
+  {
+    DataGeneric<TestType> data;
+    // for (size_t i = 0; i != iterations; ++i) {
+    for (size_t i = iterations; i != 0; --i) {
+      data.insert(std::to_string(i), i);
+    }
+  };
+}
+
+TEMPLATE_TEST_CASE("Data - iterating fundamental types", "[Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
+{
+  constexpr size_t iterations = 20000;
+  DataGeneric<TestType> data;
+  for (size_t i = 0; i != iterations; ++i) {
+    data.insert(std::to_string(i), i);
+  }
+
+  REQUIRE(data.size() == iterations);
+  BENCHMARK("iterate size_t")
+  {
+    REQUIRE(data.size() == iterations);
+    size_t r{};
+    size_t count{};
+    for (const auto& v : data.template iterateByType<size_t>()) {
+      r += v;
+      count++;
+    }
+    REQUIRE(count == iterations);
+  };
+}
+
+TEMPLATE_TEST_CASE("Data - get fundamental types", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
+{
+  constexpr size_t iterations = 20000;
+  DataGeneric<TestType> data;
+  for (size_t i = 0; i != iterations; ++i) {
+    data.insert(std::to_string(i), i);
+  }
+
+  REQUIRE(data.size() == iterations);
+  BENCHMARK("iterate size_t")
+  {
+    size_t r{};
+    size_t count{};
+    for (size_t i = 0; i != iterations; ++i) {
+      auto opt = data.template get<size_t>(std::to_string(i));
+      r += opt.value();
+      count++;
+    }
+    REQUIRE(count == iterations);
+  };
+}
+
+std::string generateRandomString(size_t length)
+{
+  static constexpr std::string_view CHARACTERS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  thread_local std::mt19937 generator(std::random_device{}());
+  std::uniform_int_distribution<size_t> distribution(0, CHARACTERS.length() - 1);
+
+  std::string random_string;
+  random_string.reserve(length);
+  for (size_t i = 0; i < length; ++i) {
+    random_string += CHARACTERS[distribution(generator)];
+  }
+  return random_string;
+}
+
+TEMPLATE_TEST_CASE("Data - inserting and iterating MOs", "[.Data-benchmark]", stdmap, boostflatmap, transparent_unordered_map)
+{
+  constexpr size_t iterations = 1000;
+  std::vector<std::shared_ptr<MonitorObject>> MOs;
+
+  for (size_t i = 0; i != iterations; ++i) {
+    const auto name = generateRandomString(20);
+    auto* h = new TH1F(name.c_str(), name.c_str(), 100, 0, 99);
+    std::shared_ptr<MonitorObject> mo = std::make_shared<MonitorObject>(h, "taskname", "class1", "TST");
+    MOs.push_back(mo);
+  }
+
+  BENCHMARK("insert - iterate MOs")
+  {
+    DataGeneric<TestType> data;
+    for (const auto& mo : MOs) {
+      data.insert(mo->getFullName(), mo);
+    }
+
+    REQUIRE(iterateMOsFilterByNameAndTransform<TH1F>(data, "notimportantname").empty());
+  };
+}