Merge branch 'master' into an/add_all_dir

Author: allnes

Diff for: cmake/configure.cmake

@@ -39,6 +39,8 @@ if( MSVC )
     set(CMAKE_CXX_FLAGS         "${CMAKE_CXX_FLAGS} /W4 /wd4267 /wd4244 /wd4100 /WX" )
 endif( MSVC )
 
+add_compile_definitions(PPC_PATH_TO_PROJECT="${CMAKE_CURRENT_SOURCE_DIR}")
+
 MACRO(SUBDIRLIST result curdir)
   FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
   SET(dirlist "")

Diff for: modules/core/task/include/task.hpp

@@ -3,6 +3,7 @@
 
 #include <chrono>
 #include <cstdint>
+#include <filesystem>
 #include <iostream>
 #include <memory>
 #include <string>
@@ -69,6 +70,11 @@ class Task {
   std::chrono::high_resolution_clock::time_point tmp_time_point;
 };
 
+inline std::filesystem::path GetAbsolutePath(const std::string &relative_path) {
+  std::filesystem::path path = std::string(PPC_PATH_TO_PROJECT) + "/tasks/" + relative_path;
+  return path;
+}
+
 }  // namespace ppc::core
 
 #endif  // MODULES_CORE_INCLUDE_TASK_HPP_

Diff for: tasks/mpi/example/data/test.txt

@@ -0,0 +1 @@
+120

Diff for: tasks/mpi/example/func_tests/main.cpp

@@ -2,6 +2,7 @@
 
 #include <boost/mpi/communicator.hpp>
 #include <boost/mpi/environment.hpp>
+#include <fstream>
 #include <random>
 #include <vector>
 
@@ -238,3 +239,54 @@ TEST(Parallel_Operations_MPI, Test_Max_2) {
     ASSERT_EQ(reference_max[0], global_max[0]);
   }
 }
+
+TEST(Parallel_Operations_MPI, Test_Max_2_File) {
+  boost::mpi::communicator world;
+  std::vector<int> global_vec;
+  std::vector<int32_t> global_max(1, 0);
+  // Create TaskData
+  auto task_data_par = std::make_shared<ppc::core::TaskData>();
+
+  if (world.rank() == 0) {
+    std::string line;
+    std::ifstream test_file(ppc::core::GetAbsolutePath("mpi/example/data/test.txt"));
+    if (test_file.is_open()) {
+      getline(test_file, line);
+    }
+    test_file.close();
+
+    const int count_size_vector = std::stoi(line);
+    global_vec = GetRandomVector(count_size_vector);
+    task_data_par->inputs.emplace_back(reinterpret_cast<uint8_t*>(global_vec.data()));
+    task_data_par->inputs_count.emplace_back(global_vec.size());
+    task_data_par->outputs.emplace_back(reinterpret_cast<uint8_t*>(global_max.data()));
+    task_data_par->outputs_count.emplace_back(global_max.size());
+  }
+
+  nesterov_a_test_task_mpi::TestMPITaskParallel test_mpi_task_parallel(task_data_par, "max");
+  ASSERT_EQ(test_mpi_task_parallel.validation(), true);
+  test_mpi_task_parallel.pre_processing();
+  test_mpi_task_parallel.run();
+  test_mpi_task_parallel.post_processing();
+
+  if (world.rank() == 0) {
+    // Create data
+    std::vector<int32_t> reference_max(1, 0);
+
+    // Create TaskData
+    auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+    task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t*>(global_vec.data()));
+    task_data_seq->inputs_count.emplace_back(global_vec.size());
+    task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t*>(reference_max.data()));
+    task_data_seq->outputs_count.emplace_back(reference_max.size());
+
+    // Create Task
+    nesterov_a_test_task_mpi::TestMPITaskSequential test_mpi_task_sequential(task_data_seq, "max");
+    ASSERT_EQ(test_mpi_task_sequential.validation(), true);
+    test_mpi_task_sequential.pre_processing();
+    test_mpi_task_sequential.run();
+    test_mpi_task_sequential.post_processing();
+
+    ASSERT_EQ(reference_max[0], global_max[0]);
+  }
+}

Diff for: tasks/omp/example/data/test.txt

@@ -0,0 +1 @@
+5

