Change test tasks api (#64)

* new submodules

* change test mpi task

* change test mpi task - style

* change test mpi task - remove old

* change test mpi task - change style

* change test mpi task - change style 2

* change test mpi task - change style 3

* change test mpi task - rename .h -> .hpp

* change omp test task

* change omp test task - fix

* change omp test task - fix 2

* change seq test task

* run all tests

* check style

* update tbb task

* update std task

* update scripts

* fix mac script

* update run scripts

* update run scripts 2

* fix windows

* fix lint

* fix headers

* try to fix clang-tidy

* try to fix clang-tidy 2

* try to fix clang-tidy 3

* try to fix clang-tidy 4

* try to fix clang-tidy 5

* try to fix clang-tidy 7

* upgrade msvc omp version

* upgrade msvc omp version 2

Author: allnes

.clang-format

@@ -1,2 +1,3 @@
 Language: Cpp
 BasedOnStyle: Google
+ColumnLimit: 120

.clang-tidy

@@ -29,6 +29,8 @@ Checks: >
   -bugprone-implicit-widening-of-multiplication-result,
   -bugprone-unchecked-optional-access,
   -clang-analyzer-security.insecureAPI.rand,
+  -clang-analyzer-optin.cplusplus.UninitializedObject,
+  -modernize-loop-convert,
 
 WarningsAsErrors: "*"
 

.github/workflows/main.yml

@@ -120,7 +120,7 @@ jobs:
     - name: Run tests
       run: |
         export OMP_NUM_THREADS=4
-        source scripts/run_mac.sh
+        source scripts/run.sh
   windows-msvc-build:
     runs-on: windows-latest
     defaults:

.github/workflows/static-analysis-pr.yml

@@ -19,14 +19,14 @@ jobs:
       id: review
       with:
         build_dir: build
-        apt_packages: mpich,libmpich*,mpi*,openmpi-bin,ninja-build,libomp-dev,valgrind
-        cmake_command: cmake -S . -B build -D CMAKE_C_COMPILER_LAUNCHER=ccache -D CMAKE_CXX_COMPILER_LAUNCHER=ccache -G Ninja -D USE_SEQ=ON -D USE_MPI=ON -D USE_OMP=ON -D USE_TBB=ON -D USE_STD=ON -D CMAKE_BUILD_TYPE=RELEASE
+        apt_packages: mpich,libmpich*,mpi*,openmpi-bin,ninja-build,libomp-16-dev,valgrind
+        cmake_command: cmake -S . -B build -D CMAKE_C_COMPILER_LAUNCHER=ccache -D CMAKE_CXX_COMPILER_LAUNCHER=ccache -G Ninja -D USE_SEQ=ON -D USE_MPI=ON -D USE_OMP=ON -D USE_TBB=ON -D USE_STD=ON -D CMAKE_BUILD_TYPE=RELEASE -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
         config_file: .clang-tidy
         exclude: 3rdparty
-        split_workflow: false
+        split_workflow: true
         lgtm_comment_body: ""
       env:
-        CC: gcc-12
-        CXX: g++-12
+        CC: clang-16
+        CXX: clang++-16
     - if: steps.review.outputs.total_comments > 0
       run: exit 1

.gitignore

@@ -8,3 +8,4 @@ scripts/variants.csv
 scripts/variants.xlsx
 venv*
 sln/
+.DS_Store

CMakeLists.txt

@@ -1,5 +1,6 @@
 cmake_minimum_required( VERSION 3.25 )
 
+project( parallel_programming_course )
 message( STATUS "Parallel Programming Course" )
 
 include(cmake/configure.cmake)
@@ -21,9 +22,16 @@ option(USE_OMP OFF)
 if( USE_OMP OR USE_SEQ )
     find_package( OpenMP )
     if( OpenMP_FOUND )
+        include_directories( ${OpenMP_C_INCLUDE_DIRS} ${OpenMP_CXX_INCLUDE_DIRS} )
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
+        if ( MSVC AND MSVC_VERSION GREATER 1919 )
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /openmp:experimental")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /openmp:experimental")
+            set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /openmp:experimental")
+            add_compile_options(/openmp:experimental)
+        endif()
     else( OpenMP_FOUND )
         message(FATAL_ERROR "OpenMP NOT FOUND")
     endif( OpenMP_FOUND )

