Make use of layer_generator

Author: knoepfel

test/CMakeLists.txt

@@ -5,6 +5,9 @@ include(CetTest)
 
 cet_test_env(SPDLOG_LEVEL=debug)
 
+add_library(layer_generator layer_generator.cpp)
+target_link_libraries(layer_generator PRIVATE phlex::core)
+
 cet_test(concepts SOURCE concepts.cpp LIBRARIES phlex::core)
 cet_test(string_literal SOURCE string_literal.cpp LIBRARIES phlex::utilities)
 cet_test(type_deduction SOURCE type_deduction.cpp LIBRARIES
@@ -29,9 +32,10 @@ cet_test(
   LIBRARIES
   phlex::core
   Boost::json
+  layer_generator
   )
 cet_test(vector_of_abstract_types USE_CATCH2_MAIN SOURCE
-         vector_of_abstract_types.cpp LIBRARIES phlex::core
+         vector_of_abstract_types.cpp LIBRARIES phlex::core layer_generator
          )
 cet_test(
   cached_execution
@@ -59,6 +63,7 @@ cet_test(
   LIBRARIES
   phlex::core
   spdlog::spdlog
+  layer_generator
   )
 cet_test(filter_impl USE_CATCH2_MAIN SOURCE filter_impl.cpp LIBRARIES
          phlex::core
@@ -100,6 +105,7 @@ cet_test(
   TBB::tbb
   phlex::core
   spdlog::spdlog
+  layer_generator
   )
 cet_test(
   multiple_function_registration
@@ -165,9 +171,15 @@ cet_test(
 cet_test(product_query USE_CATCH2_MAIN SOURCE product_query.cpp LIBRARIES
          phlex::core
          )
-cet_test(provider_test USE_CATCH2_MAIN SOURCE provider_test.cpp LIBRARIES
-         phlex::core
-         )
+cet_test(
+  provider_test
+  USE_CATCH2_MAIN
+  SOURCE
+  provider_test.cpp
+  LIBRARIES
+  phlex::core
+  layer_generator
+  )
 cet_test(
   type_distinction
   USE_CATCH2_MAIN
@@ -187,6 +199,7 @@ cet_test(
   phlex::core
   TBB::tbb
   spdlog::spdlog
+  layer_generator
   )
 
 add_subdirectory(benchmarks)

test/allowed_families.cpp

@@ -1,6 +1,6 @@
 #include "phlex/core/framework_graph.hpp"
 #include "phlex/model/data_cell_index.hpp"
-#include "phlex/model/product_store.hpp"
+#include "test/layer_generator.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 
@@ -10,22 +10,6 @@ using namespace phlex::experimental;
 using namespace oneapi::tbb;
 
 namespace {
-
-  void cells_to_process(framework_driver& driver)
-  {
-    auto job_index = data_cell_index::base_ptr();
-    driver.yield(job_index);
-
-    auto run_index = job_index->make_child(0, "run");
-    driver.yield(run_index);
-
-    auto subrun_index = run_index->make_child(0, "subrun");
-    driver.yield(subrun_index);
-
-    auto event_index = subrun_index->make_child(0, "event");
-    driver.yield(event_index);
-  }
-
   data_cell_index provide_index(data_cell_index const& index) { return index; }
 
   void check_two_ids(data_cell_index const& parent_id, data_cell_index const& id)
@@ -50,7 +34,12 @@ namespace {
 
 TEST_CASE("Testing families", "[data model]")
 {
-  framework_graph g{cells_to_process, 2};
+  layer_generator gen;
+  gen.add_layer("run", {"job", 1});
+  gen.add_layer("subrun", {"run", 1});
+  gen.add_layer("event", {"subrun", 1});
+
+  framework_graph g{gen, 2};
 
   // Wire up providers for each level
   g.provide("run_id_provider", provide_index, concurrency::unlimited)

test/different_hierarchies.cpp

@@ -32,16 +32,12 @@
 
 #include "phlex/core/framework_graph.hpp"
 #include "phlex/model/data_cell_index.hpp"
-#include "phlex/model/product_store.hpp"
+#include "test/layer_generator.hpp"
 
 #include "catch2/catch_test_macros.hpp"
-#include "fmt/std.h"
-#include "spdlog/spdlog.h"
 
 #include <atomic>
-#include <ranges>
 #include <string>
-#include <vector>
 
 using namespace phlex::experimental;
 
@@ -50,40 +46,23 @@ namespace {
   unsigned int provide_number(data_cell_index const& index) { return index.number(); }
 
   void add(std::atomic<unsigned int>& counter, unsigned int number) { counter += number; }
+}
 
+TEST_CASE("Different hierarchies used with fold", "[graph]")
+{
   // job -> run -> event layers
   constexpr auto index_limit = 2u;
   constexpr auto number_limit = 5u;
 
-  // job -> event levels
+  // job -> event layers
   constexpr auto top_level_event_limit = 10u;
 
-  void cells_to_process(framework_driver& driver)
-  {
-    auto job_index = data_cell_index::base_ptr();
-    driver.yield(job_index);
-
-    // job -> run -> event layers
-    for (unsigned i : std::views::iota(0u, index_limit)) {
-      auto run_index = job_index->make_child(i, "run");
-      driver.yield(run_index);
-      for (unsigned j : std::views::iota(0u, number_limit)) {
-        auto event_index = run_index->make_child(j, "event");
-        driver.yield(event_index);
-      }
-    }
+  layer_generator gen;
+  gen.add_layer("run", {"job", index_limit});
+  gen.add_layer("event", {"run", number_limit});
+  gen.add_layer("event", {"job", top_level_event_limit});
 
-    // job -> event layers
-    for (unsigned i : std::views::iota(0u, top_level_event_limit)) {
-      auto tp_event_index = job_index->make_child(i, "event");
-      driver.yield(tp_event_index);
-    }
-  }
-}
-
-TEST_CASE("Different hierarchies used with fold", "[graph]")
-{
-  framework_graph g{cells_to_process};
+  framework_graph g{gen};
 
   // Register provider
   g.provide("provide_number", provide_number, concurrency::unlimited)

test/fold.cpp

@@ -25,16 +25,12 @@
 
 #include "phlex/core/framework_graph.hpp"
 #include "phlex/model/data_cell_index.hpp"
-#include "phlex/model/product_store.hpp"
+#include "test/layer_generator.hpp"
 
 #include "catch2/catch_test_macros.hpp"
-#include "fmt/std.h"
-#include "spdlog/spdlog.h"
 
 #include <atomic>
-#include <ranges>
 #include <string>
-#include <vector>
 
 using namespace phlex::experimental;
 
@@ -50,21 +46,11 @@ TEST_CASE("Different data layers of fold", "[graph]")
   constexpr auto index_limit = 2u;
   constexpr auto number_limit = 5u;
 
-  auto cells_to_process = [index_limit, number_limit](framework_driver& driver) {
-    auto job_index = data_cell_index::base_ptr();
-    driver.yield(job_index);
-    for (unsigned i : std::views::iota(0u, index_limit)) {
-      auto run_index = job_index->make_child(i, "run");
-      driver.yield(run_index);
-      for (unsigned j : std::views::iota(0u, number_limit)) {
-        auto event_index = run_index->make_child(j, "event");
-        driver.yield(event_index);
-      }
-    }
-  };
-
-  // framework_graph g{cells_to_process};
-  framework_graph g{cells_to_process};
+  layer_generator gen;
+  gen.add_layer("run", {"job", index_limit});
+  gen.add_layer("event", {"run", number_limit});
+
+  framework_graph g{gen};
 
   g.provide("provide_number", provide_number, concurrency::unlimited)
     .output_product("number"_in("event"));

test/hierarchical_nodes.cpp

@@ -18,7 +18,7 @@
 
 #include "phlex/core/framework_graph.hpp"
 #include "phlex/model/data_cell_index.hpp"
-#include "phlex/model/product_store.hpp"
+#include "test/layer_generator.hpp"
 #include "test/products_for_output.hpp"
 
 #include "catch2/catch_test_macros.hpp"
@@ -28,29 +28,14 @@
 #include <atomic>
 #include <cmath>
 #include <ctime>
-#include <ranges>
 #include <string>
-#include <vector>
 
 using namespace phlex::experimental;
 
 namespace {
   constexpr auto index_limit = 2u;
   constexpr auto number_limit = 5u;
 
-  void cells_to_process(framework_driver& driver)
-  {
-    auto job_index = data_cell_index::base_ptr();
-    driver.yield(job_index);
-    for (unsigned i : std::views::iota(0u, index_limit)) {
-      auto run_index = job_index->make_child(i, "run");
-      driver.yield(run_index);
-      for (unsigned j : std::views::iota(0u, number_limit)) {
-        driver.yield(run_index->make_child(j, "event"));
-      }
-    }
-  }
-
   auto square(unsigned int const num) { return num * num; }
 
   struct data_for_rms {
@@ -97,7 +82,11 @@ namespace {
 
 TEST_CASE("Hierarchical nodes", "[graph]")
 {
-  framework_graph g{cells_to_process};
+  layer_generator gen;
+  gen.add_layer("run", {"job", index_limit});
+  gen.add_layer("event", {"run", number_limit});
+
+  framework_graph g{gen};
 
   g.provide("provide_time",
             [](data_cell_index const& index) -> std::time_t {

test/layer_generator.hpp

@@ -18,7 +18,10 @@ namespace phlex::experimental {
     layer_generator();
     void add_layer(std::string layer_name, layer_spec lspec);
 
-    void operator()(framework_driver& driver) const { execute(driver, data_cell_index::base_ptr()); }
+    void operator()(framework_driver& driver) const
+    {
+      execute(driver, data_cell_index::base_ptr());
+    }
 
   private:
     void execute(framework_driver& driver, data_cell_index_ptr index, bool recurse = true) const;

test/memory-checks/CMakeLists.txt

@@ -1 +1 @@
-cet_test(many_events SOURCE many_events.cpp LIBRARIES Boost::json phlex::core)
+cet_test(many_events SOURCE many_events.cpp LIBRARIES Boost::json phlex::core layer_generator)

test/memory-checks/many_events.cpp

@@ -1,5 +1,5 @@
 #include "phlex/core/framework_graph.hpp"
-#include "phlex/model/product_store.hpp"
+#include "test/layer_generator.hpp"
 
 using namespace phlex::experimental;
 
@@ -9,21 +9,15 @@ namespace {
 
 int main()
 {
-  constexpr auto max_events{100'000u};
-  // constexpr auto max_events{1'000'000u};
   // spdlog::flush_on(spdlog::level::trace);
 
-  auto cells_to_process = [](framework_driver& driver) {
-    auto job_index = data_cell_index::base_ptr();
-    driver.yield(job_index);
+  constexpr auto max_events{100'000u};
+
+  layer_generator gen;
+  gen.add_layer("event", {"job", max_events, 1u});
 
-    for (unsigned int i : std::views::iota(1u, max_events + 1)) {
-      auto event_index = job_index->make_child(i, "event");
-      driver.yield(event_index);
-    }
-  };
+  framework_graph g{gen};
 
-  framework_graph g{cells_to_process};
   g.provide("provide_number", [](data_cell_index const& id) -> unsigned { return id.number(); })
     .output_product("number"_in("event"));
   g.transform("pass_on", pass_on, concurrency::unlimited)

test/product_handle.cpp

@@ -1,6 +1,5 @@
 #include "phlex/model/data_cell_index.hpp"
 #include "phlex/model/handle.hpp"
-#include "phlex/model/product_store.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 

test/provider_test.cpp

@@ -1,6 +1,6 @@
 #include "phlex/core/framework_graph.hpp"
 #include "phlex/model/data_cell_index.hpp"
-#include "phlex/model/product_store.hpp"
+#include "test/layer_generator.hpp"
 
 #include "catch2/catch_test_macros.hpp"
 #include "fmt/std.h"
@@ -33,17 +33,10 @@ TEST_CASE("provider_test")
   // constexpr auto max_events{1'000'000u};
   spdlog::flush_on(spdlog::level::trace);
 
-  auto levels_to_process = [](framework_driver& driver) {
-    auto job_index = data_cell_index::base_ptr();
-    driver.yield(job_index);
+  layer_generator gen;
+  gen.add_layer("spill", {"job", max_events, 1u});
 
-    for (unsigned int i : std::views::iota(1u, max_events + 1)) {
-      auto index = job_index->make_child(i, "spill");
-      driver.yield(index);
-    }
-  };
-
-  framework_graph g{levels_to_process};
+  framework_graph g{gen};
 
   g.provide("my_name_here", give_me_vertices, concurrency::unlimited)
     .output_product("happy_vertices"_in("spill"));