Для программы умножения двух квадратных матриц DGEMM BLAS разработанной в лабораторной…
- User
Для программы умножения двух квадратных матриц DGEMM BLAS разработанной в лабораторной работе №3 на языке С/С++ реализовать многопоточные вычисления. В потоках необходимо реализовать инициализацию массивов случайными числами типа double и равномерно распределить вычислительную нагрузку. Обеспечить возможность задавать размерность матриц и количество потоков при запуске программы. Многопоточность реализовать несколькими способами.
- С использованием библиотеки стандарта POSIX Threads.
- С использованием библиотеки стандарта OpenMP.
- *C использованием библиотеки Intel TBB.
- **C использованием библиотеки стандарта MPI. Все матрицы помещаются в общей памяти одного вычислителя.
- ***C использованием технологий многопоточности для графических сопроцессоров (GPU) - CUDA/OpenCL/OpenGL/OpenACC.
#include "lab3.h"
Matrix::Matrix(int size) : size_(size) { matrix_ = (double**)malloc(size * sizeof(double*)); for (int i = 0; i < size; ++i) { matrix_[i] = (double*)malloc(size * sizeof(double)); } }
Matrix::Matrix(const Matrix& other) : size_(other.size_), matrix_(new double*[other.size_]) { for (int i = 0; i < size_; ++i) { matrix_[i] = new double[size_]{}; for (int j = 0; j < size_; ++j) { matrix_[i][j] = other.matrix_[i][j]; } } }
Matrix::~Matrix() { for (int i = 0; i < size_; ++i) { free(matrix_[i]); } free(matrix_); matrix_ = nullptr; size_ = 0; }
Matrix& Matrix::operator=(Matrix other) { std::swap(matrix_, other.matrix_); std::swap(size_, other.size_); return *this; }
void Matrix::Fill() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution ran(0.0, 1.0); for (int j = 0; j < size_; j++) { for (int k = 0; k < size_; k++) { matrix_[j][k] = ran(gen); } } }
int Matrix::GetSize() const { return size_; }
void Matrix::Print() const { for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { std::cout << matrix_[i][j] << " "; } std::cout << std::endl; } }
void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for Mul");
Matrix result{size_};
for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { result.matrix_[i][j] = 0; for (int k = 0; k < size_; ++k) { result.matrix_[i][j] += matrix_[i][k] * other.matrix_[k][j]; } if (!std::isfinite(result.matrix_[i][j])) { throw std::runtime_error("Non-finite result encountered"); } } } *this = std::move(result); }
void test(int size) { Matrix A(size); Matrix B(size); A.Fill(); B.Fill(); A.DGEMM_BLAS(B); A.Print(); }
int main(int argc, char* argv[]) { setlocale(LC_ALL, "Russian"); if (argc != 2) { std::cerr << "Не задан размер матрицы. Повторите попытку." << std::endl; return 1; }
int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Размер матрицы должен быть положительным." << std::endl; return 1; }
test(size);
return 0; } #ifndef LAB3_H #define LAB3_H
#include // std::high_resolution_clock | duration #include // std::isfinite #include // std::cout | std::endl #include // std::random_device | std::mt19937 | std::uniform_real_distribution | ran #include // std::logic_error | std::runtime_error #include // std::move
class Matrix { private: int size_; double** matrix_;
public: explicit Matrix(int size); Matrix(const Matrix& other); Matrix& operator=(Matrix other); ~Matrix(); void Fill(); int GetSize() const; void Print() const; void DGEMM_BLAS(const Matrix& other); };
void test(int size);
#endif // LAB3_H
- Assistant
Для реализации многопоточных вычислений в программе умножения двух квадратных матриц, с использованием требуемых библиотек и технологий, создайте несколько версий метода
DGEMM_BLAS, который будет разделён на разные потоки. Каждая версия будет использовать различные подходы для распараллеливания процесса умножения матриц. Необходимо также адаптировать функциюmainдля возможности задавать размер матрицы и количество потоков.1. POSIX Threads
Подключите
<pthread.h>и определите параметры, которые будут передаваться в потоковую функцию. Например, структуру, содержащую указатели на матрицы и информацию о обрабатываемом диапазоне строк.struct ThreadData { Matrix *A; Matrix *B; Matrix *result; int startRow; int endRow; }; void* pthread_dgemm(void* arg) { ThreadData* data = (ThreadData*) arg; for (int i = data->startRow; i < data->endRow; ++i) { for (int j = 0; j < data->A->GetSize(); ++j) { double sum = 0; for (int k = 0; k < data->B->GetSize(); ++k) { sum += data->A->matrix_[i][k] * data->B->matrix_[k][j]; } data->result->matrix_[i][j] = sum; } } return nullptr; }2. OpenMP
Импортируйте
<omp.h>и используйте директивы#pragma:void Matrix::DGEMM_BLAS_OpenMP(const Matrix& other) { Matrix result{size_}; #pragma omp parallel for collapse(2) for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { double sum = 0; for (int k = 0; k < size_; ++k) { sum += matrix_[i][k] * other.matrix_[k][j]; } result.matrix_[i][j] = sum; } } *this = std::move(result); }3. Intel TBB
Подключите
<tbb/parallel_for.h>и<tbb/blocked_range2d.h>. Пример:#include <tbb/parallel_for.h> #include <tbb/blocked_range2d.h> void Matrix::DGEMM_BLAS_TBB(const Matrix& other) { Matrix result{size_}; tbb::parallel_for(tbb::blocked_range2d<int>(0, size_, 0, size_), [&](tbb::blocked_range2d<int> r) { for (int i = r.rows().begin(); i < r.rows().end(); ++i) { for (int j = r.cols().begin(); j < r.cols().end(); ++j) { double sum = 0; for (int k = 0; k < size_; ++k) { sum += matrix_[i][k] * other.matrix_[k][j]; } result.matrix_[i][j] = sum; } } }); *this = stdaustria::move(result); }4. MPI
Используйте MPI для распределения работы по различным процессам. Это может потребовать переработки программы для запуска в мультипроцессорной среде с распределением данных между процессами.
5. GPU технологии
Используйте CUDA или OpenCL для написания кода работающего на GPU. Это потребует переноса данных в память GPU, выполнения умножения и передачи результата обратно на хост.
Завершите разработку, включив адаптацию
main, чтобы обработать ввод размера матриц и выбор технологии многопоточности. Интеграция всех методов потребует обширного тестирования для обеспечения корректности и эффективности на разных платформах и конфигурациях. - User
как работает pthread_dgemm
- Assistant
Функция
pthread_dgemmявляется поточной функцией, используемой вместе с библиотекой POSIX Threads (Pthreads) для реализации многопоточного умножения матриц. В этой функции происходит часть вычисления для умножения двух матриц, где каждый поток обрабатывает определённый диапазон строк результирующей матрицы.Вот как функция
pthread_dgemmработает, шаг за шагом:-
Получение данных: Функция принимает один аргумент типа
void*, который фактически является указателем на структуру данных специального типа (ThreadDataв данном случае). Эта структура должна содержать все необходимые данные для выполнения вычислений, включая указатели на матрицы и диапазон строк для обработки данным потоком. -
Преобразование указателя: Принятый указатель
void*преобразуется обратно в указатель наThread,Data. Это дает доступ к полям структуры, таким как указатели на матрицы и индексы строк, которые должны быть обработаны текущим потоком. -
Вычисление диапазона обработки: Функция извлекает начальную и конечную строки (
startRowиendRow), которые указывают, какие строки результирующей матрицы должен вычислить текущий поток. -
Выполнение матричного умножения: Внутри двойного цикла
for(поiотstartRowдоendRowи поjот 0 до размера матрицы) происходит вычисление элементов результирующей матрицы. Для каждой пары индексов(i, j)инициализируется переменнаяsum, которая затем накапливает сумму произведений соответствующих элементов строк и столбцов исходных матрицAиB. -
Запись результата: Вычисленное значение сохраняется в соответствующий элемент результирующей матрицы
result. Вычисления выполняются для всех элементов в заданном диапазоне строк. -
Завершение работы потока: После завершения всех вычислений функция возвращает
nullptr, сигнализируя о завершении работы потока.
Вызов этой функции обычно выполняется с использованием
pthread_create, который запускает новый поток, передавая ему эту функцию и указатель на структуру с параметрами. После запуска нескольких потоков, основной поток ожидает их завершения с помощьюpthread_join.Такой подход позволяет распараллеливать вычисление по строкам результирующей матрицы, что может значительно ускорить операцию умножения матриц, особенно для больших размеров матриц и/или на многоядерных системах.
-
- User
напиши пример использования
- Assistant
Давайте реализуем пример, где мы используем функцию
pthread_dgemmдля умножения двух матриц с использованием нескольких потоков. Для этой задачи нам потребуется создать матрицы, функцию для умножения, разделение задач по потокам и обратно связывание результата.Первоначально ниже приведён код, который предполагает, что у вас уже есть определение класса
Matrix, включая его методы для заполнения и вывода, как обсуждалось ранее.Шаг 1: Настройка структуры данных для потоков
struct ThreadData { Matrix *A; Matrix *B; Matrix *result; int startRow; int endRow; };Шаг 2: Функция потока
pthread_dgemmvoid* pthread_dgemm(void* arg) { ThreadData* data = (ThreadData*) arg; Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow; for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->matrix_[i][k] * B->matrix_[k][j]; } result->matrix_[i][j] = sum; } } return nullptr; }Шаг 3: Запуск матричного умножения в нескольких потоках
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads) { pthread_t threads[numThreads]; ThreadData threadData[numThreads]; int rowsPerThread = A.GetSize() / numThreads; int extraRows = A.GetSize() % numThreads; int startRow = 0; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = {&A, &B, &result, startRow, endRow}; pthread_create(&threads[i], nullptr, pthread_dgemm, &threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); } }Шаг 4: Тестирование функциональности
int main() { int size = 512; // Размер матриц int numThreads = 8; // Количество потоков Matrix A(size), B(size), result(size); A.Fill(); B.Fill(); result.InitializeToZero(); // Убедитесь, что есть такой метод, или инициализируйте все элементы нулями. parallelMatrixMultiply(A, B, result, numThreads); result.Print(); return 0; }В данном примере мы создаём и заполняем две входные матрицы, инициализируем матрицу результата, и используем функцию
parallelMatrixMultiplyдля распределения задачи матричного умножения между восьмью потоками.Не забудьте компилировать программу с флагом
-lpthread, чтобы ссылаться на библиотеку POSIX Threads:g++ -o matrix_multiply matrix_multiply.cpp -lpthread - User
lab3.cpp:78:30: error: invalid use of type ‘void’ in parameter declaration 78 | void DGEMM_BLAS_pthread(void arg) { | ~~~~~^~~ lab3.cpp: In function ‘void DGEMM_BLAS_pthread()’: lab3.cpp:80:21: error: base operand of ‘->’ has non-pointer type ‘ThreadData’ 80 | Matrix A = data->A; | ^~ lab3.cpp:81:21: error: base operand of ‘->’ has non-pointer type ‘ThreadData’ 81 | Matrix B = data->B; | ^~ lab3.cpp:82:26: error: base operand of ‘->’ has non-pointer type ‘ThreadData’ 82 | Matrix result = data->result; | ^~ lab3.cpp:83:24: error: base operand of ‘->’ has non-pointer type ‘ThreadData’ 83 | int startRow = data->startRow; | ^~ lab3.cpp:84:22: error: base operand of ‘->’ has non-pointer type ‘ThreadData’ 84 | int endRow = data->endRow; | ^~ lab3.cpp:90:27: error: ‘double Matrix::matrix_’ is private within this context 90 | sum += A->matrix_[i][k] * B->matrix_[k][j]; | ^~~~~~~ In file included from lab3.cpp:1: lab3.h:15:12: note: declared private here 15 | double* matrix_; | ^~~~~~~ lab3.cpp:90:46: error: ‘double** Matrix::matrix_’ is private within this context 90 | sum += A->matrix_[i][k] * B->matrix_[k][j]; | ^~~~~~~ In file included from lab3.cpp:1: lab3.h:15:12: note: declared private here 15 | double** matrix_; | ^~~~~~~ lab3.cpp:92:21: error: ‘double** Matrix::matrix_’ is private within this context 92 | result->matrix_[i][j] = sum; | ^~~~~~~ In file included from lab3.cpp:1: lab3.h:15:12: note: declared private here 15 | double** matrix_; | ^~~~~~~ lab3.cpp:95:12: error: return-statement with a value, in function returning ‘void’ [-fpermissive] 95 | return nullptr; | ^~~~~~~ lab3.cpp: In function ‘void parallelMatrixMultiply(Matrix&, Matrix&, Matrix&, int)’: lab3.cpp:100:37: error: use of deleted function ‘ThreadData::ThreadData()’ 100 | ThreadData threadData[numThreads]; | ^ In file included from lab3.cpp:1: lab3.h:28:8: note: ‘ThreadData::ThreadData()’ is implicitly deleted because the default definition would be ill-formed: 28 | struct ThreadData { | ^~~~~~~~~~ lab3.h:28:8: error: no matching function for call to ‘Matrix::Matrix()’ lab3.cpp:10:1: note: candidate: ‘Matrix::Matrix(const Matrix&)’ 10 | Matrix::Matrix(const Matrix& other) | ^~~~~~ lab3.cpp:10:1: note: candidate expects 1 argument, 0 provided lab3.cpp:3:1: note: candidate: ‘Matrix::Matrix(int)’ 3 | Matrix::Matrix(int size) : size_(size) { | ^~~~~~ lab3.cpp:3:1: note: candidate expects 1 argument, 0 provided In file included from lab3.cpp:1: lab3.h:28:8: error: no matching function for call to ‘Matrix::Matrix()’ 28 | struct ThreadData { | ^~~~~~~~~~ lab3.cpp:10:1: note: candidate: ‘Matrix::Matrix(const Matrix&)’ 10 | Matrix::Matrix(const Matrix& other) | ^~~~~~ lab3.cpp:10:1: note: candidate expects 1 argument, 0 provided lab3.cpp:3:1: note: candidate: ‘Matrix::Matrix(int)’ 3 | Matrix::Matrix(int size) : size_(size) { | ^~~~~~ lab3.cpp:3:1: note: candidate expects 1 argument, 0 provided In file included from lab3.cpp:1: lab3.h:28:8: error: no matching function for call to ‘Matrix::Matrix()’ 28 | struct ThreadData { | ^~~~~~~~~~ lab3.cpp:10:1: note: candidate: ‘Matrix::Matrix(const Matrix&)’ 10 | Matrix::Matrix(const Matrix& other) | ^~~~~~ lab3.cpp:10:1: note: candidate expects 1 argument, 0 provided lab3.cpp:3:1: note: candidate: ‘Matrix::Matrix(int)’ 3 | Matrix::Matrix(int size) : size_(size) { | ^~~~~~ lab3.cpp:3:1: note: candidate expects 1 argument, 0 provided lab3.cpp:107:59: error: no match for ‘operator=’ (operand types are ‘ThreadData’ and ‘’) 107 | threadData[i] = {&A, &B, &result, startRow, endRow}; | ^ In file included from lab3.cpp:1: lab3.h:28:8: note: candidate: ‘ThreadData& ThreadData::operator=(const ThreadData&)’ 28 | struct ThreadData { | ^~~~~~~~~~ lab3.h:28:8: note: no known conversion for argument 1 from ‘’ to ‘const ThreadData&’ lab3.h:28:8: note: candidate: ‘ThreadData& ThreadData::operator=(ThreadData&&)’ lab3.h:28:8: note: no known conversion for argument 1 from ‘’ to ‘ThreadData&&’ lab3.cpp:108:46: error: ‘pthread_dgemm’ was not declared in this scope; did you mean ‘pthread_yield’? 108 | pthread_create(&threads[i], nullptr, pthread_dgemm, &threadData[i]); | ^~~~~~~~~~~~~ | pthread_yield make: *** [Makefile:20: lab4] Error 1
- Assistant
Ошибки, указанные в вашем выводе компилятора, могут быть разрешены путем некоторых корректировок в вашем коде. Вот корректированные части и объяснения:
Проблема с
void*в аргументе функцииУказатель должен быть
void*, если функция предназначена для использования с потоками POSIX. Измените заголовок функции следующим образом:void* DGEMM_BLAS_pthread(void* arg) {Обращение к членам структуры
Ошибки с оператором
->говорят о том, что переменнаяdataдолжна быть указателем, но была неправильно обработана. Убедитесь, что вы делаете правильное приведение к типу и используете указатель:ThreadData* data = static_cast<ThreadData*>(arg);Доступ к приватным членам
MatrixЧлены
matrix_вашего классаMatrixявляются приватными, что препятствует их доступу из внешней функции. Вы можете добавить в классMatrixпубличные методы для получения и установки значений, или же сделать ихpublic, что не является хорошей практикой безопасности и инкапсуляции. Рекомендуется создать методы:double get(int i, int j) const { return matrix_[i][j]; } void set(int i, int j, double value) { matrix_[i][j] = value; }И используйте их в
pthread_dgemm.Ошибка в инициализации массива
threadDataУ вашей структуры нет конструктора по умолчанию из-за наличия ссылок на класс
Matrixв качестве членов. Присвоение через инициализацию нуждается в предварительном определении конструктора.Добавьте конструктор в структуру
ThreadData:struct ThreadData { Matrix *A, *B, *result; int startRow, endRow; ThreadData(Matrix* A, Matrix* B, Matrix* result, int s, int e) : A(A), B(B), result(result), startRow(s), endLink(e) {} }; // Использование ThreadData threadData[i] = ThreadData(&A, &B, &result, startRow, endRow);Ошибка с
nullptrв contextvoidВаша функция потока должна возвращать указатель
void*. ВместоnullptrвозвращайтеNULLили просто0, хотяnullptrдолжно было быть корректно:return nullptr; // Это корректно в C++11 и позже.Ошибка с
pthread_dgemmУбедитесь, что функция
pthread_dgemmобъявлена до её использования или вынеся её в заголовочный файл, который подключается там, где он нужен.Внесите необходимые изменения, и программа должна скомпилироваться успешно. Компиляция с
-lpthreadтакже обязательна. - User
#include "lab3.h"
Matrix::Matrix(int size) : size_(size) { matrix_ = (double**)malloc(size * sizeof(double*)); for (int i = 0; i < size; ++i) { matrix_[i] = (double*)malloc(size * sizeof(double)); } }
Matrix::Matrix(const Matrix& other) : size_(other.size_), matrix_(new double*[other.size_]) { for (int i = 0; i < size_; ++i) { matrix_[i] = new double[size_]{}; for (int j = 0; j < size_; ++j) { matrix_[i][j] = other.matrix_[i][j]; } } }
Matrix::~Matrix() { for (int i = 0; i < size_; ++i) { free(matrix_[i]); } free(matrix_); matrix_ = nullptr; size_ = 0; }
Matrix& Matrix::operator=(Matrix other) { std::swap(matrix_, other.matrix_); std::swap(size_, other.size_); return *this; }
double Matrix::get(int i, int j) const { return matrix_[i][j]; }
void Matrix::set(int i, int j, double value) { matrix_[i][j] = value; }
void Matrix::Fill() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution ran(0.0, 1.0); for (int j = 0; j < size_; j++) { for (int k = 0; k < size_; k++) { matrix_[j][k] = ran(gen); } } }
int Matrix::GetSize() const { return size_; }
void Matrix::Print() const { for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { std::cout << matrix_[i][j] << " "; } std::cout << std::endl; } }
void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for Mul");
Matrix result{size_};
for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { result.matrix_[i][j] = 0; for (int k = 0; k < size_; ++k) { result.matrix_[i][j] += matrix_[i][k] * other.matrix_[k][j]; } if (!std::isfinite(result.matrix_[i][j])) { throw std::runtime_error("Non-finite result encountered"); } } } *this = std::move(result); }
// POSIX Threads void Matrix::DGEMM_BLAS_pthread(void* arg) { ThreadData* data = static_cast<ThreadData*>(arg); Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow;
for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->matrix_[i][k] * B->matrix_[k][j]; } result->matrix_[i][j] = sum; } } return nullptr;}
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads) { pthread_t threads[numThreads]; ThreadData threadData[numThreads]; int rowsPerThread = A.GetSize() / numThreads; int extraRows = A.GetSize() % numThreads;
int startRow = 0; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = {&A, &B, &result, startRow, endRow}; pthread_create(&threads[i], nullptr, pthread_dgemm, &threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); }}
void POSIX() { int size = 512;
int numThreads = 8; Matrix A(size), B(size), result(size); A.Fill(); B.Fill();parallelMatrixMultiply(A, B, result, numThreads); result.Print();}
int main(int argc, char* argv[]) { setlocale(LC_ALL, "Russian"); if (argc != 2) { std::cerr << "Не задан размер матрицы. Повторите попытку." << std::endl; return 1; }
int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Размер матрицы должен быть положительным." << std::endl; return 1; }
POSIX();
return 0; } #ifndef LAB3_H #define LAB3_H
#include // std::high_resolution_clock | duration #include // std::isfinite #include // std::cout | std::endl #include // std::random_device | std::mt19937 | std::uniform_real_distribution | ran #include // std::logic_error | std::runtime_error #include // std::move #include <pthread.h>
class Matrix { private: int size_; double** matrix_;
public: explicit Matrix(int size); Matrix(const Matrix& other); Matrix& operator=(Matrix other); double get(int i, int j) const; void set(int i, int j, double value); ~Matrix(); void Fill(); int GetSize() const; void Print() const; void DGEMM_BLAS(const Matrix& other); void DGEMM_BLAS_pthread(void* arg); };
struct ThreadData { Matrix A, B, result; int startRow, endRow;
ThreadData(Matrix A, Matrix B, Matrix result, int s, int e) : A(A), B(B), result(result), startRow(s), endRow(e) {}};
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads); void DGEMM_BLAS_pthread(void* arg); void POSIX();
#endif // LAB3_H lab3.cpp:88:23: error: cannot convert ‘Matrix’ to ‘Matrix*’ in initialization 88 | Matrix A = data->A; | ~~~~~~^ | | | Matrix lab3.cpp:89:23: error: cannot convert ‘Matrix’ to ‘Matrix’ in initialization 89 | Matrix B = data->B; | ~~~~~~^ | | | Matrix lab3.cpp:90:28: error: cannot convert ‘Matrix’ to ‘Matrix’ in initialization 90 | Matrix *result = data->result; | ~~~~~~^~~~~~ | | | Matrix lab3.cpp:103:12: error: return-statement with a value, in function returning ‘void’ [-fpermissive] 103 | return nullptr; | ^~~~~~~ lab3.cpp: In function ‘void parallelMatrixMultiply(Matrix&, Matrix&, Matrix&, int)’: lab3.cpp:108:37: error: no matching function for call to ‘ThreadData::ThreadData()’ 108 | ThreadData threadData[numThreads]; | ^ In file included from lab3.cpp:1: lab3.h:35:6: note: candidate: ‘ThreadData::ThreadData(Matrix, Matrix, Matrix, int, int)’ 35 | ThreadData(Matrix A, Matrix B, Matrix result, int s, int e) | ^~~~~~~~~~ lab3.h:35:6: note: candidate expects 5 arguments, 0 provided lab3.h:31:8: note: candidate: ‘ThreadData::ThreadData(const ThreadData&)’ 31 | struct ThreadData { | ^~~~~~~~~~ lab3.h:31:8: note: candidate expects 1 argument, 0 provided lab3.h:31:8: note: candidate: ‘ThreadData::ThreadData(ThreadData&&)’ lab3.h:31:8: note: candidate expects 1 argument, 0 provided lab3.cpp:115:59: error: no match for ‘operator=’ (operand types are ‘ThreadData’ and ‘’) 115 | threadData[i] = {&A, &B, &result, startRow, endRow}; | ^ In file included from lab3.cpp:1: lab3.h:31:8: note: candidate: ‘ThreadData& ThreadData::operator=(const ThreadData&)’ 31 | struct ThreadData { | ^~~~~~~~~~ lab3.h:31:8: note: no known conversion for argument 1 from ‘’ to ‘const ThreadData&’ lab3.h:31:8: note: candidate: ‘ThreadData& ThreadData::operator=(ThreadData&&)’ lab3.h:31:8: note: no known conversion for argument 1 from ‘’ to ‘ThreadData&&’ lab3.cpp:116:46: error: ‘pthread_dgemm’ was not declared in this scope; did you mean ‘pthread_yield’? 116 | pthread_create(&threads[i], nullptr, pthread_dgemm, &threadData[i]); | ^~~~~~~~~~~~~ | pthread_yield make: *** [Makefile:20: lab4] Error 1
- Assistant
Похоже, что у вас есть несколько ошибок в коде и недоразумения о том, как должны передаваться данные в потоки и как должны быть организованы переменные в структуре
ThreadData. Перейдем к корректировкам:Исправления кода
-
Типы в
ThreadData: Вы не можете просто передавать экземплярыMatrixкак аргументы потока. Вам необходимо передавать указатели.Исправьте структуру
ThreadDataследующим образом:struct ThreadData { Matrix *A, *B, *result; int startRow, endRow; ThreadData(Matrix *A, Matrix *B, Matrix *result, int s, int e) : A(A), B(B), result(result), startRow(s), endRow(e) {} }; -
Инициализация
threadData[i]: У вас неправильно заданы параметры, поскольку вы пытаетесь присвоить указатели вместо объектов.Исправьте этот сегмент так:
for (int i = 0; i < numThreads; ++i) { int endRow = startCount + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, pthread_dgemm, (void*)&threadData[i]); startRow = endRow; } -
Функция
pthread_dgemm: Ваша функция должна возвращатьvoid*, а неvoid. Неправильное объявление функции приводит к ошибке компиляции.Исправьте сигнатуру функции так:
void* DGEMM_BLAS_pthread(void* arg) { // Ваш код return nullptr; } -
Фиксация всех повторных ошибок: Убедитесь, что ваши обертки потоков включают в себя корректные преобразования типов, и что вы передаете адреса объектов, когда требуется передать указатели. Вы также должны убедиться, что все методы и функции принимают и возвращают корректные типы данных, особенно когда речь идет о возврате из поточной функции, который должен соответствовать
void*. -
Компиляция: При компиляции вашего кода убедитесь, что вы используете
-lpthreadдля линковки с pthreads и передаете-std=c++11или более высокий стандарт, если используете C++11 или новее.
В конечном итоге ваш код должен быть организован так, чтобы правильно синтаксически взаимодействовать с потоками, передавать нужные данные и обрабатывать матричное умножение эффективно и без ошибок доступа к памяти.
-
- User
#include "lab3.h"
Matrix::Matrix(int size) : size_(size) { matrix_ = (double**)malloc(size * sizeof(double*)); for (int i = 0; i < size; ++i) { matrix_[i] = (double*)malloc(size * sizeof(double)); } }
Matrix::Matrix(const Matrix& other) : size_(other.size_), matrix_(new double*[other.size_]) { for (int i = 0; i < size_; ++i) { matrix_[i] = new double[size_]{}; for (int j = 0; j < size_; ++j) { matrix_[i][j] = other.matrix_[i][j]; } } }
Matrix::~Matrix() { for (int i = 0; i < size_; ++i) { free(matrix_[i]); } free(matrix_); matrix_ = nullptr; size_ = 0; }
Matrix& Matrix::operator=(Matrix other) { std::swap(matrix_, other.matrix_); std::swap(size_, other.size_); return *this; }
double Matrix::get(int i, int j) const { return matrix_[i][j]; }
void Matrix::set(int i, int j, double value) { matrix_[i][j] = value; }
void Matrix::Fill() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution ran(0.0, 1.0); for (int j = 0; j < size_; j++) { for (int k = 0; k < size_; k++) { matrix_[j][k] = ran(gen); } } }
int Matrix::GetSize() const { return size_; }
void Matrix::Print() const { for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { std::cout << matrix_[i][j] << " "; } std::cout << std::endl; } }
void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for Mul");
Matrix result{size_};
for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { result.matrix_[i][j] = 0; for (int k = 0; k < size_; ++k) { result.matrix_[i][j] += matrix_[i][k] * other.matrix_[k][j]; } if (!std::isfinite(result.matrix_[i][j])) { throw std::runtime_error("Non-finite result encountered"); } } } *this = std::move(result); }
// POSIX Threads void* Matrix::DGEMM_BLAS_pthread(void* arg) { ThreadData* data = static_cast<ThreadData*>(arg); Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow;
for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->matrix_[i][k] * B->matrix_[k][j]; } result->matrix_[i][j] = sum; } } return nullptr;}
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads) { pthread_t threads[numThreads]; ThreadData threadData[numThreads]; int rowsPerThread = A.GetSize() / numThreads; int extraRows = A.GetSize() % numThreads;
int startRow = 0; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, pthread_dgemm, (void)&threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); }}
void POSIX() { int size = 512;
int numThreads = 8; Matrix A(size), B(size), result(size); A.Fill(); B.Fill();parallelMatrixMultiply(A, B, result, numThreads); result.Print();}
int main(int argc, char* argv[]) { setlocale(LC_ALL, "Russian"); if (argc != 2) { std::cerr << "Не задан размер матрицы. Повторите попытку." << std::endl; return 1; }
int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Размер матрицы должен быть положительным." << std::endl; return 1; }
POSIX();
return 0; } #ifndef LAB3_H #define LAB3_H
#include // std::high_resolution_clock | duration #include // std::isfinite #include // std::cout | std::endl #include // std::random_device | std::mt19937 | std::uniform_real_distribution | ran #include // std::logic_error | std::runtime_error #include // std::move #include <pthread.h>
class Matrix { private: int size_; double** matrix_;
public: explicit Matrix(int size); Matrix(const Matrix& other); Matrix& operator=(Matrix other); double get(int i, int j) const; void set(int i, int j, double value); ~Matrix(); void Fill(); int GetSize() const; void Print() const; void DGEMM_BLAS(const Matrix& other); void* DGEMM_BLAS_pthread(void* arg); };
struct ThreadData { Matrix *A, *B, *result; int startRow, endRow;
ThreadData(Matrix *A, Matrix *B, Matrix *result, int s, int e) : A(A), B(B), result(result), startRow(s), endRow(e) {}};
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads); // void* DGEMM_BLAS_pthread(void* arg); void POSIX();
#endif // LAB3_H lab3.cpp:108:37: error: no matching function for call to ‘ThreadData::ThreadData()’ 108 | ThreadData threadData[numThreads]; | ^ In file included from lab3.cpp:1: lab3.h:35:6: note: candidate: ‘ThreadData::ThreadData(Matrix*, Matrix*, Matrix*, int, int)’ 35 | ThreadData(Matrix *A, Matrix *B, Matrix *result, int s, int e) | ^~~~~~~~~~ lab3.h:35:6: note: candidate expects 5 arguments, 0 provided lab3.h:31:8: note: candidate: ‘constexpr ThreadData::ThreadData(const ThreadData&)’ 31 | struct ThreadData { | ^~~~~~~~~~ lab3.h:31:8: note: candidate expects 1 argument, 0 provided lab3.h:31:8: note: candidate: ‘constexpr ThreadData::ThreadData(ThreadData&&)’ lab3.h:31:8: note: candidate expects 1 argument, 0 provided lab3.cpp:116:46: error: ‘pthread_dgemm’ was not declared in this scope; did you mean ‘pthread_yield’? 116 | pthread_create(&threads[i], nullptr, pthread_dgemm, (void)&threadData[i]); | ^~~~~~~~~~~~~ | pthread_yield make: *** [Makefile:20: lab4] Error 1
- Assistant
Извините за продолжающиеся недоразумения в реализации. Проблемы связаны с использованием неправильных типов и непониманием области видимости функций. Давайте пошагово разберем и устраним выявленные ошибки.
Исправление ошибок
-
Ошибка при создании
ThreadData: Проблема в том, что вы не можете создать массив объектовThreadDataиз-за отсутствия конструктора по умолчанию, который ожидался, так как у объектов есть только конструктор с параметрами. Вы должны создать массив указателейThreadDataи вызывать конструктор для каждого элемента массива:ThreadData* threadData[numThreads]; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = new ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, Matrix::DGEMM_BLAS_pthread, (void*)threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); delete threadData[i]; // Освобождение памяти после завершения потока } -
Ошибка:
'pthread_dgemm' was not declared in this scope: Проблема указывает на то, что имя функции потока задано некорректно или эта функция не видна в области видимости функцииparallelMatrixMultiply. Заменитеpthread_dgemmнаMatrix::DGEMM_BLAS_pthread. -
void* Matrix::DGEMM_BLAS_pthread(void* arg)не может быть методом класса: Методы класса не могут быть использованы непосредственно как функции потока, так как имеют дополнительный параметрthis. СделаемDGEMM_BLAS_pthreadглобальной функцией, не привязанной к классу:void* DGEMM_BLAS_pthread(void* arg) { ThreadData* data = static_cast<ThreadData*>(arg); Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow; for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->get(i, k) * B->get(k, j); } result->set(i, j, sum); } } return nullptr; }Убедитесь, что в заголовочном файле этой функция объявлена с этой сигнатурой и не привязана к классу.
-
Корректность вызова: Поскольку функция
DGEMM_BLAS_pthreadбольше не является методом класса,pthread_create(&threads[i], nullptr, Matrix::DGEMM_BLAS_pthread, (void*)threadData[i]);должен быть изменён наpthread_create(&threads[i], nullptr, DGEMM_BLAS_pthread, (void*)threadData[i]);.
С этими исправлениями реализация многопоточности в вашем приложении должна работать корректно. Не забудьте включить обработку ошибок и освобождение памяти после завершения работы потоков.
-
- User
#include "lab3.h"
Matrix::Matrix(int size) : size_(size) { matrix_ = (double**)malloc(size * sizeof(double*)); for (int i = 0; i < size; ++i) { matrix_[i] = (double*)malloc(size * sizeof(double)); } }
Matrix::Matrix(const Matrix& other) : size_(other.size_), matrix_(new double*[other.size_]) { for (int i = 0; i < size_; ++i) { matrix_[i] = new double[size_]{}; for (int j = 0; j < size_; ++j) { matrix_[i][j] = other.matrix_[i][j]; } } }
Matrix::~Matrix() { for (int i = 0; i < size_; ++i) { free(matrix_[i]); } free(matrix_); matrix_ = nullptr; size_ = 0; }
Matrix& Matrix::operator=(Matrix other) { std::swap(matrix_, other.matrix_); std::swap(size_, other.size_); return *this; }
double Matrix::get(int i, int j) const { return matrix_[i][j]; }
void Matrix::set(int i, int j, double value) { matrix_[i][j] = value; }
void Matrix::Fill() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution ran(0.0, 1.0); for (int j = 0; j < size_; j++) { for (int k = 0; k < size_; k++) { matrix_[j][k] = ran(gen); } } }
int Matrix::GetSize() const { return size_; }
void Matrix::Print() const { for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { std::cout << matrix_[i][j] << " "; } std::cout << std::endl; } }
void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for Mul");
Matrix result{size_};
for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { result.matrix_[i][j] = 0; for (int k = 0; k < size_; ++k) { result.matrix_[i][j] += matrix_[i][k] * other.matrix_[k][j]; } if (!std::isfinite(result.matrix_[i][j])) { throw std::runtime_error("Non-finite result encountered"); } } } *this = std::move(result); }
// POSIX Threads void* DGEMM_BLAS_pthread(void* arg) { ThreadData* data = static_cast<ThreadData*>(arg); Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow;
for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->get(i, k) * B->get(k, j); } result->set(i, j, sum); } } return nullptr;}
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads) { pthread_t threads[numThreads]; ThreadData threadData[numThreads]; int rowsPerThread = A.GetSize() / numThreads; int extraRows = A.GetSize() % numThreads;
int startRow = 0; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, pthread_dgemm, (void)&threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); }}
void POSIX() { int size = 512;
int numThreads = 8; Matrix A(size), B(size), result(size); A.Fill(); B.Fill();parallelMatrixMultiply(A, B, result, numThreads); result.Print();}
int main(int argc, char* argv[]) { setlocale(LC_ALL, "Russian"); if (argc != 2) { std::cerr << "Не задан размер матрицы. Повторите попытку." << std::endl; return 1; }
int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Размер матрицы должен быть положительным." << std::endl; return 1; }
POSIX();
return 0; } #ifndef LAB3_H #define LAB3_H
#include // std::high_resolution_clock | duration #include // std::isfinite #include // std::cout | std::endl #include // std::random_device | std::mt19937 | std::uniform_real_distribution | ran #include // std::logic_error | std::runtime_error #include // std::move #include <pthread.h>
class Matrix { private: int size_; double** matrix_;
public: explicit Matrix(int size); Matrix(const Matrix& other); Matrix& operator=(Matrix other); double get(int i, int j) const; void set(int i, int j, double value); ~Matrix(); void Fill(); int GetSize() const; void Print() const; void DGEMM_BLAS(const Matrix& other); };
struct ThreadData { Matrix *A, *B, *result; int startRow, endRow;
ThreadData(Matrix *A, Matrix *B, Matrix *result, int s, int e) : A(A), B(B), result(result), startRow(s), endRow(e) {}};
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads); void* DGEMM_BLAS_pthread(void* arg); void POSIX();
#endif // LAB3_H lab3.cpp: In function ‘void parallelMatrixMultiply(Matrix&, Matrix&, Matrix&, int)’: lab3.cpp:108:37: error: no matching function for call to ‘ThreadData::ThreadData()’ 108 | ThreadData threadData[numThreads]; | ^ In file included from lab3.cpp:1: lab3.h:34:6: note: candidate: ‘ThreadData::ThreadData(Matrix*, Matrix*, Matrix*, int, int)’ 34 | ThreadData(Matrix *A, Matrix *B, Matrix *result, int s, int e) | ^~~~~~~~~~ lab3.h:34:6: note: candidate expects 5 arguments, 0 provided lab3.h:30:8: note: candidate: ‘constexpr ThreadData::ThreadData(const ThreadData&)’ 30 | struct ThreadData { | ^~~~~~~~~~ lab3.h:30:8: note: candidate expects 1 argument, 0 provided lab3.h:30:8: note: candidate: ‘constexpr ThreadData::ThreadData(ThreadData&&)’ lab3.h:30:8: note: candidate expects 1 argument, 0 provided lab3.cpp:116:46: error: ‘pthread_dgemm’ was not declared in this scope; did you mean ‘pthread_yield’? 116 | pthread_create(&threads[i], nullptr, pthread_dgemm, (void)&threadData[i]); | ^~~~~~~~~~~~~ | pthread_yield make: *** [Makefile:20: lab4] Error 1
- Assistant
Ваш код содержит несколько ошибок, вызывающих проблемы при компиляции и выполнении. Для устранения ошибок вам необходимо сделать следующие изменения и уточнения:
Исправление ошибок при объявлении и использовании
ThreadDataОшибки связаны с неправильной созданием массива
ThreadData, поскольку уThreadDataнет конструктора по умолчанию, и вы не можете просто объявить массив статических объектов без инициализации. Вам нужно использовать массив указателей и создавать каждый объектThreadDataдинамически:ThreadData* threadData[numThreads]; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = new ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, DGEMM_BLAS_pthread, threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); delete threadData[i]; // Освободить память после завершения потока }Правильная передача функции потока
Вы пытались передать
pthread_dgemmвpthread_create, но в вашем коде нет такой функции. Функция, которую вы задаете в качестве поточной — этоDGEMM_BLAS_pthread. Убедитесь, что вы правильно передаете эту функцию:pthread_create(&threads[i], nullptr, DGEMM_BLAS_pthread, (void*)threadData[i]);Обеспечение корректности
#includeдирективПроверьте, что в файле
lab3.hи в начале каждого файла реализации (.cpp) присутствует#include "lab3.h"для обеспечения видимости всех объявлений классов, структур и функций.Компиляция
При компиляции вашего проекта убедитесь, что вы используете ключ
-pthreadдля корректной линковки с библиотекой pthreads:g++ -o your_program_name lab3.cpp -pthreadС учетом всех этих корректировок, ваш код должен успешно компилироваться и работать, осуществляя параллельное умножение матриц с помощью pthreads. Убедитесь, что вы обращаете внимание на каждую деталь, поскольку многопоточность требует точной работы с памятью и ресурсами.
- User
куда вообще вставить код, который ты написал. пиши разборчивее
- Assistant
Прошу прощения за недоразумение. Давайте более детально рассмотрим, как сделать ваш код компилируемым и исправить ошибки, которые вы указали. Я предоставлю вам порядок действий и объяснения, как и куда следует вставлять каждый фрагмент кода, чтобы исправить ошибки.
Корректировка структуры
ThreadDataПервым делом вам нужно убедиться, что структура
ThreadDataкорректно объявлена в вашем заголовочном файлеlab3.h:struct ThreadData { Matrix *A, *B, *result; int startRow, endRow; ThreadDocum(Document *doc, int sRow, int eRow) : doc(doc), startRow(sRow), endRow(eRow) {} };Здесь данный конструктор позволяет инициализировать все поля структуры при создании объекта.
Функция потока
DGEMM_BLAS_pthreadЭту функцию следует объявить глобальной (не методом класса), и ее код должен быть размещен в файле исполнения (например,
lab3.cpp). Убедитесь, что функция принимает аргумент типаvoid*и возвращает значение типаvoid*, согласно требованиям библиотеки pthreads:void* DGEMM_BLAS_pthread(void* arg) { ThreadData* data = static_cast<ThreadData*>(arg); Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow; for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->get(i, k) * B->get(k, j); } result->set(i, j, sum); } } return nullptr; }Использование функции
parallelMatrixMultiplyЭта функция координирует создание потоков и вызов функции
DGEMM_BLAS_pthread. Функцию следует вызвать в вашей основной функции или в любом месте, где вы хотите выполнить умножение матриц с использованием потоков. Ее текст следует разместить вlab3.cpp:void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads) { pthread_t threads[numThreads]; ThreadData *threadData[numThreads]; int rowsPerThread = A.GetSize() / numThreads; int extraRows = A.GetSize() % numThreads; int startRow = 0; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = new ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, DGEMM_BLAS_pthread, threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); delete threadData[i]; // Clean up allocated memory } }Вызов в
mainИ последнее, в функции
mainвашего файлаlab3.cppубедитесь, что вызываете методparallelMatrixMultiplyдля выполнения многопоточного умножения матриц:int main(int argc, char* argv[]) { setlocale(LC_ALL, "Russian"); if (argc != 2) { std::cerr << "Не задан размер матрицы. Повторите попытку." << std::endl; return 1; } int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Размер матрицы должен быть положительным." << std::endl; return 1; } Matrix A(size), B(size), result(size); A.Fill(); B.Fill(); int numThreads = 4; // или любое другое число, зависящее от вашей системы и задачи parallelMatrixMore Multiply(A, B, result, numThreads); result.Print(); return 0; }Убедитесь, что компилируете программу с флагом
-pthreadдля корректной линковки с библиотекой pthreads. - User
Для программы умножения двух квадратных матриц DGEMM BLAS разработанной в лабораторной работе №3 на языке С/С++ реализовать многопоточные вычисления. В потоках необходимо реализовать инициализацию массивов случайными числами типа double и равномерно распределить вычислительную нагрузку. Обеспечить возможность задавать размерность матриц и количество потоков при запуске программы. Многопоточность реализовать несколькими способами.
- С использованием библиотеки стандарта POSIX Threads. #include "lab4.h"
Matrix::Matrix(int size) : size_(size) { matrix_ = (double**)malloc(size * sizeof(double*)); for (int i = 0; i < size; ++i) { matrix_[i] = (double*)malloc(size * sizeof(double)); } }
Matrix::Matrix(const Matrix& other) : size_(other.size_), matrix_(new double*[other.size_]) { for (int i = 0; i < size_; ++i) { matrix_[i] = new double[size_]{}; for (int j = 0; j < size_; ++j) { matrix_[i][j] = other.matrix_[i][j]; } } }
Matrix::~Matrix() { for (int i = 0; i < size_; ++i) { free(matrix_[i]); } free(matrix_); matrix_ = nullptr; size_ = 0; }
Matrix& Matrix::operator=(Matrix other) { std::swap(matrix_, other.matrix_); std::swap(size_, other.size_); return *this; }
double Matrix::get(int i, int j) const { return matrix_[i][j]; }
void Matrix::set(int i, int j, double value) { matrix_[i][j] = value; }
void Matrix::Fill() { std::random_device rd; std::mt19937 gen(rd()); std::uniform_real_distribution ran(0.0, 1.0); for (int j = 0; j < size_; j++) { for (int k = 0; k < size_; k++) { matrix_[j][k] = ran(gen); } } }
int Matrix::GetSize() const { return size_; }
void Matrix::Print() const { for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { std::cout << matrix_[i][j] << " "; } std::cout << std::endl; } }
void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for Mul");
Matrix result{size_};
for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { result.matrix_[i][j] = 0; for (int k = 0; k < size_; ++k) { result.matrix_[i][j] += matrix_[i][k] * other.matrix_[k][j]; } if (!std::isfinite(result.matrix_[i][j])) { throw std::runtime_error("Non-finite result encountered"); } } } *this = std::move(result); }
// POSIX Threads void* DGEMM_BLAS_pthread(void* arg) { ThreadData* data = static_cast<ThreadData*>(arg); Matrix *A = data->A; Matrix *B = data->B; Matrix *result = data->result; int startRow = data->startRow; int endRow = data->endRow;
for (int i = startRow; i < endRow; ++i) { for (int j = 0; j < B->GetSize(); ++j) { double sum = 0.0; for (int k = 0; k < A->GetSize(); ++k) { sum += A->get(i, k) * B->get(k, j); } result->set(i, j, sum); } } return nullptr;}
void parallelMatrixMultiply(Matrix& A, Matrix& B, Matrix& result, int numThreads) { pthread_t threads[numThreads]; ThreadData *threadData[numThreads]; int rowsPerThread = A.GetSize() / numThreads; int extraRows = A.GetSize() % numThreads;
int startRow = 0; for (int i = 0; i < numThreads; ++i) { int endRow = startRow + rowsPerThread + (i < extraRows ? 1 : 0); threadData[i] = new ThreadData(&A, &B, &result, startRow, endRow); pthread_create(&threads[i], nullptr, DGEMM_BLAS_pthread, threadData[i]); startRow = endRow; } for (int i = 0; i < numThreads; ++i) { pthread_join(threads[i], nullptr); delete threadData[i]; }}
void POSIX() { int size = 3;
int numThreads = 8; Matrix A(size), B(size), result(size); A.Fill(); B.Fill();parallelMatrixMultiply(A, B, result, numThreads); result.Print();}
int main() {
POSIX();
return 0; }
- Assistant
Благодарю за предоставление полного кода. Всё выглядит корректно в реализации многопоточности при помощи POSIX Threads для умножения двух квадратных матриц. Однако, я хотел бы предложить несколько улучшений и подсказок, которые помогут улучшить стабильность и производительность вашей программы:
1. Управление памятью
Вы динамически создаёте объекты
ThreadDataв функцииparallelMatrixMultiply, для каждого потока. После завершения потока, вы удаляете эти объекты, что является хорошей практикой. Удостоверьтесь, что в случае возникновения исключений, данные объекты также корректно удаляются, чтобы избежать утечек памяти. Рассмотрите использование умных указателей (std::unique_ptr), если ваш проект позволяет использовать C++11 или новее.#include <memory> ... std::unique_ptr<ThreadData[]> threadData(new ThreadData[numThreads]);2. Проверка аргументов функций
Ваш код не проверяет вводимые параметры на корректность (например, размер матрицы должен быть положительным). Стоит добавить проверки, чтобы гарантировать корректность входных данных и избежать возможных ошибок выполнения.
3. Разбиение работ
Вы равномерно распределяете нагрузку между потоками, но возможен случай, когда число строчек матрицы не делится нацело на количество потоков. Вы корректно добавляете остаток строк первым нескольким потокам, что является правильным подходом.
4. Результаты выполнения
После выполнения операций в потоках и объединения результатов, вывести результат умножения матриц — это отличный способ для проверки корректности операций. Удостоверьтесь, что матрицы заполнены правильно.
5. Компилирование программы
Удостоверьтесь, что ваша программа компилируется с флагом
-pthreadдля корректной работы многопоточных операций POSIX в Linux:g++ -o matrix_program main.cpp -pthread6. Ошибки времени выполнения
В вашем текущем коде, функции
getиsetиспользуются для доступа к элементам матрицы, что может замедлить выполнение доступа к элементам из-за дополнительных вызовов функций. Учитывая, что это внутренний интерфейс Matrix, возможно, стоит сделатьmatrix_открытым для внутреннего использования или использовать inline функции, чтобы минимизировать накладные расходы.В целом, ваш код хорошо структурирован и должен корректно выполнять заданные задачи умножения матриц в многопоточном режиме.
- User
а теперь сделай С использованием библиотеки стандарта OpenMP.
- Assistant
Чтобы реализовать умножение квадратных матриц с использованием библиотеки OpenMP, вам нужно внести некоторые изменения в ваш код. OpenMP обеспечивает простой способ распараллеливания циклов с помощью директив компилятора, что упрощает работу с многопоточностью и позволяет добиться высокой производительности.
Шаги для добавления OpenMP:
-
Подключите библиотеку OpenMP в начале вашего файла:
#include <omp.h> -
Модифицируйте функцию
DGEMM_BLAS, чтобы использовать OpenMP для параллелизации вложенных циклов, управляющих умножением матриц. Вы можете воспользоваться директивой#pragma omp parallel forв вашей функции для распараллеливания циклов.
void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std: :logic_error("Incorrect matrix size for Mul"); Matrix result{size_}; #pragma omp parallel for collapse(2) default(none) shared(result) for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { double temp = 0.0; for (int k = 0; k < size_; ++k) { temp += matrix_[i][k] * other.matrix_[k][j]; } result.matrix_[i][j] = temp; } } *this = std::move(result); }#pragma omp parallel for: Эта директива сообщает компилятору OpenMP распараллелить следующий за ней циклfor.collapse(2): Это указание заставляет OpenMP объединять два вложенных цикла в один большой параллельный цикл, что может улучшить использование потоков.default(none): Это утверждение заставляет программиста явно указывать, как каждая переменная должна быть доступна внутри параллельного блока.shared(result): Указывает, что переменнаяresultдолжна быть общей для всех потоков.
-
Компилируйте программу с поддержкой OpenMP. Убедитесь, что при компиляции вашей программы используется флаг
-fopenmp, который активирует поддержку OpenMP в GCC:g++ -o matrix_program your_program.cpp -fopenmp -
Запустите программу, предварительно задав количество потоков (если требуется), используя переменную окружения
OMP_NUM_THREADS:OMP_NUM_THREAD=4 ./matrix_program
Использование OpenMP позволяет более просто управлять многопоточностью, эффективно распределяя вычислительные задачи между потоками. Таким образом, вы можете ускорить процесс умножения матриц, особенно на больших матрицах.
-
- User
lab4.cpp: In member function ‘void Matrix::DGEMM_BLAS(const Matrix&)’: lab4.cpp:77:33: error: ‘other’ not specified in enclosing ‘parallel’ 77 | temp += matrix_[i][k] * other.matrix_[k][j]; | ^~~~~ lab4.cpp:71:11: note: enclosing ‘parallel’ 71 | #pragma omp parallel for collapse(2) default(none) shared(result) | ^~~ make: *** [Makefile:21: lab4] Error 1
- Assistant
Ошибка, которую вы видите, указывает на то, что переменная
otherне явно указана как общая (shared) в контексте параллельного блока OpenMP, что приводит к ошибке компиляции. В директиве#pragma ompс параметромdefault(none)необходимо явно указать области видимости всех используемых переменных.Давайте исправим вашу функцию
DGEMM_BLAS, чтобы компиляция прошла успешно. Нужно добавить переменныеotherиmatrix_в списокshared, так как они используются всеми потоками и не изменяются в процессе вычислений:void Matrix::DGEMM_BLAS(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for Mul"); Matrix result{size_}; #pragma omp parallel for collapse(2) default(none) shared(other, matrix_, result, size_) for (int i = 0; i < size_; ++i) { for (int j = 0; j < size_; ++j) { double temp = 0.0; for (int k = 0; k < size_; ++k) { temp += matrix_[i][k] * other.matrix_[k][j]; } result.matrix_[i][j] = temp; } } *this = std::move(result); }Здесь мы указали следующие директивы:
shared(other, matrix_, result, size_): Это гарантирует, что переменныеother,matrix_,resultиsize_являются общими для всех потоков в блоке parallel.
Теперь при компиляции укажите флаг
-fopenmp, чтобы компилятор знал, что нужно использовать поддержку OpenMP:g++ -o matrix_program your_program.cpp -fopenmpПосле внесения этих изменений код должен компилироваться и исполняться без ошибок.
- User
а теперь C использованием библиотеки Intel TBB.
- Assistant
Для реализации многопоточного умножения двух матриц с использованием библиотеки Intel Threading Building Blocks (TBB), вы можете использовать функциональность TBB, такую как
parallel_for, что позволяет эффективно распараллеливать циклы.Шаги для интеграции TBB в ваш проект:
-
Подключите библиотеку TBB в вашем исходном файе:
#include <tbb/tbb.h> -
Перепишите функцию умножения матриц с использованием
tbb::parallel_for:
#include <tbb/tbb.h> void Matrix::DGEMM_TBB(const Matrix& other) { if (size_ != other.size_) throw std::logic_error("Incorrect matrix size for multiplication"); Matrix result(size_); tbb::parallel_for(tbb::blocked_range<size_t>(0, size_), [&] (const tbb::blocked_range<size_t>& r) { for (size_t i = r.begin(); i != r.end(); ++i) { for (int j = 0; j < size_; j++) { double sum = 0.0; for (int k = 0; k < size_; k++) { sum += matrix_[i][k] * other.matrix_[k][j]; } result.matrix_[i][j] = sum; } } }); *this = std::move(result); }В этом примере:
tbb::parallel_forиспользуется для параллельного выполнения внешнего цикла.tbb::blocked_range<size_t>(0, size_)определяет диапазон индексов, который TBB разделяет между потоками.- Лямбда-функция описывает, что именно каждый поток должен выполнить.
-
Скомпилируйте вашу программу с TBB. Убедитесь, что компилятор знает, где найти заголовки и библиотеку TBB. Для GCC это можно сделать так:
g++ -o matrix_program your_program.cpp -ltbbЭто компилирует программу с динамической ссылкой на TBB. Убедитесь, что на вашей системе установлен TBB.
-
Запуск программы. После успешной компиляции программа должна выполнять умножение матриц, используя возможности параллелизма TBB.
Дополнительные настройки:
-
Оптимизация производительности: Эффективность распараллеливания может зависеть от характеристик матриц и распределения работы между потоками. В случае необходимости, можно настроить гранулярность разбиения задач.
-
Обработка больших данных: Если размер матрицы слишком велик, убедитесь, что ваша система имеет достаточно оперативной памяти для их обработки, чтобы избежать замедления из-за свопинга или других проблем с памятью.
-
Использование локальности данных: Для повышения эффективности кэширования можно воспользоваться блочным умножением матриц в случае больших размеров матриц.
Применение TBB позволяет не только ускорить вычисления за счет многопоточности, но и предоставляет гибкие инструменты для оптимизации работы с параллельными алгоритмами.
-
- User
напиши main
- Assistant
Для создания основной функции
mainв контексте вашего проекта по умножению матриц, где использование Intel TBB для умножения уже реализовано, мы могли бы организовать ввод размеров матриц и количество потоков (для OpenMP), запуск операций заполнения и умножения матриц, а затем выводить их результаты.Внизу приведен пример такой функции
main. Этот код предполагает, что у вас есть классMatrix, который уже определен и включает методы для выполнения всех необходимых операций.#include <iostream> #include "Matrix.h" // убедитесь, что ваш заголовочный файл называется правильно int main(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " matrix_size num_threads" << std::endl; return 1; } int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Matrix size must be positive." << std::endl; return 1; } int numThreads = std::atoi(argv[2]); if (numThreads <= 0) { std::cerr << "Number of threads must be positive." << std::endl; return 1; } // Установка числа потоков для TBB tbb::task_scheduler_init init(numThreads); Matrix A(size), B(size), C(size); // создаем три матрицы размером size x size // Заполнение матриц случайными числами A.Fill(); B.Fill(); // Умножение матриц C = A; C.DGEMM_TBB(B); // Печать результатов std::cout << "Matrix A: " << std::endl; A.Print(); std::cout << "Matrix B: " << std::endl; B.Print(); std::cout << "Result matrix C (A * B): " << std::endl; C.Print(); return 0; }Не забудьте компилировать вашу программу с необходимыми флагами и библиотеками, например:
g++ -o matrix_multiplication main.cpp -ltbbПримечания:
- Убедитесь, что ваш класс
Matrixподдерживает все необходимые операции, указанные вmain. tbb::task_scheduler_init init(numThreads);используется для установки количества потоков, которые будет использовать TBB. Это поможет контролировать количество активных потоков в вашей программе.- Проверьте обработку неправильных аргументов, которые передаются программе, чтобы избежать выполнения с некорректными данными.
- Функция
Matrix::Print()используется для вывода матриц на экран. Это полезно для проверки результатов умножения на небольших матрицах.
Этот код позволит испытать ваши алгоритмы умножения матриц в многопоточной среде с помощью Intel TBB.
- Убедитесь, что ваш класс
- User
lab4.cpp:198:10: error: ‘task_scheduler_init’ is not a member of ‘tbb’ 198 | tbb::task_scheduler_init init(numThreads); | ^~~~~~~~
- Assistant
Похоже, используется более новая версия библиотеки Intel TBB, в которой класс
tbb::task_scheduler_initустарел и больше не используется для инициализации планировщика задач. В новых версиях TBB, планировщик задач автоматически инициализируется и оптимизируется за вас. Однако, если вы всё-таки хотите контролировать количество потоков, используемых TBB, вы можете использоватьtbb::global_control.Вот сайт код для установки количества потоков в вашем приложении:
#include <iostream> #include "Matrix.h" // Убедитесь, что ваш заголовочный файл называется правильно #include <tbb/global_control.h> // Для контроля количества потоков int main(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " matrix_size num_threads" << std::endl; return 1; } int size = std::atoi(argv[1]); if (size <= 0) { std::cerr << "Matrix size must be positive." << std::endl; return 1; } int numThreads = std::atoi(argv[2]); if (numThreads <= 0) { std::cerr << "Number of threads must be positive." << std::endl; return 1; } // Установка числа потоков для TBB tbb::global_control control(tbb::global_control::max_allowed_parallelism, numThreads); Matrix A(size), B(size), C(size); // создаем три матрицы размером size x size // Заполнение матриц случайными числами A.Fill(); B.Fill(); // Умножение матриц C = A; C.DGEMM_TBB(B); // Печать результатов std::cout << "Matrix A: " << std::endl; A.Print(); std::cout << "Matrix B: " << std::endl; B.Print(); std::cout << "Result matrix C (A * B): " << std::endl; C.Print(); return 0; }Компиляция
Убедитесь, что у вас установлена последняя версия TBB и компилируйте вашу программу со всеми необходимыми флагами:
g++ -o matrix_multiplication main.cpp -ltbbЭтот код позволяет контролировать количество потоков через
tbb::global_control, что адекватно заменяет старый способ управления планировщиком через устаревшийtask_scheduler_init. - User
теперь возникают такие ошибки /usr/bin/ld: /tmp/cc9DFW08.o: in function
tbb::detail::d1::task_group_context::task_group_context(tbb::detail::d1::task_group_context::context_traits, tbb::detail::d0::string_resource_index)': /usr/include/oneapi/tbb/task_group.h:271: undefined reference totbb::detail::r1::initialize(tbb::detail::d1::task_group_context&)' /usr/bin/ld: /tmp/cc9DFW08.o: in functiontbb::detail::d1::task_group_context::~task_group_context()': /usr/include/oneapi/tbb/task_group.h:367: undefined reference totbb::detail::r1::destroy(tbb::detail::d1::task_group_context&)' /usr/bin/ld: /tmp/cc9DFW08.o: in functionMatrix::DGEMM_TBB(Matrix const&)': /usr/include/oneapi/tbb/detail/_small_object_pool.h:61: undefined reference totbb::detail::r1::allocate(tbb::detail::d1::small_object_pool*&, unsigned long)' /usr/bin/ld: /tmp/cc9DFW08.o: in functiontbb::detail::d1::max_concurrency()': /usr/include/oneapi/tbb/task_arena.h:466: undefined reference totbb::detail::r1::max_concurrency(tbb::detail::d1::task_arena_base const*)' /usr/bin/ld: /tmp/cc9DFW08.o: in functiontbb::detail::d1::execute_and_wait(tbb::detail::d1::task&, tbb::detail::d1::task_group_context&, tbb::detail::d1::wait_context&, tbb::detail::d1::task_group_context&)': /usr/include/oneapi/tbb/detail/_task.h:191: undefined reference totbb::detail::r1::execute_and_wait(tbb::detail::d1::task&, tbb::detail::d1::task_group_context&, tbb::detail::d1::wait_context&, tbb::detail::d1::task_group_context&)' /usr/bin/ld: /tmp/cc9DFW08.o: in functiontbb::detail::d1::global_control::global_control(tbb::detail::d1::global_control::parameter, unsigned long)': /usr/include/oneapi/tbb/global_control.h:85: undefined reference totbb::detail::r1::create(tbb::detail::d1::global_control&)' /usr/bin/ld: /tmp/cc9DFW08.o: in functiontbb::detail::d1::global_control::~global_control()': /usr/include/oneapi/tbb/global_control.h:95: undefined reference totbb::detail::r1::destroy(tbb::detail::d1::global_control&)' /usr/bin/ld: /tmp/cc9DFW08.o: in function `tbb::detail::d1::start_for<tbb::detail::d1::blocked_range, Matrix::DGEMM_TBB(Matrix const&)::{lambda(tbb::detail::d1::blocked_range const&)#1}, tbb::detail::d1::auto_partitioner const>::execute(tbb::detail::d1::execution_data&)': /usr/include/oneapi/tbb/detail/_small_object_pool.h:53: undef - Assistant
Ошибка, которую вы видите, связана с линковкой и нехваткой библиотеки
tbbпри компиляции. Это указывает на то, что компилятору не удаётся найти или корректно ссылаться на функции TBB, определенные в соответствующих библиотеках. Давайте решим эту проблему.Правильная компиляция и линковка TBB
-
Убедитесь, что библиотека TBB установлена: Проверьте, находится ли TBB на вашем компьютере и настроены ли переменные окружения, указывающие на местоположение библиотек и заголовочных файлов TBB.
-
Правильный путь к библиотеке и заголовкам: Если TBB установлена в нестандартном размещении, может потребоваться указать компилятору, где искать заголовочные файлы и библиотеку. Для этого используйте параметры компилятора
-I(для заголовочных файлов) и-L(для библиотек). Например:g++ -o matrix_multiplication your_program.cpp -I/path/to/tbb/include -L/path/to/tbb/lib -ltbb -
Флаг
-ltbb: Убедитесь, что вы используете флаг-ltbbв командной строке компиляции для правильной линковки с библиотекой. -
Запуск на Linux: Если вы используете Linux и сталкиваетесь с проблемами линковки, возможно, будет полезно добавить флаг
-Wl,-rpath,/path/to/tb/libдля указания пути к динамическим библиотекам при выполнении.Пример компиляции:
g++ -o matrix_multiplication your_program.cpp -I/path/to/tbb/include -L/path/to/tbb/lib -ltbb -Wl,-rpath,/path/to/tbb/lib -
Проверьте, используется ли стандартная версия C++: TBB, особенно новые версии, могут требовать использования C++11 или выше. Убедитесь, что вы передаёте
-std=c++11или выше в строке компиляции:g++ -std=c++11 -o matrix_multiplication your_program.cpp -ltbb
Пример команды для компиляции с указанием путей и версии стандарта C++:
g++ -std=c++11 -o matrix_multiplication your_program.cpp -I/usr/local/include -L/usr/local/lib -ltbb -Wl,-rpath,/usr/local/libУдостоверьтесь, что вы следуете этим шагам внимательно, и проверьте корректность путей до библиотек и заголовочных файлов на вашей системе, так как некорректные пути — частая причина ошибок в линковке.
-
- User
а как скачать ttb
- Assistant
Intel Threading Building Blocks (TBB) — это библиотека для параллельного программирования на C++, которую можно установить различными способами в зависимости от вашей операционной системы. Ниже приводятся инструкции по установке TBB на различных платформах.
Установка на Linux
Для большинства дистрибутивов Linux установка TBB может быть выполнена через пакетный менеджер. Например, для Ubuntu вы можете использовать
apt:sudo apt update sudo apt install libtbb-devЭто установит библиотеки TBB, а также заголовочные файлы, которые необходимы для разработки.
Установка на macOS
На macOS TBB можно установить с помощью Homebrew:
brew install tbbЭто скачает и установит последнюю версию TBB.
Установка на Windows
Для Windows можно скачать бинарные файлы или исходный код TBB с GitHub или использовать менеджер пакетов vcpkg:
-
Скачать и установить через vcpkg:
vcpkg install tbb -
Скачать бинарные файлы или исходный код с GitHub:
- Перейдите на страницу релизов TBB на GitHub: Intel TBB GitHub.
- Скачайте нужный релиз в зависимости от вашей системы (существуют различные версии для Windows, Linux и macOS).
- Распакуйте архив и добавьте пути к библиотекам и заголовочным файлам в переменные окружения вашей системы.
Компиляция исходного кода (опционально для всех ОС)
Если вы хотите скомпилировать TBB сами из исходного кода, выполните следующие шаги:
-
Клонируйте репозиторий TBB с GitHub:
git clone https://github.com/oneapi-src/oneTBB.git cd oneTBB -
Следуйте инструкциям по сборке в файле
README.mdилиBUILD.md, которые обычно включают выполнение скриптов сборки или использование CMake:mkdir build cd build cmake .. make -
После сборки добавьте путь к скомпилированным библиотекам в переменные окружения вашей системы, например,
LD_LIBRARY_PATHна Linux илиPATHна Windows.
Выбор метода установки зависит от ваших предпочтений и доступности инструментов на вашей системе. Убедитесь, что после установки вы проверяете, что TBB корректно работает, компилируя и запуская какую-либо тестовую программу, использующую TBB.
-