README.md

@@ -91,20 +91,14 @@ Navigate to a source code folder.
 
   ```
   mkdir build && cd build
-  cmake -D USE_SEQ=ON \
-        -D USE_MPI=ON \
-        -D USE_OMP=ON \
-        -D USE_TBB=ON \
-        -D USE_STD=ON \
-        -D USE_STYLE_CHECKER=ON ..
+  cmake -D USE_SEQ=ON -D USE_MPI=ON -D USE_OMP=ON -D USE_TBB=ON -D USE_STD=ON ..
   ```
 *Help on CMake keys:*
 - `-D USE_SEQ=ON` enable `Sequential` labs (based on OpenMP's CMakeLists.txt).
 - `-D USE_MPI=ON` enable `MPI` labs.
 - `-D USE_OMP=ON` enable `OpenMP` labs.
 - `-D USE_TBB=ON` enable `TBB` labs.
 - `-D USE_STD=ON` enable `std::thread` labs.
-- `-D USE_STYLE_CHECKER=ON` enable style check with build project.
 
 *A corresponding flag can be omitted if it's not needed.*
 

first_samples/mpi_boost/main.cpp

@@ -12,10 +12,9 @@ int main(int argc, char** argv) {
   boost::mpi::communicator world;
 
   world.barrier();
-  std::cout << "Processor = " << boost::mpi::environment::processor_name()
-            << std::endl;
+  std::cout << "Processor = " << boost::mpi::environment::processor_name() << std::endl;
   std::cout << "Rank = " << world.rank() << std::endl;
   std::cout << "Number of processors = " << world.size() << std::endl;
 
   return 0;
-}
+}

modules/core/CMakeLists.txt

@@ -1,10 +1,9 @@
 get_filename_component(ProjectId ${CMAKE_CURRENT_SOURCE_DIR} NAME)
 
 set(ProjectId "${ProjectId}")
-project( ${ProjectId} )
 message( STATUS "-- " ${ProjectId} )
 
-file(GLOB_RECURSE ALL_SOURCE_FILES *.cpp *.h)
+file(GLOB_RECURSE ALL_SOURCE_FILES *.cpp *.h *.hpp)
 
 set(PACK_LIB "${ProjectId}_lib")
 add_library(${PACK_LIB} STATIC ${ALL_SOURCE_FILES} )

modules/core/include/perf.hpp

@@ -35,15 +35,12 @@ class Perf {
   void pipeline_run(const std::shared_ptr<PerfAttr>& perfAttr,
                     const std::shared_ptr<ppc::core::PerfResults>& perfResults);
   // Check performance of task's run() function
-  void task_run(const std::shared_ptr<PerfAttr>& perfAttr,
-                const std::shared_ptr<ppc::core::PerfResults>& perfResults);
+  void task_run(const std::shared_ptr<PerfAttr>& perfAttr, const std::shared_ptr<ppc::core::PerfResults>& perfResults);
 
  private:
   std::shared_ptr<Task> task;
-  static void common_run(
-      const std::shared_ptr<PerfAttr>& perfAttr,
-      const std::function<void()>& pipeline,
-      const std::shared_ptr<ppc::core::PerfResults>& perfResults);
+  static void common_run(const std::shared_ptr<PerfAttr>& perfAttr, const std::function<void()>& pipeline,
+                         const std::shared_ptr<ppc::core::PerfResults>& perfResults);
 };
 
 }  // namespace core

modules/core/include/task.hpp

@@ -50,8 +50,7 @@ class Task {
 
  private:
   std::vector<std::string> functions_order;
-  std::vector<std::string> right_functions_order = {
-      "validation", "pre_processing", "run", "post_processing"};
+  std::vector<std::string> right_functions_order = {"validation", "pre_processing", "run", "post_processing"};
 };
 
 }  // namespace ppc::core

modules/core/src/perf.cpp

