GCC Code Coverage Report

Directory:	./
File:	modules/task/include/task.hpp
Date:	2026-01-10 02:40:41

	Exec	Total	Coverage
Lines:	66	70	94.3%
Functions:	669	706	94.8%
Branches:	76	130	58.5%

  
      Line
      Branch
      Exec
      Source
    
      #pragma once
    
      #include <omp.h>
    
      #include <array>
    
      #include <chrono>
    
      #include <cstdint>
    
      #include <cstdlib>
    
      #include <fstream>
    
      #include <iomanip>
    
      #include <iostream>
    
      #include <memory>
    
      #include <sstream>
    
      #include <stdexcept>
    
      #include <string>
    
      #include <util/include/util.hpp>
    
      #include <utility>
    
      namespace ppc::task {
    
      /// @brief Represents the type of task (parallelization technology).
    
      /// @details Used to select the implementation type in tests and execution logic.
    
      enum class TypeOfTask : uint8_t {
    
        /// Use all available implementations
    
        kALL,
    
        /// MPI (Message Passing Interface)
    
        kMPI,
    
        /// OpenMP (Open Multi-Processing)
    
        kOMP,
    
        /// Sequential implementation
    
        kSEQ,
    
        /// Standard Thread Library (STL threads)
    
        kSTL,
    
        /// Intel Threading Building Blocks (TBB)
    
        kTBB,
    
        /// Unknown task type
    
        kUnknown
    
      };
    
      using TaskMapping = std::pair<TypeOfTask, std::string>;
    
      using TaskMappingArray = std::array<TaskMapping, 6>;
    
      const TaskMappingArray kTaskTypeMappings = {{{TypeOfTask::kALL, "all"},
    
                                                   {TypeOfTask::kMPI, "mpi"},
    
                                                   {TypeOfTask::kOMP, "omp"},
    
                                                   {TypeOfTask::kSEQ, "seq"},
    
                                                   {TypeOfTask::kSTL, "stl"},
    
                                                   {TypeOfTask::kTBB, "tbb"}}};
    
      96276
      inline std::string TypeOfTaskToString(TypeOfTask type) {
    
        2/2✓ Branch 0 taken 288954 times.
✓ Branch 1 taken 40 times.

      288994
        for (const auto &[key, value] : kTaskTypeMappings) {
    
        2/2✓ Branch 0 taken 96236 times.
✓ Branch 1 taken 192718 times.

      288954
          if (key == type) {
    
            return value;
    
          }
    
        }
    
      40
        return "unknown";
    
      }
    
      /// @brief Indicates whether a task is enabled or disabled.
    
      enum class StatusOfTask : uint8_t {
    
        /// Task is enabled and should be executed
    
        kEnabled,
    
        /// Task is disabled and will be skipped
    
        kDisabled
    
      };
    
      /// @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) {
    
        1/2✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.

      20
          return "disabled";
    
        }
    
        1/2✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.

      20
        return "enabled";
    
      }
    
      /// @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.
    
      /// @return Formatted string combining the task type and its corresponding value from the file.
    
      /// @throws std::runtime_error If the file cannot be opened.
    
      96336
      inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string &settings_file_path) {
    
      96336
        std::ifstream file(settings_file_path);
    
        2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 96296 times.

      96336
        if (!file.is_open()) {
    
        2/4✓ Branch 2 taken 40 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 40 times.
✗ Branch 6 not taken.

      80
          throw std::runtime_error("Failed to open " + settings_file_path);
    
        }
    
        auto list_settings = ppc::util::InitJSONPtr();
    
        2/2✓ Branch 1 taken 96276 times.
✓ Branch 2 taken 20 times.

      96296
        file >> *list_settings;
    
        1/2✓ Branch 1 taken 96276 times.
✗ Branch 2 not taken.

      96276
        std::string type_str = TypeOfTaskToString(type_of_task);
    
        2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 96236 times.

      96276
        if (type_str == "unknown") {
    
      40
          return type_str;
    
        }
    
        4/8✓ Branch 1 taken 96236 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 96236 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 96216 times.
✗ Branch 8 not taken.
✓ Branch 10 taken 96216 times.
✗ Branch 11 not taken.

      481140
        return type_str + "_" + std::string((*list_settings)["tasks"][type_str]);
    
      96336
      }
    
      enum class StateOfTesting : uint8_t { kFunc, kPerf };
    
      template <typename InType, typename OutType>
    
      /// @brief Base abstract class representing a generic task with a defined pipeline.
    
      /// @tparam InType Input data type.
    
      /// @tparam OutType Output data type.
    
        6/11✓ Branch 0 taken 100 times.
