This repository has been archived by the owner on Jun 30, 2024. It is now read-only.
forked from mahbhlddnhakkh/ppc-2024-threads
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
1 parent
4d4d8a9
commit da63cd0
Showing
14 changed files
with
1,692 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,212 @@ | ||
#include <gtest/gtest.h> | ||
|
||
#include <vector> | ||
|
||
#include "omp/belan_vadim_mat_fox_omp/include/ops_omp.hpp" | ||
|
||
using namespace BelanOMP; | ||
|
||
TEST(FoxBlockedParallel, MatrixMultiplication2x2) { | ||
// Define input matrices | ||
std::vector<double> matrixA = {1, 2, 3, 4}; | ||
std::vector<double> matrixB = {4, 3, 2, 1}; | ||
std::vector<double> expectedOutput = {8, 5, 20, 13}; | ||
|
||
// Create TaskData | ||
std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>(); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data())); | ||
taskData->inputs_count.emplace_back(2); | ||
taskData->inputs_count.emplace_back(2); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data())); | ||
taskData->inputs_count.emplace_back(2); | ||
taskData->inputs_count.emplace_back(2); | ||
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[4]())); | ||
taskData->outputs_count.emplace_back(2); | ||
taskData->outputs_count.emplace_back(2); | ||
|
||
// Create Task | ||
FoxBlockedParallel foxBlockedParallel(taskData); | ||
foxBlockedParallel.validation(); | ||
foxBlockedParallel.pre_processing(); | ||
auto *output = reinterpret_cast<double *>(taskData->outputs[0]); | ||
foxBlockedParallel.run(); | ||
foxBlockedParallel.post_processing(); | ||
|
||
// Check the output | ||
for (size_t i = 0; i < 4; ++i) { | ||
ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]); | ||
} | ||
|
||
// Free memory | ||
delete[] output; | ||
} | ||
|
||
TEST(FoxBlockedParallel, MatrixMultiplication) { | ||
// Define input matrices | ||
std::vector<double> matrixA = {1, 2, 3, 4, 5, 6, 7, 8, 9}; | ||
std::vector<double> matrixB = {9, 8, 7, 6, 5, 4, 3, 2, 1}; | ||
std::vector<double> expectedOutput = {30, 24, 18, 84, 69, 54, 138, 114, 90}; | ||
|
||
// Create TaskData | ||
std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>(); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data())); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data())); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[9]())); | ||
taskData->outputs_count.emplace_back(3); | ||
taskData->outputs_count.emplace_back(3); | ||
|
||
// Create Task | ||
FoxBlockedParallel foxBlockedParallel(taskData); | ||
foxBlockedParallel.validation(); | ||
foxBlockedParallel.pre_processing(); | ||
auto *output = reinterpret_cast<double *>(taskData->outputs[0]); | ||
foxBlockedParallel.run(); | ||
foxBlockedParallel.post_processing(); | ||
|
||
// Check the output | ||
for (size_t i = 0; i < 9; ++i) { | ||
ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]); | ||
} | ||
|
||
// Free memory | ||
delete[] output; | ||
} | ||
|
||
TEST(FoxBlockedParallel, MatrixMultiplication_VerySmallMatrices) { | ||
// Define input matrices | ||
std::vector<double> matrixA(10 * 10); | ||
std::vector<double> matrixB(10 * 10); | ||
std::vector<double> expectedOutput(10 * 10); | ||
|
||
// Initialize matrices with random values | ||
for (size_t i = 0; i < 10 * 10; ++i) { | ||
matrixA[i] = rand() % 10; | ||
matrixB[i] = rand() % 10; | ||
expectedOutput[i] = 0; | ||
} | ||
|
||
for (size_t i = 0; i < 10; ++i) { | ||
for (size_t j = 0; j < 10; ++j) { | ||
for (size_t k = 0; k < 10; ++k) { | ||
expectedOutput[i * 10 + j] += matrixA[i * 10 + k] * matrixB[k * 10 + j]; | ||
} | ||
} | ||
} | ||
|
||
// Create TaskData | ||
std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>(); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data())); | ||
taskData->inputs_count.emplace_back(10); | ||
taskData->inputs_count.emplace_back(10); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data())); | ||
taskData->inputs_count.emplace_back(10); | ||
taskData->inputs_count.emplace_back(10); | ||
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[10 * 10]())); | ||
taskData->outputs_count.emplace_back(10); | ||
taskData->outputs_count.emplace_back(10); | ||
|
||
// Create Task | ||
FoxBlockedParallel foxBlockedParallel(taskData); | ||
foxBlockedParallel.validation(); | ||
foxBlockedParallel.pre_processing(); | ||
auto *output = reinterpret_cast<double *>(taskData->outputs[0]); | ||
foxBlockedParallel.run(); | ||
foxBlockedParallel.post_processing(); | ||
|
||
// Check the output | ||
for (size_t i = 0; i < 10 * 10; ++i) { | ||
ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]); | ||
} | ||
|
||
// Free memory | ||
delete[] output; | ||
} | ||
|
||
TEST(FoxBlockedParallel, MatrixMultiplication_SmallMatrices) { | ||
// Define input matrices | ||
std::vector<double> matrixA(100 * 100); | ||
std::vector<double> matrixB(100 * 100); | ||
std::vector<double> expectedOutput(100 * 100); | ||
|
||
// Initialize matrices with random values | ||
for (size_t i = 0; i < 100 * 100; ++i) { | ||
matrixA[i] = rand() % 10; | ||
matrixB[i] = rand() % 10; | ||
expectedOutput[i] = 0; | ||
} | ||
|
||
for (size_t i = 0; i < 100; ++i) { | ||
for (size_t j = 0; j < 100; ++j) { | ||
for (size_t k = 0; k < 100; ++k) { | ||
expectedOutput[i * 100 + j] += matrixA[i * 100 + k] * matrixB[k * 100 + j]; | ||
} | ||
} | ||
} | ||
|
||
// Create TaskData | ||
std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>(); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data())); | ||
taskData->inputs_count.emplace_back(100); | ||
taskData->inputs_count.emplace_back(100); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data())); | ||
taskData->inputs_count.emplace_back(100); | ||
taskData->inputs_count.emplace_back(100); | ||
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[100 * 100]())); | ||
taskData->outputs_count.emplace_back(100); | ||
taskData->outputs_count.emplace_back(100); | ||
|
||
// Create Task | ||
FoxBlockedParallel foxBlockedParallel(taskData); | ||
foxBlockedParallel.validation(); | ||
foxBlockedParallel.pre_processing(); | ||
auto *output = reinterpret_cast<double *>(taskData->outputs[0]); | ||
foxBlockedParallel.run(); | ||
foxBlockedParallel.post_processing(); | ||
|
||
// Check the output | ||
for (size_t i = 0; i < 100 * 100; ++i) { | ||
ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]); | ||
} | ||
|
||
// Free memory | ||
delete[] output; | ||
} | ||
|
||
TEST(FoxBlockedParallel, MatrixMultiplicationWithNegatives) { | ||
// Define input matrices with negative values | ||
std::vector<double> matrixA = {-1, -2, -3, -4, -5, -6, -7, -8, -9}; | ||
std::vector<double> matrixB = {-9, -8, -7, -6, -5, -4, -3, -2, -1}; | ||
std::vector<double> expectedOutput = {30, 24, 18, 84, 69, 54, 138, 114, 90}; | ||
|
||
// Create TaskData | ||
std::shared_ptr<ppc::core::TaskData> taskData = std::make_shared<ppc::core::TaskData>(); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixA.data())); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(matrixB.data())); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->inputs_count.emplace_back(3); | ||
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(new double[9]())); | ||
taskData->outputs_count.emplace_back(3); | ||
taskData->outputs_count.emplace_back(3); | ||
|
||
// Create Task | ||
FoxBlockedParallel foxBlockedParallel(taskData); | ||
foxBlockedParallel.validation(); | ||
foxBlockedParallel.pre_processing(); | ||
auto *output = reinterpret_cast<double *>(taskData->outputs[0]); | ||
foxBlockedParallel.run(); | ||
foxBlockedParallel.post_processing(); | ||
|
||
// Check the output | ||
for (size_t i = 0; i < 9; ++i) { | ||
ASSERT_DOUBLE_EQ(output[i], expectedOutput[i]); | ||
} | ||
|
||
// Free memory | ||
delete[] output; | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,44 @@ | ||
// Copyright 2024 Vadim Belan | ||
#pragma once | ||
|
||
#include <memory> | ||
#include <utility> | ||
#include <vector> | ||
|
||
#include "core/task/include/task.hpp" | ||
|
||
namespace BelanOMP { | ||
|
||
using Matrix = std::vector<std::vector<double>>; | ||
|
||
class FoxBlockedSequential : public ppc::core::Task { | ||
public: | ||
explicit FoxBlockedSequential(std::shared_ptr<ppc::core::TaskData> taskData_) : Task(std::move(taskData_)) {} | ||
bool pre_processing() override; | ||
bool validation() override; | ||
bool run() override; | ||
bool post_processing() override; | ||
|
||
private: | ||
Matrix A{}; | ||
Matrix B{}; | ||
Matrix C{}; | ||
int block_size{}; | ||
}; | ||
|
||
class FoxBlockedParallel : public ppc::core::Task { | ||
public: | ||
explicit FoxBlockedParallel(std::shared_ptr<ppc::core::TaskData> taskData_) : Task(std::move(taskData_)) {} | ||
bool pre_processing() override; | ||
bool validation() override; | ||
bool run() override; | ||
bool post_processing() override; | ||
|
||
private: | ||
Matrix A{}; | ||
Matrix B{}; | ||
Matrix C{}; | ||
int block_size{}; | ||
}; | ||
|
||
} // namespace BelanOMP |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,55 @@ | ||
// Copyright 2023 Nesterov Alexander | ||
|
||
#ifndef MODULES_CORE_INCLUDE_PERF_HPP_ | ||
#define MODULES_CORE_INCLUDE_PERF_HPP_ | ||
|
||
#include <cstdint> | ||
#include <functional> | ||
#include <memory> | ||
#include <vector> | ||
|
||
#include "core/task/include/task.hpp" | ||
|
||
namespace ppc { | ||
namespace core { | ||
|
||
struct PerfAttr { | ||
// count of task's running | ||
uint64_t num_running; | ||
std::function<double(void)> current_timer = [&] { return 0.0; }; | ||
}; | ||
|
||
struct PerfResults { | ||
// measurement of task's time (in seconds) | ||
double time_sec = 0.0; | ||
enum TypeOfRunning { PIPELINE, TASK_RUN, NONE } type_of_running = NONE; | ||
constexpr const static double MAX_TIME = 10.0; | ||
constexpr const static double MIN_TIME = 0.05; | ||
}; | ||
|
||
class Perf { | ||
public: | ||
// Init performance analysis with initialized task and initialized data | ||
explicit Perf(std::shared_ptr<Task> task_); | ||
// Set task with initialized task and initialized data for performance | ||
// analysis c | ||
void set_task(std::shared_ptr<Task> task_); | ||
// Check performance of full task's pipeline: pre_processing() -> | ||
// validation() -> run() -> post_processing() | ||
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); | ||
// Pint results for automation checkers | ||
static void print_perf_statistic(const std::shared_ptr<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); | ||
}; | ||
|
||
} // namespace core | ||
} // namespace ppc | ||
|
||
#endif // MODULES_CORE_INCLUDE_PERF_HPP_ |
Oops, something went wrong.