@@ -6,17 +6,12 @@
 
 #include "unapproved/unapproved.h"
 
-ppc::core::Perf::Perf(std::shared_ptr<Task> task_) {
-  set_task(std::move(task_));
-}
+ppc::core::Perf::Perf(std::shared_ptr<Task> task_) { set_task(std::move(task_)); }
 
-void ppc::core::Perf::set_task(std::shared_ptr<Task> task_) {
-  task = std::move(task_);
-}
+void ppc::core::Perf::set_task(std::shared_ptr<Task> task_) { task = std::move(task_); }
 
-void ppc::core::Perf::pipeline_run(
-    const std::shared_ptr<PerfAttr>& perfAttr,
-    const std::shared_ptr<ppc::core::PerfResults>& perfResults) {
+void ppc::core::Perf::pipeline_run(const std::shared_ptr<PerfAttr>& perfAttr,
+                                   const std::shared_ptr<ppc::core::PerfResults>& perfResults) {
   common_run(
       std::move(perfAttr),
       [&]() {
@@ -28,26 +23,22 @@ void ppc::core::Perf::pipeline_run(
       std::move(perfResults));
 }
 
-void ppc::core::Perf::task_run(
-    const std::shared_ptr<PerfAttr>& perfAttr,
-    const std::shared_ptr<ppc::core::PerfResults>& perfResults) {
+void ppc::core::Perf::task_run(const std::shared_ptr<PerfAttr>& perfAttr,
+                               const std::shared_ptr<ppc::core::PerfResults>& perfResults) {
   task->validation();
   task->pre_processing();
   common_run(
       std::move(perfAttr), [&]() { task->run(); }, std::move(perfResults));
   task->post_processing();
 }
 
-void ppc::core::Perf::common_run(
-    const std::shared_ptr<PerfAttr>& perfAttr,
-    const std::function<void()>& pipeline,
-    const std::shared_ptr<ppc::core::PerfResults>& perfResults) {
+void ppc::core::Perf::common_run(const std::shared_ptr<PerfAttr>& perfAttr, const std::function<void()>& pipeline,
+                                 const std::shared_ptr<ppc::core::PerfResults>& perfResults) {
   auto begin = std::chrono::high_resolution_clock::now();
   for (int i = 0; i < perfAttr->num_running; i++) {
     pipeline();
   }
   auto end = std::chrono::high_resolution_clock::now();
-  auto duration =
-      std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count();
+  auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - begin).count();
   perfResults->time_sec = duration * 1e-9;
 }

modules/core/src/task.cpp

@@ -9,28 +9,20 @@ void ppc::core::Task::set_data(std::shared_ptr<TaskData> taskData_) {
   taskData = std::move(taskData_);
 }
 
-std::shared_ptr<ppc::core::TaskData> ppc::core::Task::get_data() const {
-  return taskData;
-}
+std::shared_ptr<ppc::core::TaskData> ppc::core::Task::get_data() const { return taskData; }
 
-ppc::core::Task::Task(std::shared_ptr<TaskData> taskData_) {
-  set_data(std::move(taskData_));
-}
+ppc::core::Task::Task(std::shared_ptr<TaskData> taskData_) { set_data(std::move(taskData_)); }
 
 void ppc::core::Task::internal_order_test(const std::string& str) {
-  if (!functions_order.empty() && str == functions_order.back() && str == "run")
-    return;
+  if (!functions_order.empty() && str == functions_order.back() && str == "run") return;
 
   functions_order.push_back(str);
 
   for (auto i = 0; i < functions_order.size(); i++) {
-    if (functions_order[i] !=
-        right_functions_order[i % right_functions_order.size()]) {
-      throw std::invalid_argument(
-          "ORDER OF FUCTIONS IS NOT RIGHT: \n" +
-          std::string("Serial number: ") + std::to_string(i + 1) + "\n" +
-          std::string("Yours function: ") + functions_order[i] + "\n" +
-          std::string("Expected function: ") + right_functions_order[i]);
+    if (functions_order[i] != right_functions_order[i % right_functions_order.size()]) {
+      throw std::invalid_argument("ORDER OF FUCTIONS IS NOT RIGHT: \n" + std::string("Serial number: ") +
+                                  std::to_string(i + 1) + "\n" + std::string("Yours function: ") + functions_order[i] +
+                                  "\n" + std::string("Expected function: ") + right_functions_order[i]);
     }
   }
 }

modules/core/tests/core_tests.cpp

@@ -13,8 +13,7 @@ TEST(core_tests, check_int32_t) {
   std::vector<int32_t> out(1, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
@@ -36,8 +35,7 @@ TEST(core_tests, check_validate_func) {
   std::vector<int32_t> out(2, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
@@ -55,8 +53,7 @@ TEST(core_tests, check_double) {
   std::vector<double> out(1, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
@@ -78,8 +75,7 @@ TEST(core_tests, check_uint8_t) {
   std::vector<uint8_t> out(1, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
@@ -101,8 +97,7 @@ TEST(core_tests, check_int64_t) {
   std::vector<int64_t> out(1, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
@@ -124,8 +119,7 @@ TEST(core_tests, check_float) {
   std::vector<float> out(1, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
@@ -147,8 +141,7 @@ TEST(core_tests, check_wrong_order) {
   std::vector<float> out(1, 0);
 
   // Create TaskData
-  std::shared_ptr<ppc::core::TaskData> taskData =
-      std::make_shared<ppc::core::TaskData>();
+  std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>();
   taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
   taskData->inputs_count.emplace_back(in.size());
   taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));

modules/core/tests/test_task.hpp

@@ -10,14 +10,12 @@
 
 #include "core/include/task.hpp"
 
-namespace ppc {
-namespace test {
+namespace ppc::test {
 
 template <class T>
 class TestTask : public ppc::core::Task {
  public:
-  explicit TestTask(std::shared_ptr<ppc::core::TaskData> taskData_)
-      : Task(taskData_) {}
+  explicit TestTask(std::shared_ptr<ppc::core::TaskData> taskData_) : Task(taskData_) {}
   bool pre_processing() override {
     internal_order_test();
     input_ = reinterpret_cast<T *>(taskData->inputs[0]);
@@ -49,7 +47,6 @@ class TestTask : public ppc::core::Task {
   T *output_{};
 };
 
-}  // namespace test
-}  // namespace ppc
+}  // namespace ppc::test
 
 #endif  // MODULES_CORE_TESTS_TEST_TASK_HPP_

modules/reference/average_of_vector_elements/CMakeLists.txt

@@ -1,10 +1,9 @@
 get_filename_component(ProjectId ${CMAKE_CURRENT_SOURCE_DIR} NAME)
 
 set(ProjectId "${ProjectId}_ref")
-project( ${ProjectId} )
 message( STATUS "-- " ${ProjectId} )
 
-file(GLOB_RECURSE ALL_SOURCE_FILES *.cpp *.h)
+file(GLOB_RECURSE ALL_SOURCE_FILES *.cpp *.h *.hpp)
 
 set(PACK_LIB "${ProjectId}_lib")
 add_library(${PACK_LIB} STATIC ${ALL_SOURCE_FILES} )

modules/reference/average_of_vector_elements/ref_task.hpp

@@ -17,9 +17,7 @@ namespace reference {
 template <class InType, class OutType>
 class AverageOfVectorElements : public ppc::core::Task {
  public:
-  explicit AverageOfVectorElements(
-      std::shared_ptr<ppc::core::TaskData> taskData_)
-      : Task(taskData_) {}
+  explicit AverageOfVectorElements(std::shared_ptr<ppc::core::TaskData> taskData_) : Task(taskData_) {}
   bool pre_processing() override {
     internal_order_test();
     // Init vectors
@@ -41,8 +39,7 @@ class AverageOfVectorElements : public ppc::core::Task {
 
   bool run() override {
     internal_order_test();
-    average = static_cast<OutType>(
-        std::accumulate(input_.begin(), input_.end(), 0.0));
+    average = static_cast<OutType>(std::accumulate(input_.begin(), input_.end(), 0.0));
     average /= static_cast<OutType>(taskData->inputs_count[0]);
     return true;
   }