Use typed descriptors for test task filtering (#825)

Author: aobolensk

modules/task/include/task.hpp

@@ -56,6 +56,15 @@ constexpr std::string_view TypeOfTaskToString(TypeOfTask type) {
   return "unknown";
 }
 
+constexpr TypeOfTask TypeOfTaskFromString(std::string_view type) {
+  for (const auto &[key, value] : kTaskTypeMappings) {
+    if (value == type) {
+      return key;
+    }
+  }
+  return TypeOfTask::kUnknown;
+}
+
 /// @brief Indicates whether a task is enabled or disabled.
 enum class StatusOfTask : uint8_t {
   /// Task is enabled and should be executed
@@ -64,24 +73,70 @@ enum class StatusOfTask : uint8_t {
   kDisabled,
 };
 
+constexpr std::string_view StatusOfTaskToString(StatusOfTask status_of_task) {
+  return status_of_task == StatusOfTask::kDisabled ? "disabled" : "enabled";
+}
+
+inline StatusOfTask StatusOfTaskFromString(std::string_view status_of_task) {
+  if (status_of_task == "enabled") {
+    return StatusOfTask::kEnabled;
+  }
+  if (status_of_task == "disabled") {
+    return StatusOfTask::kDisabled;
+  }
+  throw std::runtime_error("Unknown task status: " + std::string(status_of_task));
+}
+
 /// @brief Returns a string representation of the task status.
 /// @param status_of_task Task status (enabled or disabled).
 /// @return "enabled" if the task is enabled, otherwise "disabled".
 inline std::string GetStringTaskStatus(StatusOfTask status_of_task) {
-  if (status_of_task == StatusOfTask::kDisabled) {
-    return "disabled";
+  return std::string(StatusOfTaskToString(status_of_task));
+}
+
+enum class TaskCategory : uint8_t {
+  kUnknown,
+  kThreads,
+  kProcesses,
+};
+
+constexpr std::string_view TaskCategoryToString(TaskCategory category) {
+  switch (category) {
+    case TaskCategory::kThreads:
+      return "threads";
+    case TaskCategory::kProcesses:
+      return "processes";
+    case TaskCategory::kUnknown:
+      return "";
   }
-  return "enabled";
+  return "";
 }
 
+constexpr TaskCategory TaskCategoryFromSettingsPath(std::string_view settings_task_path) {
+  if (settings_task_path.starts_with("threads")) {
+    return TaskCategory::kThreads;
+  }
+  if (settings_task_path.starts_with("processes")) {
+    return TaskCategory::kProcesses;
+  }
+  return TaskCategory::kUnknown;
+}
+
+struct TaskDescriptor {
+  TypeOfTask type = TypeOfTask::kUnknown;
+  StatusOfTask status = StatusOfTask::kEnabled;
+  TaskCategory category = TaskCategory::kUnknown;
+  std::string display_name;
+};
+
 /// @brief Returns a string representation of the task type based on the JSON settings file.
 /// @param type_of_task Type of the task.
 /// @param settings_file_path Path to the JSON file containing task type strings.
 /// @param settings_task_path Optional dot-separated nested path inside the `tasks` object.
 /// @return Formatted string combining the task type and its corresponding value from the file.
 /// @throws std::runtime_error If the file cannot be opened or the requested settings key is missing.
-inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string &settings_file_path,
-                                     std::string_view settings_task_path = {}) {
+inline StatusOfTask GetTaskStatus(TypeOfTask type_of_task, const std::string &settings_file_path,
+                                  std::string_view settings_task_path = {}) {
   std::ifstream file(settings_file_path);
   if (!file.is_open()) {
     throw std::runtime_error("Failed to open " + settings_file_path);
@@ -92,7 +147,7 @@ inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string
 
   const std::string_view type_str = TypeOfTaskToString(type_of_task);
   if (type_str == "unknown") {
-    return std::string(type_str);
+    return StatusOfTask::kEnabled;
   }
 
   auto get_required_node = [&settings_file_path](const nlohmann::json &node, const std::string &key,
@@ -124,7 +179,17 @@ inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string
   const std::string type_key(type_str);
   settings_key_path += "." + type_key;
   const auto &type_node = get_required_node(*settings_node, type_key, settings_key_path);
-  return type_key + "_" + type_node.get<std::string>();
+  return StatusOfTaskFromString(type_node.get<std::string>());
+}
+
+inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string &settings_file_path,
+                                     std::string_view settings_task_path = {}) {
+  const StatusOfTask status = GetTaskStatus(type_of_task, settings_file_path, settings_task_path);
+  const std::string_view type_str = TypeOfTaskToString(type_of_task);
+  if (type_str == "unknown") {
+    return std::string(type_str);
+  }
+  return std::string(type_str) + "_" + std::string(StatusOfTaskToString(status));
 }
 
 enum class StateOfTesting : uint8_t {

modules/util/include/func_test_util.hpp

@@ -2,8 +2,6 @@
 
 #include <gtest/gtest.h>
 
-#include <tbb/tick_count.h>
-
 #include <concepts>
 #include <cstddef>
 #include <functional>
@@ -15,12 +13,14 @@
 #include <utility>
 
 #include "task/include/task.hpp"
+#include "util/include/task_descriptor_util.hpp"
 #include "util/include/util.hpp"
 
 namespace ppc::util {
 
 template <typename InType, typename OutType, typename TestType = void>
-using FuncTestParam = std::tuple<std::function<ppc::task::TaskPtr<InType, OutType>(InType)>, std::string, TestType>;
+using FuncTestParam = std::tuple<std::function<ppc::task::TaskPtr<InType, OutType>(InType)>, std::string, TestType,
+                                 ppc::task::TaskDescriptor>;
 
 template <typename InType, typename OutType, typename TestType = void>
 using GTestFuncParam = ::testing::TestParamInfo<FuncTestParam<InType, OutType, TestType>>;
@@ -50,8 +50,7 @@ class BaseRunFuncTests : public ::testing::TestWithParam<FuncTestParam<InType, O
   static std::string PrintFuncTestName(const GTestFuncParam<InType, OutType, TestType> &info) {
     RequireStaticInterface<Derived>();
     TestType test_param = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(info.param);
-    return std::get<static_cast<std::size_t>(GTestParamIndex::kNameTest)>(info.param) + "_" +
-           Derived::PrintTestParam(test_param);
+    return GetTaskDescriptor(info.param).display_name + "_" + Derived::PrintTestParam(test_param);
   }
 
  protected:
@@ -71,36 +70,39 @@ class BaseRunFuncTests : public ::testing::TestWithParam<FuncTestParam<InType, O
   }
 
   void ExecuteTest(FuncTestParam<InType, OutType, TestType> test_param) {
-    const std::string &test_name = std::get<static_cast<std::size_t>(GTestParamIndex::kNameTest)>(test_param);
+    const auto &descriptor = GetTaskDescriptor(test_param);
 
-    ValidateTestName(test_name);
+    ValidateTaskDescriptor(descriptor);
 
-    const auto test_env_scope = ppc::util::test::MakePerTestEnvForCurrentGTest(test_name);
+    const auto test_env_scope = ppc::util::test::MakePerTestEnvForCurrentGTest(descriptor.display_name);
 
-    if (IsTestDisabled(test_name)) {
+    if (IsTestDisabled(descriptor)) {
       GTEST_SKIP();
     }
 
-    if (ShouldSkipNonMpiTask(test_name)) {
+    if (ShouldSkipNonMpiTask(descriptor)) {
       std::cerr << "kALL and kMPI tasks are not under mpirun\n";
       GTEST_SKIP();
     }
 
     InitializeAndRunTask(test_param);
   }
 
-  void ValidateTestName(const std::string &test_name) {
-    EXPECT_FALSE(test_name.contains("unknown"));
+  void ValidateTaskDescriptor(const ppc::task::TaskDescriptor &descriptor) {
+    EXPECT_NE(descriptor.type, ppc::task::TypeOfTask::kUnknown);
   }
 
-  bool IsTestDisabled(const std::string &test_name) {
-    return test_name.contains("disabled");
+  bool IsTestDisabled(const ppc::task::TaskDescriptor &descriptor) {
+    return descriptor.status == ppc::task::StatusOfTask::kDisabled;
   }
 
-  bool ShouldSkipNonMpiTask(const std::string &test_name) {
-    auto contains_substring = [&](const std::string &substring) { return test_name.contains(substring); };
+  bool ShouldSkipNonMpiTask(const ppc::task::TaskDescriptor &descriptor) {
+    return !ppc::util::IsUnderMpirun() && IsMpiTaskType(descriptor.type);
+  }
 
-    return !ppc::util::IsUnderMpirun() && (contains_substring("_all") || contains_substring("_mpi"));
+  bool ShouldSkipTestCase(const FuncTestParam<InType, OutType, TestType> &test_param) {
+    const auto &descriptor = GetTaskDescriptor(test_param);
+    return IsTestDisabled(descriptor) || ShouldSkipNonMpiTask(descriptor);
   }
 
   /// @brief Initializes task instance and runs it through the full pipeline.
@@ -136,15 +138,14 @@ class BaseRunFuncTests : public ::testing::TestWithParam<FuncTestParam<InType, O
 
 namespace detail {
 
-[[nodiscard]] inline std::string MakeFuncTestTaskTagPattern(std::string_view task_tag) {
-  std::string tag_pattern{task_tag};
-  if (!tag_pattern.starts_with('_')) {
-    tag_pattern.insert(0, 1, '_');
+[[nodiscard]] inline ppc::task::TypeOfTask TaskTypeFromFuncTestTag(std::string_view task_tag) {
+  while (task_tag.starts_with('_')) {
+    task_tag.remove_prefix(1);
   }
-  if (!tag_pattern.ends_with('_')) {
-    tag_pattern.push_back('_');
+  while (task_tag.ends_with('_')) {
+    task_tag.remove_suffix(1);
   }
-  return tag_pattern;
+  return ppc::task::TypeOfTaskFromString(task_tag);
 }
 
 }  // namespace detail
@@ -156,12 +157,12 @@ void RunTestCasesWithTag(const TestTasksList &test_tasks_list, std::string_view
     return;
   }
 
-  const std::string task_tag_pattern = detail::MakeFuncTestTaskTagPattern(task_tag);
+  const ppc::task::TypeOfTask task_type = detail::TaskTypeFromFuncTestTag(task_tag);
   bool has_matching_task = false;
   std::apply([&](const auto &...test_params) {
     auto run_if_tagged = [&](const auto &test_param) {
-      const std::string &test_name = std::get<static_cast<std::size_t>(GTestParamIndex::kNameTest)>(test_param);
-      if (test_name.contains(task_tag_pattern)) {
+      const auto &descriptor = GetTaskDescriptor(test_param);
+      if (descriptor.type == task_type) {
         has_matching_task = true;
         std::invoke(run_test_case, test_param);
       }
@@ -185,11 +186,10 @@ auto ExpandToValues(const Tuple &t) {
 template <typename Task, typename InType, typename SizesContainer, std::size_t... Is>
 auto GenTaskTuplesImpl(const SizesContainer &sizes, const std::string &settings_path,
                        std::string_view settings_task_path, std::index_sequence<Is...> /*unused*/) {
-  return std::make_tuple(
-      std::make_tuple(ppc::task::TaskGetter<Task, InType>,
-                      std::string(GetNamespace<Task>()) + "_" +
-                          ppc::task::GetStringTaskType(Task::GetStaticTypeOfTask(), settings_path, settings_task_path),
-                      std::get<Is>(sizes))...);
+  const auto descriptor =
+      MakeTaskDescriptor(GetNamespace<Task>(), Task::GetStaticTypeOfTask(), settings_path, settings_task_path);
+  return std::make_tuple(std::make_tuple(ppc::task::TaskGetter<Task, InType>, descriptor.display_name,
+                                         std::get<Is>(sizes), descriptor)...);
 }
 
 template <typename Task, typename InType, typename SizesContainer>

modules/util/include/perf_test_util.hpp

@@ -21,6 +21,7 @@
 #include <utility>
 
 #include "task/include/task.hpp"
+#include "util/include/task_descriptor_util.hpp"
 #include "util/include/util.hpp"
 
 namespace ppc::util {
@@ -40,38 +41,18 @@ struct PerfAttr {
 
 namespace detail {
 
-inline bool ContainsFilterToken(std::string_view value, std::string_view filter) {
-  if (filter.empty()) {
-    return true;
-  }
-  return value.contains(filter);
-}
-
-inline bool MatchesCategoryFilter(std::string_view task_category, std::string_view category_filter) {
-  if (category_filter.empty() || task_category.empty()) {
-    return true;
-  }
-  return category_filter.contains(task_category);
+inline bool ContainsDescriptorToken(std::string_view filter, std::string_view descriptor_token) {
+  return filter.empty() || descriptor_token.empty() || filter.contains(descriptor_token);
 }
 
-inline bool ShouldRunBenchmark(std::string_view test_name, std::string_view task_category) {
+inline bool ShouldRunBenchmark(const ppc::task::TaskDescriptor &descriptor) {
   const auto impl_filter = env::get<std::string>("PPC_PERF_IMPL_FILTER");
   const auto category_filter = env::get<std::string>("PPC_PERF_CATEGORY_FILTER");
   const auto impl_filter_value = impl_filter.has_value() ? std::string_view(impl_filter.value()) : std::string_view{};
   const auto category_filter_value =
       category_filter.has_value() ? std::string_view(category_filter.value()) : std::string_view{};
-  return ContainsFilterToken(test_name, impl_filter_value) &&
-         MatchesCategoryFilter(task_category, category_filter_value);
-}
-
-inline std::string GetPerfTaskCategory(std::string_view settings_task_path) {
-  if (settings_task_path.starts_with("threads")) {
-    return "threads";
-  }
-  if (settings_task_path.starts_with("processes")) {
-    return "processes";
-  }
-  return {};
+  return ContainsDescriptorToken(impl_filter_value, ppc::task::TypeOfTaskToString(descriptor.type)) &&
+         ContainsDescriptorToken(category_filter_value, ppc::task::TaskCategoryToString(descriptor.category));
 }
 
 template <typename InType, typename OutType>
@@ -188,7 +169,8 @@ class BenchmarkTaskBody final {
 }  // namespace detail
 
 template <typename InType, typename OutType>
-using PerfTestParam = std::tuple<std::function<ppc::task::TaskPtr<InType, OutType>(InType)>, std::string, std::string>;
+using PerfTestParam = std::tuple<std::function<ppc::task::TaskPtr<InType, OutType>(InType)>, std::string,
+                                 ppc::task::TaskCategory, ppc::task::TaskDescriptor>;
 
 template <typename InType, typename OutType>
 /// @brief Base class for performance testing of parallel tasks.
@@ -198,7 +180,7 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
  public:
   /// @brief Generates a readable name for the performance test case.
   static std::string CustomPerfTestName(const ::testing::TestParamInfo<PerfTestParam<InType, OutType>> &info) {
-    return std::get<static_cast<std::size_t>(GTestParamIndex::kNameTest)>(info.param);
+    return GetTaskDescriptor(info.param).display_name;
   }
 
  protected:
@@ -212,18 +194,17 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
 
   void ExecuteTest(const PerfTestParam<InType, OutType> &perf_test_param) {
     auto task_getter = std::get<static_cast<std::size_t>(GTestParamIndex::kTaskGetter)>(perf_test_param);
-    auto test_name = std::get<static_cast<std::size_t>(GTestParamIndex::kNameTest)>(perf_test_param);
-    auto task_category = std::get<static_cast<std::size_t>(GTestParamIndex::kTestParams)>(perf_test_param);
+    const auto &descriptor = GetTaskDescriptor(perf_test_param);
 
-    ASSERT_FALSE(test_name.find("unknown") != std::string::npos);
-    if (test_name.find("disabled") != std::string::npos) {
+    ASSERT_NE(descriptor.type, ppc::task::TypeOfTask::kUnknown);
+    if (descriptor.status == ppc::task::StatusOfTask::kDisabled) {
       return;
     }
-    if (!detail::ShouldRunBenchmark(test_name, task_category)) {
+    if (!detail::ShouldRunBenchmark(descriptor)) {
       return;
     }
 
-    const auto test_env_token = ppc::util::test::MakeCurrentGTestToken(test_name);
+    const auto test_env_token = ppc::util::test::MakeCurrentGTestToken(descriptor.display_name);
     const auto test_env_scope = ppc::util::test::ScopedPerTestEnv(test_env_token);
 
     const auto input_data = GetTestInputData();
@@ -243,7 +224,7 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
     auto benchmark_body =
         detail::BenchmarkTaskBody<decltype(task_getter), BenchmarkInputType>(task_getter, input_data, test_env_token);
 
-    benchmark::RegisterBenchmark(test_name, std::move(benchmark_body))
+    benchmark::RegisterBenchmark(descriptor.display_name, std::move(benchmark_body))
         ->UseManualTime()
         ->Unit(benchmark::kSecond)
         ->Iterations(static_cast<std::int64_t>(num_iterations));
@@ -255,11 +236,11 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
 
 template <typename TaskType, typename InputType>
 auto MakePerfTaskTuples(const std::string &settings_path, std::string_view settings_task_path = {}) {
-  const auto name = std::string(GetNamespace<TaskType>()) + "_" +
-                    ppc::task::GetStringTaskType(TaskType::GetStaticTypeOfTask(), settings_path, settings_task_path);
+  const auto descriptor =
+      MakeTaskDescriptor(GetNamespace<TaskType>(), TaskType::GetStaticTypeOfTask(), settings_path, settings_task_path);
 
-  return std::make_tuple(std::make_tuple(ppc::task::TaskGetter<TaskType, InputType>, name,
-                                         detail::GetPerfTaskCategory(settings_task_path)));
+  return std::make_tuple(std::make_tuple(ppc::task::TaskGetter<TaskType, InputType>, descriptor.display_name,
+                                         descriptor.category, descriptor));
 }
 
 template <typename Tuple, std::size_t... I>