Add PPC_ASAN_RUN logic and refactor task/test macros

allnes · allnes · commit 62b086658fac · 2025-06-06T00:19:24.000+02:00
Introduce `PPC_ASAN_RUN` to handle ASAN-specific configurations, replacing `USE_ASAN`. Refactor task initialization and testing macros for improved readability and flexibility. Adjust test and build scripts to incorporate new environment variables and settings management.
diff --git a/modules/core/util/include/func_test_util.hpp b/modules/core/util/include/func_test_util.hpp
@@ -74,19 +74,27 @@ auto ExpandToValues(const Tuple& t) {
   return ExpandToValuesImpl(t, std::make_index_sequence<kN>{});
 }
 
-#define INIT_TASK_GENERATOR(InTypeParam, SizesParam)                                                         \
-  template <typename Task, std::size_t... Is>                                                                \
-  auto GenTaskTuplesImpl(std::index_sequence<Is...>) {                                                       \
-    return std::make_tuple(                                                                                  \
-        std::make_tuple(ppc::core::TaskGetter<Task, InTypeParam>,                                            \
-                        std::string(ppc::util::GetNamespace<Task>()) + std::string("_") +                    \
-                            ppc::core::GetStringTaskType(Task::GetStaticTypeOfTask(), PPC_STUDENT_SETTINGS), \
-                        SizesParam[Is])...);                                                                 \
-  }                                                                                                          \
-                                                                                                             \
-  template <typename Task>                                                                                   \
-  auto TaskListGenerator() {                                                                                 \
-    return GenTaskTuplesImpl<Task>(std::make_index_sequence<SizesParam.size()>{});                           \
+#define INIT_TASK_GENERATOR(InTypeParam, SizesParam, SettingsPath)                                   \
+  template <typename Task, std::size_t... Is>                                                        \
+  auto GenTaskTuplesImpl(std::index_sequence<Is...>) {                                               \
+    return std::make_tuple(                                                                          \
+        std::make_tuple(ppc::core::TaskGetter<Task, InTypeParam>,                                    \
+                        std::string(ppc::util::GetNamespace<Task>()) + std::string("_") +            \
+                            ppc::core::GetStringTaskType(Task::GetStaticTypeOfTask(), SettingsPath), \
+                        SizesParam[Is])...);                                                         \
+  }                                                                                                  \
+                                                                                                     \
+  template <typename Task>                                                                           \
+  auto TaskListGenerator() {                                                                         \
+    return GenTaskTuplesImpl<Task>(std::make_index_sequence<SizesParam.size()>{});                   \
   }
 
+#define ADD_FUNC_TASK_THREADS(TASK) TaskListGenerator<TASK>()
+
+#ifndef PPC_ASAN_RUN
+#define ADD_FUNC_TASK_PROCESS(TASK) TaskListGenerator<TASK>()
+#else
+#define ADD_FUNC_TASK_PROCESS(TASK) std::tuple<>()
+#endif
+
 }  // namespace ppc::util
diff --git a/modules/core/util/include/perf_test_util.hpp b/modules/core/util/include/perf_test_util.hpp
@@ -79,11 +79,16 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
       throw std::runtime_error(err_msg.str().c_str());
     }
 
+#ifndef PPC_ASAN_RUN
     int rank = -1;
     MPI_Comm_rank(MPI_COMM_WORLD, &rank);
     if (rank == 0) {
       perf.PrintPerfStatistic(test_name);
     }
+#else
+    perf.PrintPerfStatistic(test_name);
+#endif
+
     OutType output_data = task_->GetOutput();
     ASSERT_TRUE(CheckTestOutputData(output_data));
   }
@@ -92,14 +97,39 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
   ppc::core::TaskPtr<InType, OutType> task_;
 };
 