✓ Branch 1 taken 15569 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 30 times.
✗ Branch 5 not taken.
✓ Branch 7 taken 222 times.
✗ Branch 8 not taken.
✓ Branch 10 taken 10 times.
✗ Branch 11 not taken.
✓ Branch 13 taken 10 times.
✗ Branch 14 not taken.

      18249
      class Task {
    
       public:
    
        /// @brief Validates input data and task attributes before execution.
    
        /// @return True if validation is successful.
    
      19066
        virtual bool Validation() final {
    
        2/2✓ Branch 0 taken 18751 times.
✓ Branch 1 taken 10 times.

      19066
          if (stage_ == PipelineStage::kNone || stage_ == PipelineStage::kDone) {
    
      19046
            stage_ = PipelineStage::kValidation;
    
          } else {
    
      20
            stage_ = PipelineStage::kException;
    
        1/2✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.

      20
            throw std::runtime_error("Validation should be called before preprocessing");
    
          }
    
      19046
          return ValidationImpl();
    
        }
    
        /// @brief Performs preprocessing on the input data.
    
        /// @return True if preprocessing is successful.
    
      18978
        virtual bool PreProcessing() final {
    
        2/2✓ Branch 0 taken 18673 times.
✓ Branch 1 taken 20 times.

      18978
          if (stage_ == PipelineStage::kValidation) {
    
      18938
            stage_ = PipelineStage::kPreProcessing;
    
          } else {
    
      40
            stage_ = PipelineStage::kException;
    
        1/2✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.

      40
            throw std::runtime_error("Preprocessing should be called after validation");
    
          }
    
        2/2✓ Branch 0 taken 18483 times.
✓ Branch 1 taken 190 times.

      18938
          if (state_of_testing_ == StateOfTesting::kFunc) {
    
      18558
            InternalTimeTest();
    
          }
    
      18938
          return PreProcessingImpl();
    
        }
    
        /// @brief Executes the main logic of the task.
    
        /// @return True if execution is successful.
    
      19128
        virtual bool Run() final {
    
        2/2✓ Branch 0 taken 18748 times.
✓ Branch 1 taken 20 times.

      19128
          if (stage_ == PipelineStage::kPreProcessing || stage_ == PipelineStage::kRun) {
    
      19088
            stage_ = PipelineStage::kRun;
    
          } else {
    
      40
            stage_ = PipelineStage::kException;
    
        1/2✓ Branch 2 taken 20 times.
✗ Branch 3 not taken.

      40
            throw std::runtime_error("Run should be called after preprocessing");
    
          }
    
      19088
          return RunImpl();
    
        }
    
        /// @brief Performs postprocessing on the output data.
    
        /// @return True if postprocessing is successful.
    
      18978
        virtual bool PostProcessing() final {
    
        2/2✓ Branch 0 taken 18658 times.
✓ Branch 1 taken 35 times.

      18978
          if (stage_ == PipelineStage::kRun) {
    
      18908
            stage_ = PipelineStage::kDone;
    
          } else {
    
      70
            stage_ = PipelineStage::kException;
    
        1/2✓ Branch 2 taken 35 times.
✗ Branch 3 not taken.

      70
            throw std::runtime_error("Postprocessing should be called after run");
    
          }
    
        2/2✓ Branch 0 taken 18468 times.
✓ Branch 1 taken 190 times.

      18908
          if (state_of_testing_ == StateOfTesting::kFunc) {
    
      18528
            InternalTimeTest();
    
          }
    
      18908
          return PostProcessingImpl();
    
        }
    
        /// @brief Returns the current testing mode.
    
        /// @return Reference to the current StateOfTesting.
    
        StateOfTesting &GetStateOfTesting() {
    
          return state_of_testing_;
    
        }
    
        /// @brief Sets the dynamic task type.
    
        /// @param type_of_task Task type to set.
    
        void SetTypeOfTask(TypeOfTask type_of_task) {
    
        3/7✓ Branch 0 taken 100 times.
✓ Branch 1 taken 9296 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 7 taken 54 times.
✗ Branch 8 not taken.

      18498
          type_of_task_ = type_of_task;
    
        }
    
        /// @brief Returns the dynamic task type.
    
        /// @return Current dynamic task type.
    
        [[nodiscard]] TypeOfTask GetDynamicTypeOfTask() const {
    
        1/3✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.

      10
          return type_of_task_;
    
        }
    
        /// @brief Returns the current task status.
    
        /// @return Task status (enabled or disabled).
    
        [[nodiscard]] StatusOfTask GetStatusOfTask() const {
    
          return status_of_task_;
    
        }
    
        /// @brief Returns the static task type.
    
        /// @return Static task type (default: kUnknown).
    
        static constexpr TypeOfTask GetStaticTypeOfTask() {
    
          return TypeOfTask::kUnknown;
    
        }
    
        /// @brief Returns a reference to the input data.
    
        /// @return Reference to the task's input data.
    
        InType &GetInput() {
    
        10/14✓ Branch 0 taken 1448 times.
✓ Branch 1 taken 8659 times.
✓ Branch 2 taken 2100 times.
✓ Branch 3 taken 602 times.
✓ Branch 4 taken 315 times.
✓ Branch 5 taken 64 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 200 times.
✗ Branch 8 not taken.
✓ Branch 10 taken 10 times.
✓ Branch 11 taken 16 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 10 times.
✗ Branch 14 not taken.

      17058
          return input_;
    
        }
    
        /// @brief Returns a reference to the output data.
    
        /// @return Reference to the task's output data.
    
        OutType &GetOutput() {
    
        11/15✓ Branch 0 taken 261 times.
✓ Branch 1 taken 2627 times.
✓ Branch 2 taken 1103 times.
✓ Branch 3 taken 64 times.
✓ Branch 4 taken 542 times.
✓ Branch 5 taken 134 times.
✓ Branch 6 taken 80 times.
✓ Branch 7 taken 262 times.
✗ Branch 8 not taken.
✓ Branch 10 taken 118 times.
✗ Branch 11 not taken.
✓ Branch 13 taken 18 times.
✗ Branch 14 not taken.
✓ Branch 16 taken 18 times.
✗ Branch 17 not taken.

      29496
          return output_;
    
        }
    
        /// @brief Destructor. Verifies that the pipeline was executed in the correct order.
    
        /// @note Terminates the program if the pipeline order is incorrect or incomplete.
    
      34130
        virtual ~Task() {
    
      34160
          if (stage_ != PipelineStage::kDone && stage_ != PipelineStage::kException) {
    
            ppc::util::DestructorFailureFlag::Set();
    
          }
    
      #if _OPENMP >= 201811
    
          omp_pause_resource_all(omp_pause_soft);
    
      #endif
    
        4/16✓ Branch 0 taken 110 times.
✓ Branch 1 taken 16965 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 10 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 10 times.
✗ Branch 10 not taken.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✗ Branch 13 not taken.
✗ Branch 14 not taken.
✗ Branch 15 not taken.

      38628
        }
    
       protected:
    
        /// @brief Measures execution time between preprocessing and postprocessing steps.
    
        /// @throws std::runtime_error If execution exceeds the allowed time limit.
    
      37086
        virtual void InternalTimeTest() final {
    
        2/2✓ Branch 0 taken 18483 times.
✓ Branch 1 taken 18468 times.

      37086
          if (stage_ == PipelineStage::kPreProcessing) {
    
      18558
            tmp_time_point_ = std::chrono::high_resolution_clock::now();
    
          }
    
        2/2✓ Branch 0 taken 18468 times.
✓ Branch 1 taken 18483 times.

      37086
          if (stage_ == PipelineStage::kDone) {
    
      18528
            auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() -
    
                                                                                 tmp_time_point_)
    
                                .count();
    
      18528
            auto diff = static_cast<double>(duration) * 1e-9;
    
      18528
            const auto max_time = ppc::util::GetTaskMaxTime();
    
      18528
            std::stringstream err_msg;
    
        1/2✓ Branch 0 taken 18468 times.
✗ Branch 1 not taken.

      18528
            if (diff < max_time) {
    
        1/2✓ Branch 1 taken 18468 times.
✗ Branch 2 not taken.

      18528
              err_msg << "Test time:" << std::fixed << std::setprecision(10) << diff << '\n';
    
            } else {
    
      ✗
              err_msg << "\nTask execute time need to be: ";
    
      ✗
              err_msg << "time < " << max_time << " secs.\n";
    
      ✗
              err_msg << "Original time in secs: " << diff << '\n';
    
      ✗
              throw std::runtime_error(err_msg.str().c_str());
    
            }
    
      18528
          }
    
      37086
        }
    
        /// @brief User-defined validation logic.
    
        /// @return True if validation is successful.
    
        virtual bool ValidationImpl() = 0;
    
        /// @brief User-defined preprocessing logic.
    
        /// @return True if preprocessing is successful.
    
        virtual bool PreProcessingImpl() = 0;
    
        /// @brief User-defined task execution logic.
    
        /// @return True if a run is successful.
    
        virtual bool RunImpl() = 0;
    
        /// @brief User-defined postprocessing logic.
    
        /// @return True if postprocessing is successful.
    
        virtual bool PostProcessingImpl() = 0;
    
       private:
    
        InType input_{};
    
        OutType output_{};
    
        StateOfTesting state_of_testing_ = StateOfTesting::kFunc;
    
        TypeOfTask type_of_task_ = TypeOfTask::kUnknown;
    
        StatusOfTask status_of_task_ = StatusOfTask::kEnabled;
    
        std::chrono::high_resolution_clock::time_point tmp_time_point_;
    
        enum class PipelineStage : uint8_t {
    
          kNone,
    
          kValidation,
    
          kPreProcessing,
    
          kRun,
    
          kDone,
    
          kException
    
        } stage_ = PipelineStage::kNone;
    
      };
    
      /// @brief Smart pointer alias for Task.
    
      /// @tparam InType Input data type.
    
      /// @tparam OutType Output data type.
    
      template <typename InType, typename OutType>
    
      using TaskPtr = std::shared_ptr<Task<InType, OutType>>;
    
      /// @brief Constructs and returns a shared pointer to a task with the given input.
    
      /// @tparam TaskType Type of the task to create.
    
      /// @tparam InType Type of the input.
    
      /// @param in Input to pass to the task constructor.
    
      /// @return Shared a pointer to the newly created task.
    
      template <typename TaskType, typename InType>
    
      17516
      std::shared_ptr<TaskType> TaskGetter(const InType &in) {
    
      17516
        return std::make_shared<TaskType>(in);
    
      }
    
      }  // namespace ppc::task