Diff for: tasks/omp/example/func_tests/main.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include <fstream>
 #include <random>
 #include <vector>
 
@@ -207,3 +208,48 @@ TEST(Parallel_Operations_OpenMP, Test_Mult_2) {
   test_omp_task_parallel.post_processing();
   ASSERT_EQ(ref_res[0], par_res[0]);
 }
+
+TEST(Parallel_Operations_OpenMP, Test_Mult_2_File) {
+  std::string line;
+  std::ifstream test_file(ppc::core::GetAbsolutePath("omp/example/data/test.txt"));
+  if (test_file.is_open()) {
+    getline(test_file, line);
+  }
+  test_file.close();
+
+  std::vector<int> vec = GetRandomVector(std::stoi(line));
+  // Create data
+  std::vector<int> ref_res(1, 0);
+
+  // Create TaskData
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(vec.data()));
+  task_data_seq->inputs_count.emplace_back(vec.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(ref_res.data()));
+  task_data_seq->outputs_count.emplace_back(ref_res.size());
+
+  // Create Task
+  nesterov_a_test_task_omp::TestOMPTaskSequential test_omp_task_sequential(task_data_seq, "*");
+  ASSERT_EQ(test_omp_task_sequential.validation(), true);
+  test_omp_task_sequential.pre_processing();
+  test_omp_task_sequential.run();
+  test_omp_task_sequential.post_processing();
+
+  // Create data
+  std::vector<int> par_res(1, 0);
+
+  // Create TaskData
+  auto task_data_par = std::make_shared<ppc::core::TaskData>();
+  task_data_par->inputs.emplace_back(reinterpret_cast<uint8_t *>(vec.data()));
+  task_data_par->inputs_count.emplace_back(vec.size());
+  task_data_par->outputs.emplace_back(reinterpret_cast<uint8_t *>(par_res.data()));
+  task_data_par->outputs_count.emplace_back(par_res.size());
+
+  // Create Task
+  nesterov_a_test_task_omp::TestOMPTaskParallel test_omp_task_parallel(task_data_par, "*");
+  ASSERT_EQ(test_omp_task_parallel.validation(), true);
+  test_omp_task_parallel.pre_processing();
+  test_omp_task_parallel.run();
+  test_omp_task_parallel.post_processing();
+  ASSERT_EQ(ref_res[0], par_res[0]);
+}

Diff for: tasks/seq/example/data/test.txt

@@ -0,0 +1 @@
+100

Diff for: tasks/seq/example/func_tests/main.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include <fstream>
 #include <vector>
 
 #include "seq/example/include/ops_seq.hpp"
@@ -118,3 +119,33 @@ TEST(Sequential, Test_Sum_100) {
   test_task_sequential.post_processing();
   ASSERT_EQ(count, out[0]);
 }
+
+TEST(Sequential, Test_Sum_100_From_File) {
+  std::string line;
+  std::ifstream test_file(ppc::core::GetAbsolutePath("seq/example/data/test.txt"));
+  if (test_file.is_open()) {
+    getline(test_file, line);
+  }
+  test_file.close();
+
+  const int count = std::stoi(line);
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create TaskData
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.validation(), true);
+  test_task_sequential.pre_processing();
+  test_task_sequential.run();
+  test_task_sequential.post_processing();
+  ASSERT_EQ(count, out[0]);
+}

Diff for: tasks/stl/example/data/test.txt

@@ -0,0 +1 @@
+15

Diff for: tasks/stl/example/func_tests/main.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include <fstream>
 #include <random>
 #include <thread>
 #include <vector>
@@ -212,3 +213,49 @@ TEST(Parallel_Operations_STL_Threads, Test_Diff_2) {
   test_stl_task_parallel.post_processing();
   ASSERT_EQ(ref_res[0], par_res[0]);
 }