-#define ADD_PERF_TASK(TaskType, InputTypeParam)                                                                \
-  std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                                             \
-                  std::string(ppc::util::GetNamespace<TaskType>()) + std::string("_") +                        \
-                      ppc::core::GetStringTaskType(TaskType::GetStaticTypeOfTask(), PPC_STUDENT_SETTINGS),     \
-                  ppc::core::PerfResults::TypeOfRunning::kPipeline),                                           \
-      std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                                         \
-                      std::string(ppc::util::GetNamespace<TaskType>()) + std::string("_") +                    \
-                          ppc::core::GetStringTaskType(TaskType::GetStaticTypeOfTask(), PPC_STUDENT_SETTINGS), \
-                      ppc::core::PerfResults::TypeOfRunning::kTaskRun)
+#define ADD_PERF_TASK_THREADS(TaskType, InputTypeParam, SettingsPath)                                         \
+  std::tuple(std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                                 \
+                             std::string(ppc::util::GetNamespace<TaskType>()) + "_" +                         \
+                                 ppc::core::GetStringTaskType(TaskType::GetStaticTypeOfTask(), SettingsPath), \
+                             ppc::core::PerfResults::TypeOfRunning::kPipeline),                               \
+             std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                                 \
+                             std::string(ppc::util::GetNamespace<TaskType>()) + "_" +                         \
+                                 ppc::core::GetStringTaskType(TaskType::GetStaticTypeOfTask(), SettingsPath), \
+                             ppc::core::PerfResults::TypeOfRunning::kTaskRun))
+
+template <typename Tuple, std::size_t... I>
+auto TupleToGTestValuesImpl(Tuple&& tup, std::index_sequence<I...>) {
+  return ::testing::Values(std::get<I>(std::forward<Tuple>(tup))...);
+}
+
+template <typename Tuple>
+auto TupleToGTestValues(Tuple&& tup) {
+  constexpr size_t size = std::tuple_size<std::decay_t<Tuple>>::value;
+  return TupleToGTestValuesImpl(std::forward<Tuple>(tup), std::make_index_sequence<size>{});
+}
+
+#ifndef PPC_ASAN_RUN
+#define ADD_PERF_TASK_PROCESS(TaskType, InputTypeParam, SettingsPath)                                         \
+  std::tuple(std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                                 \
+                             std::string(ppc::util::GetNamespace<TaskType>()) + "_" +                         \
+                                 ppc::core::GetStringTaskType(TaskType::GetStaticTypeOfTask(), SettingsPath), \
+                             ppc::core::PerfResults::TypeOfRunning::kPipeline),                               \
+             std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                                 \
+                             std::string(ppc::util::GetNamespace<TaskType>()) + "_" +                         \
+                                 ppc::core::GetStringTaskType(TaskType::GetStaticTypeOfTask(), SettingsPath), \
+                             ppc::core::PerfResults::TypeOfRunning::kTaskRun))
+#else
+#define ADD_PERF_TASK_PROCESS(TaskType, InputTypeParam, SettingsPath) std::make_tuple()
+#endif
 
 }  // namespace ppc::util
diff --git a/scripts/run_tests.py b/scripts/run_tests.py
@@ -123,8 +123,8 @@ def run_performance_list(self):
     ppc_runner = PPCRunner()
     ppc_runner.setup_env(os.environ.copy())
 
-    if args_dict["running_type"] in ["threads", "processes"]:
-        ppc_runner.run_core()
+    # if args_dict["running_type"] in ["threads", "processes"]:
+    #     ppc_runner.run_core()
 
     if args_dict["running_type"] == "threads":
         ppc_runner.run_threads()
diff --git a/tasks/CMakeLists.txt b/tasks/CMakeLists.txt
@@ -17,11 +17,19 @@ if (USE_PERF_TESTS)
     list(APPEND list_of_exec_tests ${exec_perf_tests})
 endif (USE_PERF_TESTS)
 
+if((DEFINED ENV{PPC_ASAN_RUN}) AND ("$ENV{PPC_ASAN_RUN}" STREQUAL "1"))
+    add_compile_definitions(PPC_ASAN_RUN)
+endif()
+
 SUBDIRLIST(subdirs ${CMAKE_CURRENT_LIST_DIR})
 foreach(subd ${subdirs})
     if (subd STREQUAL "common")
         continue()
     endif ()