Line	Branch	Exec	Source
1			#pragma once
2
3			#include <omp.h>
4
5			#include <array>
6			#include <chrono>
7			#include <cstdint>
8			#include <cstdlib>
9			#include <fstream>
10			#include <iomanip>
11			#include <iostream>
12			#include <memory>
13			#include <sstream>
14			#include <stdexcept>
15			#include <string>
16			#include <util/include/util.hpp>
17			#include <utility>
18
19			namespace ppc::task {
20
21			/// @brief Represents the type of task (parallelization technology).
22			/// @details Used to select the implementation type in tests and execution logic.
23			enum class TypeOfTask : uint8_t {
24			/// Use all available implementations
25			kALL,
26			/// MPI (Message Passing Interface)
27			kMPI,
28			/// OpenMP (Open Multi-Processing)
29			kOMP,
30			/// Sequential implementation
31			kSEQ,
32			/// Standard Thread Library (STL threads)
33			kSTL,
34			/// Intel Threading Building Blocks (TBB)
35			kTBB,
36			/// Unknown task type
37			kUnknown
38			};
39
40			using TaskMapping = std::pair<TypeOfTask, std::string>;
41			using TaskMappingArray = std::array<TaskMapping, 6>;
42
43			const TaskMappingArray kTaskTypeMappings = {{{TypeOfTask::kALL, "all"},
44			{TypeOfTask::kMPI, "mpi"},
45			{TypeOfTask::kOMP, "omp"},
46			{TypeOfTask::kSEQ, "seq"},
47			{TypeOfTask::kSTL, "stl"},
48			{TypeOfTask::kTBB, "tbb"}}};
49
50		96276	inline std::string TypeOfTaskToString(TypeOfTask type) {
51	2/2 ✓ Branch 0 taken 288954 times. ✓ Branch 1 taken 40 times.	288994	for (const auto &[key, value] : kTaskTypeMappings) {
52	2/2 ✓ Branch 0 taken 96236 times. ✓ Branch 1 taken 192718 times.	288954	if (key == type) {
53			return value;
54			}
55			}
56		40	return "unknown";
57			}
58
59			/// @brief Indicates whether a task is enabled or disabled.
60			enum class StatusOfTask : uint8_t {
61			/// Task is enabled and should be executed
62			kEnabled,
63			/// Task is disabled and will be skipped
64			kDisabled
65			};
66
67			/// @brief Returns a string representation of the task status.
68			/// @param status_of_task Task status (enabled or disabled).
69			/// @return "enabled" if the task is enabled, otherwise "disabled".
70			inline std::string GetStringTaskStatus(StatusOfTask status_of_task) {
71			if (status_of_task == StatusOfTask::kDisabled) {
72	1/2 ✓ Branch 2 taken 20 times. ✗ Branch 3 not taken.	20	return "disabled";
73			}
74	1/2 ✓ Branch 2 taken 20 times. ✗ Branch 3 not taken.	20	return "enabled";
75			}
76
77			/// @brief Returns a string representation of the task type based on the JSON settings file.
78			/// @param type_of_task Type of the task.
79			/// @param settings_file_path Path to the JSON file containing task type strings.
80			/// @return Formatted string combining the task type and its corresponding value from the file.
81			/// @throws std::runtime_error If the file cannot be opened.
82		96336	inline std::string GetStringTaskType(TypeOfTask type_of_task, const std::string &settings_file_path) {
83		96336	std::ifstream file(settings_file_path);
84	2/2 ✓ Branch 0 taken 40 times. ✓ Branch 1 taken 96296 times.	96336	if (!file.is_open()) {
85	2/4 ✓ Branch 2 taken 40 times. ✗ Branch 3 not taken. ✓ Branch 5 taken 40 times. ✗ Branch 6 not taken.	80	throw std::runtime_error("Failed to open " + settings_file_path);
86			}
87
88			auto list_settings = ppc::util::InitJSONPtr();
89	2/2 ✓ Branch 1 taken 96276 times. ✓ Branch 2 taken 20 times.	96296	file >> *list_settings;
90
91	1/2 ✓ Branch 1 taken 96276 times. ✗ Branch 2 not taken.	96276	std::string type_str = TypeOfTaskToString(type_of_task);
92	2/2 ✓ Branch 0 taken 40 times. ✓ Branch 1 taken 96236 times.	96276	if (type_str == "unknown") {
93		40	return type_str;
94			}
95
96	4/8 ✓ Branch 1 taken 96236 times. ✗ Branch 2 not taken. ✓ Branch 4 taken 96236 times. ✗ Branch 5 not taken. ✓ Branch 7 taken 96216 times. ✗ Branch 8 not taken. ✓ Branch 10 taken 96216 times. ✗ Branch 11 not taken.	481140	return type_str + "_" + std::string((*list_settings)["tasks"][type_str]);
97		96336	}
98
99			enum class StateOfTesting : uint8_t { kFunc, kPerf };
100
101			template <typename InType, typename OutType>
102			/// @brief Base abstract class representing a generic task with a defined pipeline.
103			/// @tparam InType Input data type.
104			/// @tparam OutType Output data type.
105	6/11 ✓ Branch 0 taken 100 times. ✓ Branch 1 taken 15569 times. ✗ Branch 2 not taken. ✓ Branch 4 taken 30 times. ✗ Branch 5 not taken. ✓ Branch 7 taken 222 times. ✗ Branch 8 not taken. ✓ Branch 10 taken 10 times. ✗ Branch 11 not taken. ✓ Branch 13 taken 10 times. ✗ Branch 14 not taken.	18249	class Task {
106			public:
107			/// @brief Validates input data and task attributes before execution.
108			/// @return True if validation is successful.
109		19066	virtual bool Validation() final {
110	2/2 ✓ Branch 0 taken 18751 times. ✓ Branch 1 taken 10 times.	19066	if (stage_ == PipelineStage::kNone \|\| stage_ == PipelineStage::kDone) {
111		19046	stage_ = PipelineStage::kValidation;
112			} else {
113		20	stage_ = PipelineStage::kException;
114	1/2 ✓ Branch 2 taken 10 times. ✗ Branch 3 not taken.	20	throw std::runtime_error("Validation should be called before preprocessing");
115			}
116		19046	return ValidationImpl();
117			}
118
119			/// @brief Performs preprocessing on the input data.
120			/// @return True if preprocessing is successful.
121		18978	virtual bool PreProcessing() final {
122	2/2 ✓ Branch 0 taken 18673 times. ✓ Branch 1 taken 20 times.	18978	if (stage_ == PipelineStage::kValidation) {
123		18938	stage_ = PipelineStage::kPreProcessing;
124			} else {
125		40	stage_ = PipelineStage::kException;
126	1/2 ✓ Branch 2 taken 20 times. ✗ Branch 3 not taken.	40	throw std::runtime_error("Preprocessing should be called after validation");
127			}
128	2/2 ✓ Branch 0 taken 18483 times. ✓ Branch 1 taken 190 times.	18938	if (state_of_testing_ == StateOfTesting::kFunc) {
129		18558	InternalTimeTest();
130			}
131		18938	return PreProcessingImpl();
132			}
133
134			/// @brief Executes the main logic of the task.
135			/// @return True if execution is successful.
136		19128	virtual bool Run() final {
137	2/2 ✓ Branch 0 taken 18748 times. ✓ Branch 1 taken 20 times.	19128	if (stage_ == PipelineStage::kPreProcessing \|\| stage_ == PipelineStage::kRun) {
138		19088	stage_ = PipelineStage::kRun;
139			} else {
140		40	stage_ = PipelineStage::kException;
141	1/2 ✓ Branch 2 taken 20 times. ✗ Branch 3 not taken.	40	throw std::runtime_error("Run should be called after preprocessing");
142			}
143		19088	return RunImpl();
144			}
145
146			/// @brief Performs postprocessing on the output data.
147			/// @return True if postprocessing is successful.
148		18978	virtual bool PostProcessing() final {
149	2/2 ✓ Branch 0 taken 18658 times. ✓ Branch 1 taken 35 times.	18978	if (stage_ == PipelineStage::kRun) {
150		18908	stage_ = PipelineStage::kDone;
151			} else {
152		70	stage_ = PipelineStage::kException;
153	1/2 ✓ Branch 2 taken 35 times. ✗ Branch 3 not taken.	70	throw std::runtime_error("Postprocessing should be called after run");
154			}
155	2/2 ✓ Branch 0 taken 18468 times. ✓ Branch 1 taken 190 times.	18908	if (state_of_testing_ == StateOfTesting::kFunc) {
156		18528	InternalTimeTest();
157			}
158		18908	return PostProcessingImpl();
159			}
160
161			/// @brief Returns the current testing mode.
162			/// @return Reference to the current StateOfTesting.
163			StateOfTesting &GetStateOfTesting() {
164			return state_of_testing_;
165			}
166
167			/// @brief Sets the dynamic task type.
168			/// @param type_of_task Task type to set.
169			void SetTypeOfTask(TypeOfTask type_of_task) {
170	3/7 ✓ Branch 0 taken 100 times. ✓ Branch 1 taken 9296 times. ✗ Branch 2 not taken. ✗ Branch 4 not taken. ✗ Branch 5 not taken. ✓ Branch 7 taken 54 times. ✗ Branch 8 not taken.	18498	type_of_task_ = type_of_task;
171			}
172
173			/// @brief Returns the dynamic task type.
174			/// @return Current dynamic task type.
175			[[nodiscard]] TypeOfTask GetDynamicTypeOfTask() const {
176	1/3 ✗ Branch 0 not taken. ✓ Branch 1 taken 10 times. ✗ Branch 2 not taken.	10	return type_of_task_;
177			}
178
179			/// @brief Returns the current task status.
180			/// @return Task status (enabled or disabled).
181			[[nodiscard]] StatusOfTask GetStatusOfTask() const {
182			return status_of_task_;
183			}
184
185			/// @brief Returns the static task type.
186			/// @return Static task type (default: kUnknown).
187			static constexpr TypeOfTask GetStaticTypeOfTask() {
188			return TypeOfTask::kUnknown;
189			}
190
191			/// @brief Returns a reference to the input data.
192			/// @return Reference to the task's input data.
193			InType &GetInput() {
194	10/14 ✓ Branch 0 taken 1448 times. ✓ Branch 1 taken 8659 times. ✓ Branch 2 taken 2100 times. ✓ Branch 3 taken 602 times. ✓ Branch 4 taken 315 times. ✓ Branch 5 taken 64 times. ✗ Branch 6 not taken. ✓ Branch 7 taken 200 times. ✗ Branch 8 not taken. ✓ Branch 10 taken 10 times. ✓ Branch 11 taken 16 times. ✗ Branch 12 not taken. ✓ Branch 13 taken 10 times. ✗ Branch 14 not taken.	17058	return input_;
195			}
196
197			/// @brief Returns a reference to the output data.
198			/// @return Reference to the task's output data.
199			OutType &GetOutput() {
200	11/15 ✓ Branch 0 taken 261 times. ✓ Branch 1 taken 2627 times. ✓ Branch 2 taken 1103 times. ✓ Branch 3 taken 64 times. ✓ Branch 4 taken 542 times. ✓ Branch 5 taken 134 times. ✓ Branch 6 taken 80 times. ✓ Branch 7 taken 262 times. ✗ Branch 8 not taken. ✓ Branch 10 taken 118 times. ✗ Branch 11 not taken. ✓ Branch 13 taken 18 times. ✗ Branch 14 not taken. ✓ Branch 16 taken 18 times. ✗ Branch 17 not taken.	29496	return output_;
201			}
202
203			/// @brief Destructor. Verifies that the pipeline was executed in the correct order.
204			/// @note Terminates the program if the pipeline order is incorrect or incomplete.
205		34130	virtual ~Task() {
206		34160	if (stage_ != PipelineStage::kDone && stage_ != PipelineStage::kException) {
207			ppc::util::DestructorFailureFlag::Set();
208			}
209			#if _OPENMP >= 201811
210			omp_pause_resource_all(omp_pause_soft);
211			#endif
212	4/16 ✓ Branch 0 taken 110 times. ✓ Branch 1 taken 16965 times. ✗ Branch 2 not taken. ✗ Branch 3 not taken. ✗ Branch 4 not taken. ✓ Branch 5 taken 10 times. ✗ Branch 6 not taken. ✗ Branch 7 not taken. ✗ Branch 8 not taken. ✓ Branch 9 taken 10 times. ✗ Branch 10 not taken. ✗ Branch 11 not taken. ✗ Branch 12 not taken. ✗ Branch 13 not taken. ✗ Branch 14 not taken. ✗ Branch 15 not taken.	38628	}
213
214			protected:
215			/// @brief Measures execution time between preprocessing and postprocessing steps.
216			/// @throws std::runtime_error If execution exceeds the allowed time limit.
217		37086	virtual void InternalTimeTest() final {
218	2/2 ✓ Branch 0 taken 18483 times. ✓ Branch 1 taken 18468 times.	37086	if (stage_ == PipelineStage::kPreProcessing) {
219		18558	tmp_time_point_ = std::chrono::high_resolution_clock::now();
220			}
221
222	2/2 ✓ Branch 0 taken 18468 times. ✓ Branch 1 taken 18483 times.	37086	if (stage_ == PipelineStage::kDone) {
223		18528	auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() -
224			tmp_time_point_)
225			.count();
226		18528	auto diff = static_cast<double>(duration) * 1e-9;
227
228		18528	const auto max_time = ppc::util::GetTaskMaxTime();
229		18528	std::stringstream err_msg;
230	1/2 ✓ Branch 0 taken 18468 times. ✗ Branch 1 not taken.	18528	if (diff < max_time) {
231	1/2 ✓ Branch 1 taken 18468 times. ✗ Branch 2 not taken.	18528	err_msg << "Test time:" << std::fixed << std::setprecision(10) << diff << '\n';
232			} else {
233		✗	err_msg << "\nTask execute time need to be: ";
234		✗	err_msg << "time < " << max_time << " secs.\n";
235		✗	err_msg << "Original time in secs: " << diff << '\n';
236		✗	throw std::runtime_error(err_msg.str().c_str());
237			}
238		18528	}
239		37086	}
240
241			/// @brief User-defined validation logic.
242			/// @return True if validation is successful.
243			virtual bool ValidationImpl() = 0;
244
245			/// @brief User-defined preprocessing logic.
246			/// @return True if preprocessing is successful.
247			virtual bool PreProcessingImpl() = 0;
248
249			/// @brief User-defined task execution logic.
250			/// @return True if a run is successful.
251			virtual bool RunImpl() = 0;
252
253			/// @brief User-defined postprocessing logic.
254			/// @return True if postprocessing is successful.
255			virtual bool PostProcessingImpl() = 0;
256
257			private:
258			InType input_{};
259			OutType output_{};
260			StateOfTesting state_of_testing_ = StateOfTesting::kFunc;
261			TypeOfTask type_of_task_ = TypeOfTask::kUnknown;
262			StatusOfTask status_of_task_ = StatusOfTask::kEnabled;
263			std::chrono::high_resolution_clock::time_point tmp_time_point_;
264			enum class PipelineStage : uint8_t {
265			kNone,
266			kValidation,
267			kPreProcessing,
268			kRun,
269			kDone,
270			kException
271			} stage_ = PipelineStage::kNone;
272			};
273
274			/// @brief Smart pointer alias for Task.
275			/// @tparam InType Input data type.
276			/// @tparam OutType Output data type.
277			template <typename InType, typename OutType>
278			using TaskPtr = std::shared_ptr<Task<InType, OutType>>;
279
280			/// @brief Constructs and returns a shared pointer to a task with the given input.
281			/// @tparam TaskType Type of the task to create.
282			/// @tparam InType Type of the input.
283			/// @param in Input to pass to the task constructor.
284			/// @return Shared a pointer to the newly created task.
285			template <typename TaskType, typename InType>
286		17516	std::shared_ptr<TaskType> TaskGetter(const InType &in) {
287		17516	return std::make_shared<TaskType>(in);
288			}
289
290			} // namespace ppc::task
291