+
+TEST(Parallel_Operations_STL_Threads, Test_Diff_2_File) {
+  std::string line;
+  std::ifstream test_file(ppc::core::GetAbsolutePath("stl/example/data/test.txt"));
+  if (test_file.is_open()) {
+    getline(test_file, line);
+  }
+  test_file.close();
+
+  auto nthreads = std::thread::hardware_concurrency() * std::stoi(line);
+  std::vector<int> vec = GetRandomVector(static_cast<int>(nthreads));
+  // Create data
+  std::vector<int> ref_res(1, 0);
+
+  // Create TaskData
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(vec.data()));
+  task_data_seq->inputs_count.emplace_back(vec.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(ref_res.data()));
+  task_data_seq->outputs_count.emplace_back(ref_res.size());
+
+  // Create Task
+  nesterov_a_test_task_stl::TestSTLTaskSequential test_stl_task_sequential(task_data_seq, "-");
+  ASSERT_EQ(test_stl_task_sequential.validation(), true);
+  test_stl_task_sequential.pre_processing();
+  test_stl_task_sequential.run();
+  test_stl_task_sequential.post_processing();
+
+  // Create data
+  std::vector<int> par_res(1, 0);
+
+  // Create TaskData
+  auto task_data_par = std::make_shared<ppc::core::TaskData>();
+  task_data_par->inputs.emplace_back(reinterpret_cast<uint8_t *>(vec.data()));
+  task_data_par->inputs_count.emplace_back(vec.size());
+  task_data_par->outputs.emplace_back(reinterpret_cast<uint8_t *>(par_res.data()));
+  task_data_par->outputs_count.emplace_back(par_res.size());
+
+  // Create Task
+  nesterov_a_test_task_stl::TestSTLTaskParallel test_stl_task_parallel(task_data_par, "-");
+  ASSERT_EQ(test_stl_task_parallel.validation(), true);
+  test_stl_task_parallel.pre_processing();
+  test_stl_task_parallel.run();
+  test_stl_task_parallel.post_processing();
+  ASSERT_EQ(ref_res[0], par_res[0]);
+}

Diff for: tasks/tbb/example/data/test.txt

@@ -0,0 +1 @@
+5

Diff for: tasks/tbb/example/func_tests/main.cpp

@@ -1,5 +1,6 @@
 #include <gtest/gtest.h>
 
+#include <fstream>
 #include <random>
 #include <vector>
 
@@ -206,3 +207,48 @@ TEST(Parallel_Operations_TBB, Test_Mult_2) {
   test_tbb_task_parallel.post_processing();
   ASSERT_EQ(ref_res[0], par_res[0]);
 }
+
+TEST(Parallel_Operations_TBB, Test_Mult_2_File) {
+  std::string line;
+  std::ifstream test_file(ppc::core::GetAbsolutePath("tbb/example/data/test.txt"));
+  if (test_file.is_open()) {
+    getline(test_file, line);
+  }
+  test_file.close();
+
+  std::vector<int> vec = GetRandomVector(std::stoi(line));
+  // Create data
+  std::vector<int> ref_res(1, 0);
+
+  // Create TaskData
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(vec.data()));
+  task_data_seq->inputs_count.emplace_back(vec.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(ref_res.data()));
+  task_data_seq->outputs_count.emplace_back(ref_res.size());
+
+  // Create Task
+  nesterov_a_test_task_tbb::TestTBBTaskSequential test_tbb_task_sequential(task_data_seq, "*");
+  ASSERT_EQ(test_tbb_task_sequential.validation(), true);
+  test_tbb_task_sequential.pre_processing();
+  test_tbb_task_sequential.run();
+  test_tbb_task_sequential.post_processing();
+
+  // Create data
+  std::vector<int> par_res(1, 0);
+
+  // Create TaskData
+  auto task_data_par = std::make_shared<ppc::core::TaskData>();
+  task_data_par->inputs.emplace_back(reinterpret_cast<uint8_t *>(vec.data()));
+  task_data_par->inputs_count.emplace_back(vec.size());
+  task_data_par->outputs.emplace_back(reinterpret_cast<uint8_t *>(par_res.data()));
+  task_data_par->outputs_count.emplace_back(par_res.size());
+
+  // Create Task
+  nesterov_a_test_task_tbb::TestTBBTaskParallel test_tbb_task_parallel(task_data_par, "*");
+  ASSERT_EQ(test_tbb_task_parallel.validation(), true);
+  test_tbb_task_parallel.pre_processing();
+  test_tbb_task_parallel.run();
+  test_tbb_task_parallel.post_processing();
+  ASSERT_EQ(ref_res[0], par_res[0]);
+}