+
+    set(SETTINGS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${subd}/settings.json")
+    add_compile_definitions(PPC_SETTINGS_${subd}=\"${SETTINGS_PATH}\")
+
     add_subdirectory(${subd})
 endforeach()
 
diff --git a/tasks/common/runners/functional.cpp b/tasks/common/runners/functional.cpp
@@ -71,7 +71,7 @@ class WorkerTestFailurePrinter : public ::testing::EmptyTestEventListener {
 };
 
 int main(int argc, char** argv) {
-#ifndef USE_ASAN
+#ifndef PPC_ASAN_RUN
   MPI_Init(&argc, &argv);
 
   // Limit the number of threads in TBB
diff --git a/tasks/common/runners/performance.cpp b/tasks/common/runners/performance.cpp
@@ -71,7 +71,7 @@ class WorkerTestFailurePrinter : public ::testing::EmptyTestEventListener {
 };
 
 int main(int argc, char** argv) {
-#ifndef USE_ASAN
+#ifndef PPC_ASAN_RUN
   MPI_Init(&argc, &argv);
 
   // Limit the number of threads in TBB
diff --git a/tasks/example/CMakeLists.txt b/tasks/example/CMakeLists.txt
@@ -1,10 +1,6 @@
 get_filename_component(CURRENT_DIR_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
 project(CURRENT_DIR_NAME)
 
-add_library("${CURRENT_DIR_NAME}_common" INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/common/include/common.hpp")
-get_filename_component(SETTINGS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/settings.json" ABSOLUTE)
-target_compile_definitions("${CURRENT_DIR_NAME}_common" INTERFACE PPC_STUDENT_SETTINGS=\"${SETTINGS_PATH}\")
-
 set(exec_func_tests "ppc_func_tests")
 set(exec_perf_tests "ppc_perf_tests")
 set(test_base_dir "${CMAKE_CURRENT_SOURCE_DIR}/tests")
@@ -28,8 +24,13 @@ endif (USE_PERF_TESTS)
 get_filename_component(TASK_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
 message(STATUS "-- ${TASK_NAME}")
 
+set(technologies "omp" "seq" "stl" "tbb")
+if((NOT DEFINED ENV{PPC_ASAN_RUN}) OR ("$ENV{PPC_ASAN_RUN}" STREQUAL "0"))
+    list(APPEND technologies "all" "mpi")
+endif()
+
 # Create lib
-foreach (dir_type "all" "mpi" "omp" "seq" "stl" "tbb")
+foreach (dir_type ${technologies})
     # Check directory existing
     set(base_dir "${CMAKE_CURRENT_SOURCE_DIR}/${dir_type}")
     if (NOT EXISTS "${base_dir}")
@@ -51,7 +52,7 @@ foreach (dir_type "all" "mpi" "omp" "seq" "stl" "tbb")
         add_library(${name_lib} STATIC ${lib_source_files})
     endif()
     set_target_properties(${name_lib} PROPERTIES LINKER_LANGUAGE CXX)
-    target_link_libraries(${name_lib} PUBLIC core_module_lib "${CURRENT_DIR_NAME}_common")
+    target_link_libraries(${name_lib} PUBLIC core_module_lib)
 
     # Link core library
     foreach (exec_func ${list_of_exec_tests})
diff --git a/tasks/example/info.json b/tasks/example/info.json
@@ -3,6 +3,7 @@
     "first_name": "Нестеров",
     "last_name": "Александр",
     "middle_name": "Юрьевич",
-    "group_number": "АБВ-123"
+    "group_number": "АБВ-123",
+    "tasks_type": "threads"
   }
 }
diff --git a/tasks/example/tests/functional/main.cpp b/tasks/example/tests/functional/main.cpp
@@ -63,12 +63,12 @@ TEST_P(NesterovARunFuncTests, MatmulFromPic) { ExecuteTest(GetParam()); }
 
 const std::array<TestType, 3> kTestParam = {std::make_tuple(3, "3"), std::make_tuple(5, "5"), std::make_tuple(7, "7")};
 
-INIT_TASK_GENERATOR(InType, kTestParam)
+INIT_TASK_GENERATOR(InType, kTestParam, PPC_SETTINGS_example)
 
 const auto kTestTasksList =
-    std::tuple_cat(TaskListGenerator<NesterovATestTaskALL>(), TaskListGenerator<NesterovATestTaskMPI>(),
-                   TaskListGenerator<NesterovATestTaskOMP>(), TaskListGenerator<NesterovATestTaskSEQ>(),
-                   TaskListGenerator<NesterovATestTaskSTL>(), TaskListGenerator<NesterovATestTaskTBB>());
+    std::tuple_cat(ADD_FUNC_TASK_PROCESS(NesterovATestTaskALL), ADD_FUNC_TASK_PROCESS(NesterovATestTaskMPI),
+                   ADD_FUNC_TASK_THREADS(NesterovATestTaskOMP), ADD_FUNC_TASK_THREADS(NesterovATestTaskSEQ),
+                   ADD_FUNC_TASK_THREADS(NesterovATestTaskSTL), ADD_FUNC_TASK_THREADS(NesterovATestTaskTBB));
 
 INSTANTIATE_TEST_SUITE_P_NOLINT(PicMatrixTests, NesterovARunFuncTests, ppc::util::ExpandToValues(kTestTasksList),
                                 NesterovARunFuncTests::PrintFuncTestName<NesterovARunFuncTests>);
diff --git a/tasks/example/tests/performance/main.cpp b/tasks/example/tests/performance/main.cpp
@@ -29,13 +29,16 @@ class ExampleRunPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
   InType GetTestInputData() final { return input_data_; }
 };
 
+const auto all_perf_tasks = std::tuple_cat(ADD_PERF_TASK_PROCESS(NesterovATestTaskALL, InType, PPC_SETTINGS_example),
+                                           ADD_PERF_TASK_PROCESS(NesterovATestTaskMPI, InType, PPC_SETTINGS_example),
+                                           ADD_PERF_TASK_THREADS(NesterovATestTaskOMP, InType, PPC_SETTINGS_example),
+                                           ADD_PERF_TASK_THREADS(NesterovATestTaskSEQ, InType, PPC_SETTINGS_example),
+                                           ADD_PERF_TASK_THREADS(NesterovATestTaskSTL, InType, PPC_SETTINGS_example),
+                                           ADD_PERF_TASK_THREADS(NesterovATestTaskTBB, InType, PPC_SETTINGS_example));
+
 TEST_P(ExampleRunPerfTest, RunPerfModes) { ExecuteTest(GetParam()); }
 
-INSTANTIATE_TEST_SUITE_P_NOLINT(
-    RunModeTests, ExampleRunPerfTest,
-    ::testing::Values(ADD_PERF_TASK(NesterovATestTaskALL, InType), ADD_PERF_TASK(NesterovATestTaskMPI, InType),
-                      ADD_PERF_TASK(NesterovATestTaskOMP, InType), ADD_PERF_TASK(NesterovATestTaskSEQ, InType),
-                      ADD_PERF_TASK(NesterovATestTaskSTL, InType), ADD_PERF_TASK(NesterovATestTaskTBB, InType)),
-    ExampleRunPerfTest::CustomPerfTestName);
+INSTANTIATE_TEST_SUITE_P_NOLINT(RunModeTests, ExampleRunPerfTest, ppc::util::TupleToGTestValues(all_perf_tasks),
+                                ExampleRunPerfTest::CustomPerfTestName);
 
 }  // namespace nesterov_a_test_task

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`"first_name": "Нестеров",`
`4`	`4`	`"last_name": "Александр",`
`5`	`5`	`"middle_name": "Юрьевич",`
`6`		`- "group_number": "АБВ-123"`
	`6`	`+ "group_number": "АБВ-123",`
	`7`	`+ "tasks_type": "threads"`
`7`	`8`	`}`
`8`	`9`	`}`