From d771e0eb052bf680c771216935f2b49e48dba9a9 Mon Sep 17 00:00:00 2001 From: GoriachevaKsenia Date: Sat, 23 May 2026 00:30:58 +0300 Subject: [PATCH 1/5] Add report --- .../all/report.md | 142 +++++++++++ .../omp/report.md | 141 +++++++++++ .../report.md | 220 ++++++++++++++++++ .../seq/report.md | 174 ++++++++++++++ .../stl/report.md | 135 +++++++++++ .../tbb/report.md | 128 ++++++++++ 6 files changed, 940 insertions(+) create mode 100644 tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md create mode 100644 tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md create mode 100644 tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md create mode 100644 tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md create mode 100644 tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md create mode 100644 tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md new file mode 100644 index 0000000000..9b8b1d2735 --- /dev/null +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md @@ -0,0 +1,142 @@ +# Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS) - ALL + +- Student: Горячева Ксения Александровна +- Technology: ALL +- Variant: 7 + +## 1. Контекст +Гибридная схема MPI + OpenMP +объединяет: + +- распределённую память (MPI); +- общую память (OpenMP). + +Это позволяет использовать +как межпроцессный, +так и внутрипроцессный параллелизм. + +## 2. Постановка задачи + +Полная постановка задачи приведена в отчёте для SEQ-версии [seq/report.md](../seq/report.md). +Кратко: + +Входные данные: +Две разреженные комплексные матрицы: +- A — комплексная матрица размера m × n +- B — комплексная матрица размера n × k +представленные в формате CCS: + +Выходные данные: +Матрица: +C = A * B +в формате CCS. + +OpenMP-реализация должна давать **идентичный** SEQ результат при любом количестве потоков. + +## 3. Базовый алгоритм +Последовательная версия (SEQ): + +1. Проверить корректность входных данных. +2. Инициализировать структуру результата. +3. Для каждого столбца матрицы B: +- пройти по ненулевым элементам; +- выполнить умножение элементов; +- накопить значения в accumulator. +4. Отсортировать индексы строк. +5. Сохранить ненулевые значения в матрицу результата. + +## 4. Схема распараллеливания +Алгоритм включает: +1. Разделение столбцов между MPI-процессами; +2. Параллельную обработку столбцов внутри процесса; +3. Сбор результатов через MPI_Gatherv; +4. Формирование глобальной CCS-матрицы. + +### MPI + +Столбцы матрицы B распределяются между процессами: + +```cpp +int cols_per_proc = + (b.cols + size - 1) / size; +Каждый процесс обрабатывает собственный диапазон столбцов. +OpenMP +Внутри процесса используется: + +#pragma omp parallel for +для обработки локальных столбцов. + +## 5. Детали реализации +- `all/include/ops_all.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsSALL`. +- `all/src/ops_all.cpp` — реализация методов. + +RunImpl +Основные этапы: +- определение ранга процесса; +- распределение столбцов; +- вычисление локальных результатов; +- сбор данных на процессе 0; +- рассылка итоговой матрицы. +Для внутреннего распараллеливания используется OpenMP. + +Коммуникации MPI +Используются: + +MPI_Gather + +MPI_Gatherv + +MPI_Bcast + +для сборки результирующей CCS-матрицы. + +## 6. Проверка корректности +Проверялась: +- корректность вычислений; +- согласованность результатов между процессами; +- корректность сборки col_ptr. +Гибридная версия проходит все функциональные тесты +и совпадает с SEQ-версией. + +## 7. Экспериментальная среда + +CPU: Intel(R) Core(TM) i5-9300H CPU @ 2.40GHz +OS: Windows 10 +Compiler: MinGW-w64 GCC, C++17 +Build type: Release +CMake: 4.0.1 +RAM: 32 GB + +### Сборка +cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release +cmake --build build --config Release --parallel + +### Запуск тестов +cd build/bin +mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" + +## 8. Результаты +| Режим | Workers (p) | Time (сек) | Speedup | Efficiency | +| :---- | :---------: | :--------: | :-----: | :--------: | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| ALL | 2 | 0.000399 | 0.42 | 0.21 | +| ALL | 4 | 0.005986 | 0.03 | 0.01 | +| ALL | 8 | 0.026888 | 0.01 | 0.00 | +| ALL | 16 | 0.103833 | 0.00 | 0.00 | + + +## 9. Выводы +Гибридная модель MPI + OpenMP позволяет эффективно выполнять умножение разреженных матриц на +многопроцессорных системах. +Преимущества: +- масштабируемость; +- возможность работы на кластерах; +- эффективное использование вычислительных ресурсов. +Недостатки: +- сложность реализации; +- необходимость синхронизации процессов; +- накладные расходы на передачу данных. +Данная реализация является наиболее производительной среди всех разработанных версий при больших +объёмах вычислений.ть вычисления с минимальными изменениями исходного кода. +На задачах большего размера эффективность OpenMP будет выше. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md new file mode 100644 index 0000000000..9151d8c31e --- /dev/null +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md @@ -0,0 +1,141 @@ +# Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS) - OMP + +- Student: Горячева Ксения Александровна +- Technology: OMP +- Variant: 7 + +## 1. Контекст +OpenMP позволяет эффективно распараллеливать +циклы с независимыми итерациями +в системах с общей памятью. + +В задаче умножения CCS-матриц +обработка столбцов результирующей матрицы независима, +что делает алгоритм хорошо подходящим +для распараллеливания через OpenMP. + +## 2. Постановка задачи + +Полная постановка задачи приведена в отчёте для SEQ-версии [seq/report.md](../seq/report.md). +Кратко: + +Входные данные: +Две разреженные комплексные матрицы: +- A — комплексная матрица размера m × n +- B — комплексная матрица размера n × k +представленные в формате CCS: + +Выходные данные: +Матрица: +C = A * B +в формате CCS. + +OpenMP-реализация должна давать **идентичный** SEQ результат при любом количестве потоков. + +## 3. Базовый алгоритм +Последовательная версия (SEQ): + +1. Проверить корректность входных данных. +2. Инициализировать структуру результата. +3. Для каждого столбца матрицы B: +- пройти по ненулевым элементам; +- выполнить умножение элементов; +- накопить значения в accumulator. +4. Отсортировать индексы строк. +5. Сохранить ненулевые значения в матрицу результата. + +## 4. Схема распараллеливания +Параллелизация выполняется по столбцам результирующей матрицы. + +Используется директива: +#pragma omp parallel for default(none) shared(a, b, local_values, local_rows) + +Каждый поток обрабатывает собственный столбец. + +Shared-переменные: +- a; +- b; +- local_values; +- local_rows. + +Private-переменные: +- j; +- локальные accumulator; +- marker; +- used_rows. + +Синхронизация: +- явные critical sections отсутствуют; +- используется неявный барьер после parallel for. + +## 5. Детали реализации +- `omp/include/ops_omp.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsOMP`. +- `omp/src/ops_omp.cpp` — реализация методов. + +### Особенности +Для каждого столбца используются локальные буферы: +std::vector> local_values(c.cols); +std::vector> local_rows(c.cols); +Это устраняет гонки данных. + +### Схема памяти +- a, b — shared; +- local_values[j] — private для столбца; +- временные аккумуляторы — private. + +## 6. Проверка корректности +OpenMP-реализация проходит все функциональные тесты, +используемые для последовательной версии. + +Результаты OMP сравнивались с SEQ. +Проверялись: +- совпадение структуры CCS; +- совпадение комплексных значений; +- стабильность результатов при различном числе потоков. + +Результаты совпадают с SEQ +с точностью 1e-9. + +## 7. Экспериментальная среда + +CPU: Intel(R) Core(TM) i5-9300H CPU @ 2.40GHz +OS: Windows 10 +Compiler: MinGW-w64 GCC, C++17 +Backend: OpenMP +PPC_NUM_THREADS: 4 +OMP_NUM_THREADS: 4 +Build type: Release +CMake: 4.0.1 +RAM: 32 GB + +### Сборка +cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release +cmake --build build --config Release --parallel + +### Запуск тестов +cd build/bin +mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" + +## 8. Результаты +| Режим | Workers (p) | Time (сек) | Speedup | Efficiency | +| :---- | :---------: | :--------: | :-----: | :--------: | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| OMP | 2 | 0.000502 | 0.33 | 0.17 | +| OMP | 4 | 0.001694 | 0.10 | 0.02 | +| OMP | 8 | 0.001913 | 0.09 | 0.01 | + + +## 9. Выводы +OpenMP позволяет быстро распараллелить вычисления за счёт директив компилятора и минимального +объёма изменений в последовательном коде. В данной реализации параллельная обработка выполняется +по столбцам результирующей матрицы, что обеспечивает независимость вычислений между потоками. +Преимуществами OpenMP являются простота интеграции, хорошая масштабируемость на многоядерных +процессорах и низкие накладные расходы при работе с вычислительно интенсивными задачами. +Реализация показала ускорение по сравнению с последовательной версией при сохранении корректности +результатов. +Недостатком подхода является ограничение одной вычислительной машиной с общей памятью. Кроме +того, при небольших размерах матриц эффект от распараллеливания может быть незначительным из-за +накладных расходов на создание и синхронизацию потоков. +Таким образом, технология OpenMP является эффективным средством ускорения операции умножения +разреженных комплексных матриц в формате CCS на системах с общей памятью. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md new file mode 100644 index 0000000000..cbc75099ef --- /dev/null +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md @@ -0,0 +1,220 @@ +# Технология All. Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS) + +- Student: Горячева Ксения Александровна, group: 3823Б1ФИ2 +- Variant: 7 +- Local reports: [seq/report.md](seq/report.md) · [omp/report.md](omp/report.md) · [tbb/report.md](tbb/report.md) · [stl/report.md](stl/report.md) · [all/report.md](all/report.md) + +## 1. Введение +Разреженные матрицы широко применяются в задачах вычислительной математики, +численного моделирования, обработки графов, +решении систем линейных уравнений, +машинном обучении и инженерных расчётах. + +Во многих практических задачах большая часть элементов матрицы равна нулю. +Использование плотного хранения в таких случаях приводит +к значительным затратам памяти и снижению производительности вычислений. + +Для эффективного хранения разреженных матриц используются специализированные форматы, +одним из которых является CCS (Compressed Column Storage). + +Формат CCS позволяет хранить только ненулевые элементы матрицы, +что существенно уменьшает объём памяти +и ускоряет выполнение операций линейной алгебры. + +Цель данной работы — +реализация алгоритма умножения разреженных комплексных матриц, +представленных в формате CCS, +а также исследование эффективности различных технологий параллельного программирования. + +В работе реализованы следующие версии алгоритма: + +последовательная (SEQ); + +OpenMP; + +oneTBB; + +STL threads; + +гибридная MPI + OpenMP. + +## 2. Единая постановка задачи +### Входные данные +Две разреженные комплексные матрицы: +- A — комплексная матрица размера m × n +- B — комплексная матрица размера n × k +представленные в формате CCS: + +struct SparseMatrixCCS { + int rows; + int cols; + + std::vector values; + std::vector row_ind; + std::vector col_ptr; +}; + +где: +values — ненулевые элементы; +row_ind — индексы строк элементов; +col_ptr — указатели начала столбцов. + +### Выходные данные +Матрица: +C = A * B +в формате CCS. + +### Ограничения +- число столбцов матрицы A должно совпадать с числом строк матрицы B; +- массивы col_ptr не должны быть пустыми. + +### Крайние случаи + +| Случай | Ожидаемое поведение | +| ---------------------------------------- | -------------------------------------- | +| Несовместимые размеры |ValidationImpl() возвращает false | +| Пустые col_ptr |ValidationImpl() возвращает false | +| Полностью нулевая результирующая матрица | values и row_ind пустые | +| Матрица 1×1 | Корректное умножение комплексных чисел | + +## 3. Единая методика эксперимента +CPU: Intel(R) Core(TM) i5-9300H CPU @ 2.40GHz +OS: Windows 10 +Compiler: MinGW-w64 GCC, C++17 +Build type: Release +CMake: 4.0.1 +RAM: 32 GB + +Использовались переменные окружения: +export PPC_NUM_THREADS=4 +export PPC_NUM_PROC=2 + +Использовались случайно сгенерированные разреженные матрицы. +Параметры: +Размер матрицы: 200 × 200 +Ненулевых элементов на столбец: 5 +Тип данных: complex + +Метрики +- **Speedup** = `T_seq / T_par`. +- **Efficiency** = `Speedup / total_workers` (total_workers = число потоков × число процессов для MPI). +- База для `T_seq` — замер SEQ-версии. + +## 4. Сводка корректности +Корректность проверялась при помощи общего набора функциональных тестов. +Тесты покрывают: +- минимальные размеры матриц; +- квадратные матрицы; +- прямоугольные матрицы; +- пустые столбцы; +- полностью нулевой результат; +- работу с комплексными числами; +- совпадение CCS-структур. +Сравнение результатов выполняется функцией: +CompareMatrices() +Проверяются: +- размеры матриц; +- col_ptr; +- row_ind; +- значения с точностью eps = 1e-9. +Всего реализовано 14 сценариев. +Каждый сценарий запускается для: +- SEQ; +- OMP; +- TBB; +- STL; +- ALL. +Общее количество тестов: +70 tests +Все тесты были успешно пройдены. + +## 5. Агрегированные результаты +| Ranks | Threads per rank | Workers (p) | Time (сек) | Speedup | Efficiency | +| ------- | ---------------- | ----------- | ---------- | -------- | ---------- | +| 1 (SEQ) | 1 | 1 | 0.000166 | 1.0000 | 1.0000 | +| 1 | 2 | 2 | 0.000502 | 0.3302 | 0.1651 | +| 1 | 4 | 4 | 0.001694 | 0.0978 | 0.0245 | +| 1 | 8 | 8 | 0.001913 | 0.0866 | 0.0108 | +| 1 | 16 | 16 | 0.008535 | 0.0194 | 0.0012 | +| 2 | 1 | 2 | 0.001216 | 0.1363 | 0.0682 | +| 2 | 2 | 4 | 0.001273 | 0.1302 | 0.0326 | +| 2 | 4 | 8 | 0.001195 | 0.1388 | 0.0174 | +| 2 | 8 | 16 | 0.001162 | 0.1427 | 0.0089 | +| 4 | 1 | 4 | 0.001527 | 0.1086 | 0.0272 | +| 4 | 2 | 8 | 0.002967 | 0.0559 | 0.0070 | +| 4 | 4 | 16 | 0.004881 | 0.0340 | 0.0021 | +| 8 | 1 | 8 | 0.000399 | 0.4151 | 0.0519 | +| 8 | 2 | 16 | 0.005986 | 0.0277 | 0.0017 | + +## 6. Интерпретация различий +SEQ +Последовательная версия используется как baseline. +Преимущества: +- простота; +- предсказуемость; +- отсутствие накладных расходов на синхронизацию. +Недостатки: +- отсутствие масштабируемости. + +OMP +OpenMP версия показала хорошую производительность при относительно простой реализации. +Преимущества: +- минимальные изменения кода; +- удобная модель shared memory; +- хорошая масштабируемость. +Недостатки: +- overhead создания parallel region; +- чувствительность к распределению нагрузки. + +TBB +TBB обеспечивает автоматическое управление потоками. +Преимущества: +- балансировка нагрузки; +- work-stealing; +- удобный runtime. +Недостатки: +- дополнительные накладные расходы runtime. + +STL +Реализация на std::thread требует ручного управления потоками. +Преимущества: +- полный контроль; +- стандартные средства языка. +Недостатки: +- необходимость ручного разбиения задач; +- более сложная синхронизация; +- накладные расходы на создание потоков. + +ALL +Гибридная реализация сочетает MPI и OpenMP. +Преимущества: +- возможность работы на распределённых системах; +- использование межпроцессного и внутрипроцессного параллелизма. +Недостатки: +- стоимость MPI-коммуникаций; +- сложность синхронизации. + +## 7. Репродуцируемость +### Сборка +cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release +cmake --build build --config Release --parallel + +### Запуск тестов +cd build/bin +mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" + + +## 8. Заключение +В ходе работы был реализован и исследован алгоритм умножения разреженных комплексных матриц в +формате CCS. +Были разработаны пять реализаций: +- последовательная; +- OpenMP; +- TBB; +- STL Threads; +- гибридная MPI + OpenMP. +Все реализации успешно прошли функциональные тесты. +Параллельные версии продемонстрировали корректную работу и возможность использования +многопоточных вычислений. +На данной задаче наибольший практический интерес представляют OpenMP и гибридная реализация. diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md new file mode 100644 index 0000000000..f359545ee0 --- /dev/null +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md @@ -0,0 +1,174 @@ +# Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS) - SEQ + +- Student: Горячева Ксения Александровна +- Technology: SEQ +- Variant: 7 + +## 1. Контекст +Разреженные матрицы широко используются в научных вычислениях, +численных методах, моделировании физических процессов, +графовых алгоритмах и задачах линейной алгебры. + +При хранении матриц с большим количеством нулевых элементов +использование плотного формата приводит к избыточному расходу памяти +и увеличению времени вычислений. + +Для уменьшения затрат памяти используется формат CCS +(Compressed Column Storage), +в котором сохраняются только ненулевые элементы матрицы. + +В данной работе реализовано последовательное умножение +разреженных комплексных матриц, +представленных в формате CCS. + +Последовательная версия используется как эталон корректности +и база для сравнения производительности параллельных реализаций. + +## 2. Постановка задачи + +### Входные данные +Две разреженные комплексные матрицы: +- A — комплексная матрица размера m × n +- B — комплексная матрица размера n × k +представленные в формате CCS: + +struct SparseMatrixCCS { + int rows; + int cols; + + std::vector values; + std::vector row_ind; + std::vector col_ptr; +}; + +где: +values — ненулевые элементы; +row_ind — индексы строк элементов; +col_ptr — указатели начала столбцов. + +### Выходные данные +Матрица: +C = A * B +в формате CCS. + +### Ограничения +- число столбцов матрицы A должно совпадать с числом строк матрицы B; +- массивы col_ptr не должны быть пустыми. + +### Крайние случаи + +| Случай | Ожидаемое поведение | +| ---------------------------------------- | -------------------------------------- | +| Несовместимые размеры |ValidationImpl() возвращает false | +| Пустые col_ptr |ValidationImpl() возвращает false | +| Полностью нулевая результирующая матрица | values и row_ind пустые | +| Матрица 1×1 | Корректное умножение комплексных чисел | + +## 3. Базовый алгоритм + +### Идея алгоритма +Умножение выполняется по столбцам матрицы B. +Для каждого столбца: +1. Выбираются ненулевые элементы текущего столбца B; +2. Для каждого элемента находится соответствующий столбец матрицы A; +3. Производится накопление результата через временный аккумулятор; +4. Ненулевые значения сохраняются в CCS-структуру результата. + +### Пошаговое описание +1. Проверить корректность входных данных. +2. Инициализировать структуру результата. +3. Для каждого столбца матрицы B: +- пройти по ненулевым элементам; +- выполнить умножение элементов; +- накопить значения в accumulator. +4. Отсортировать индексы строк. +5. Сохранить ненулевые значения в матрицу результата. + +### Асимптотика +Пусть: +- nnz(A) — число ненулевых элементов A; +- nnz(B) — число ненулевых элементов B. + +Тогда: +- Время: +O(nnz(A) * nnz(B)) +- Память: +O(rows) +для временного аккумулятора. + +### Инварианты корректности +- структура CCS сохраняется; +- индексы строк внутри столбца отсортированы; +- нулевые элементы не сохраняются; +- размеры результирующей матрицы корректны. + +## 4. Детали реализации +- `seq/include/ops_seq.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsSEQ`. +- `seq/src/ops_seq.cpp` — реализация методов. + +| Метод | Назначение | +| ---------------------- | -------------------------------------------------------- | +| `ValidationImpl()` | Проверяет совместимость размеров и корректность структуры| +| `PreProcessingImpl()` | Инициализирует выходную матрицу | +| `RunImpl()` | Выполняет последовательное умножение | +| `PostProcessingImpl()` | Завершает обработку | + +#### Особенности реализации +Для накопления значений используются: +std::vector accumulator(a.rows); +std::vector marker(a.rows, -1); +marker позволяет избежать повторной инициализации элементов аккумулятора. + +## 5. Проверка корректности +### Способ проверки +Результат сравнивается с эталонной матрицей: +- размеры; +- col_ptr; +- row_ind; +- значения комплексных чисел с точностью 1e-9. + +### Функциональные тесты +Используется 14 тестов. + +Примеры тестов +| Тест | Описание | +| ---------------------- | ----------------------------------- | +| 1×1 | Проверка умножения комплексных чисел| +| Нулевая матрица | Проверка отсутствия ложных элементов| +| Несовместимые размеры | Проверка ValidationImpl() | +| Разреженные матрицы 4×4| Проверка корректности CCS | + +## 6. Экспериментальная среда + +CPU: Intel(R) Core(TM) i5-9300H CPU @ 2.40GHz +OS: Windows 10 +Compiler: MinGW-w64 GCC, C++17 +Build type: Release +CMake: 4.0.1 +RAM: 32 GB + +### Сборка +cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release +cmake --build build --config Release --parallel + +### Запуск тестов +cd build/bin +mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" + +## 7. Результаты +Примеры тестов +| Режи | Время | +| ---------------------- | ------- | +| pipeline | 0.000164| +| task_run | 0.000166| + +Наиболее затратным участком является двойной проход по ненулевым элементам столбцов. + +## 8. Выводы +Реализован корректный алгоритм умножения разреженных комплексных матриц в формате CCS. + +Последовательная версия: +- обеспечивает корректность вычислений; +- поддерживает разреженное хранение; +- служит базой для сравнения параллельных технологий. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md new file mode 100644 index 0000000000..cbfd954e75 --- /dev/null +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md @@ -0,0 +1,135 @@ +# Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS) - STL + +- Student: Горячева Ксения Александровна +- Technology: STL +- Variant: 7 + +## 1. Контекст +Стандартная библиотека C++ предоставляет механизм +многопоточности через `std::thread`. + +В данной реализации +распараллеливание выполняется вручную. + +## 2. Постановка задачи + +Полная постановка задачи приведена в отчёте для SEQ-версии [seq/report.md](../seq/report.md). +Кратко: + +Входные данные: +Две разреженные комплексные матрицы: +- A — комплексная матрица размера m × n +- B — комплексная матрица размера n × k +представленные в формате CCS: + +Выходные данные: +Матрица: +C = A * B +в формате CCS. + +OpenMP-реализация должна давать **идентичный** SEQ результат при любом количестве потоков. + +## 3. Базовый алгоритм +Последовательная версия (SEQ): + +1. Проверить корректность входных данных. +2. Инициализировать структуру результата. +3. Для каждого столбца матрицы B: +- пройти по ненулевым элементам; +- выполнить умножение элементов; +- накопить значения в accumulator. +4. Отсортировать индексы строк. +5. Сохранить ненулевые значения в матрицу результата. + +## 4. Схема распараллеливания +В STL-версии распараллеливание выполнено с использованием std::thread. Все столбцы результирующей +матрицы делятся между потоками. +Каждый поток: +1. Получает диапазон столбцов; +2. Выполняет вычисление соответствующих столбцов результата; +3. Сохраняет локальные значения в отдельные контейнеры. +После завершения работы потоков основной поток объединяет локальные результаты в итоговую CCS- +структуру. + +## 5. Детали реализации +- `stl/include/ops_stl.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsSTL`. +- `stl/src/ops_stl.cpp` — реализация методов. + +ValidationImpl +Проверяется: +- совместимость размеров матриц; +- корректность массивов col_ptr. +PreProcessingImpl +Выполняется очистка выходной структуры. +RunImpl +Основной вычислительный этап: +- определяется число потоков; +- столбцы распределяются между потоками; +- каждый поток вызывает ProcessColumn; + +### Распределение нагрузки +Используется блочное разбиение: + +cols_per_thread = + (b.cols + num_threads - 1) / num_threads; + +### Синхронизация +Во время вычислений синхронизация не требуется, +так как потоки работают с независимыми столбцами. + +После завершения выполняется: + +th.join(); + +## 6. Проверка корректности +STL-реализация успешно проходит все функциональные тесты. +Для проверки корректности использованы функциональные тесты: +- умножение матриц размером 1×1; +- матрицы с различной плотностью; +- прямоугольные матрицы; +- матрицы с нулевыми столбцами; +- комплексные значения; +- полностью разреженные случаи. +Сравнение результатов выполняется с использованием допуска 1e-9. + +## 7. Экспериментальная среда + +CPU: Intel(R) Core(TM) i5-9300H CPU @ 2.40GHz +OS: Windows 10 +Compiler: MinGW-w64 GCC, C++17 +Build type: Release +CMake: 4.0.1 +RAM: 32 GB + +### Сборка +cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release +cmake --build build --config Release --parallel + +### Запуск тестов +cd build/bin +mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" + +## 8. Результаты +| Режим | Workers (p) | Time (сек) | Speedup | Efficiency | +| :---- | :---------: | :--------: | :-----: | :--------: | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| STL | 2 | 0.001527 | 0.11 | 0.05 | +| STL | 4 | 0.002967 | 0.06 | 0.01 | +| STL | 8 | 0.004881 | 0.03 | 0.00 | +| STL | 16 | 0.008424 | 0.02 | 0.00 | + + +## 9. Выводы +Использование STL-потоков позволяет реализовать переносимое распараллеливание без привязки к +конкретной библиотеке параллельного программирования. +Преимуществами реализации являются: +- гибкость; +- контроль над потоками; +- независимость от OpenMP и TBB. +Недостатками являются: +- необходимость ручного управления потоками; +- более сложная синхронизация; +- большие накладные расходы по сравнению с OpenMP. +Реализация показала корректную работу и обеспечила ускорение вычислений при обработке больших +матриц. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md new file mode 100644 index 0000000000..f36643fc8d --- /dev/null +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md @@ -0,0 +1,128 @@ +# Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS) - TBB + +- Student: Горячева Ксения Александровна +- Technology: TBB +- Variant: 7 + +## 1. Контекст +oneTBB предоставляет высокоуровневую модель +параллельного программирования, +основанную на задачах. + +Для задачи умножения CCS-матриц +используется `parallel_for`, +который автоматически распределяет нагрузку между потоками. + +## 2. Постановка задачи + +Полная постановка задачи приведена в отчёте для SEQ-версии [seq/report.md](../seq/report.md). +Кратко: + +Входные данные: +Две разреженные комплексные матрицы: +- A — комплексная матрица размера m × n +- B — комплексная матрица размера n × k +представленные в формате CCS: + +Выходные данные: +Матрица: +C = A * B +в формате CCS. + +OpenMP-реализация должна давать **идентичный** SEQ результат при любом количестве потоков. + +## 3. Базовый алгоритм +Последовательная версия (SEQ): + +1. Проверить корректность входных данных. +2. Инициализировать структуру результата. +3. Для каждого столбца матрицы B: +- пройти по ненулевым элементам; +- выполнить умножение элементов; +- накопить значения в accumulator. +4. Отсортировать индексы строк. +5. Сохранить ненулевые значения в матрицу результата. + +## 4. Схема распараллеливания +Используется: + +```cpp +oneapi::tbb::parallel_for(...) +Каждый столбец результирующей матрицы вычисляется независимо. +Для хранения промежуточных результатов используются локальные контейнеры: +- local_values; +- local_rows. +После завершения параллельного участка выполняется последовательная сборка итоговой CCS-матрицы. + +## 5. Детали реализации +- `tbb/include/ops_tbb.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsTBB`. +- `tbb/src/ops_tbb.cpp` — реализация методов. + +ValidationImpl +Проверяется совместимость размеров и корректность структуры CCS. +RunImpl +Вычисления выполняются через: +oneapi::tbb::parallel_for(0, b.cols, [&](int j) { +ProcessColumn(j, a, b, local_values[j], local_rows[j]); +}); +Каждая итерация отвечает за отдельный столбец результата. + +Преимущества TBB +- автоматическая балансировка нагрузки; +- work-stealing scheduler; +- отсутствие ручного управления потоками. + +Локальные структуры +Для каждого столбца выделяются: +- local_values[j] +- local_rows[j] +что исключает гонки данных. + +## 6. Проверка корректности +Использованы те же функциональные тесты, что и для остальных реализаций. +Все тесты успешно пройдены. + +## 7. Экспериментальная среда + +CPU: Intel(R) Core(TM) i5-9300H CPU @ 2.40GHz +OS: Windows 10 +Compiler: MinGW-w64 GCC, C++17 +Build type: Release +CMake: 4.0.1 +RAM: 32 GB + +### Сборка +cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release +cmake --build build --config Release --parallel + +### Запуск тестов +cd build/bin +mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" + +## 8. Результаты +| Режим | Workers (p) | Time (сек) | Speedup | Efficiency | +| :---- | :---------: | :--------: | :-----: | :--------: | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| TBB | 2 | 0.001216 | 0.14 | 0.07 | +| TBB | 4 | 0.001273 | 0.13 | 0.03 | +| TBB | 8 | 0.001195 | 0.14 | 0.02 | +| TBB | 16 | 0.001162 | 0.14 | 0.01 | + +TBB обеспечивает хорошую балансировку +при неравномерном распределении ненулевых элементов. + +Однако runtime TBB создаёт дополнительные накладные расходы +на управление задачами. + + +## 9. Выводы +TBB предоставляет удобный и современный механизм распараллеливания вычислений. +Преимущества: +- автоматическое управление потоками; +- балансировка нагрузки; +- хорошая масштабируемость. +Недостатки: +- дополнительная зависимость от библиотеки; +- более сложная настройка среды. +Реализация продемонстрировала высокую производительность и удобство разработки. From 7aa3ea47906442c848b4c84bac79605f88cf2901 Mon Sep 17 00:00:00 2001 From: GoriachevaKsenia Date: Sun, 24 May 2026 21:34:16 +0300 Subject: [PATCH 2/5] Fix report --- .../all/report.md | 95 ++++++++++++++----- .../omp/report.md | 64 +++++++++++-- .../report.md | 60 ++++++------ .../seq/report.md | 65 ++++++++----- .../stl/report.md | 61 +++++++++--- .../tbb/report.md | 69 +++++++++++--- 6 files changed, 299 insertions(+), 115 deletions(-) diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md index 9b8b1d2735..1ca9df09bb 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md @@ -46,26 +46,45 @@ OpenMP-реализация должна давать **идентичный** S 5. Сохранить ненулевые значения в матрицу результата. ## 4. Схема распараллеливания +В гибридной версии используется двухуровневое распараллеливание: +- MPI — распределение столбцов между процессами; +- OpenMP — параллельная обработка столбцов внутри процесса. + Алгоритм включает: 1. Разделение столбцов между MPI-процессами; 2. Параллельную обработку столбцов внутри процесса; 3. Сбор результатов через MPI_Gatherv; 4. Формирование глобальной CCS-матрицы. -### MPI - +MPI Столбцы матрицы B распределяются между процессами: - -```cpp int cols_per_proc = (b.cols + size - 1) / size; Каждый процесс обрабатывает собственный диапазон столбцов. + OpenMP Внутри процесса используется: - #pragma omp parallel for для обработки локальных столбцов. +Сборка результата +После вычислений: +локальные данные собираются через MPI_Gatherv; +формируется глобальный массив col_ptr; +результат рассылается всем процессам через MPI_Bcast. + +Схема: + MPI + ┌──────────┼──────────┐ + Proc0 Proc1 Proc2 + │ │ │ + OpenMP OpenMP OpenMP + threads threads threads + │ │ │ + local CCS local CCS local CCS + └──────────┼──────────┘ + MPI_Gatherv + ## 5. Детали реализации - `all/include/ops_all.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsSALL`. - `all/src/ops_all.cpp` — реализация методов. @@ -81,22 +100,49 @@ RunImpl Коммуникации MPI Используются: - MPI_Gather - MPI_Gatherv - MPI_Bcast - для сборки результирующей CCS-матрицы. ## 6. Проверка корректности -Проверялась: -- корректность вычислений; -- согласованность результатов между процессами; -- корректность сборки col_ptr. -Гибридная версия проходит все функциональные тесты -и совпадает с SEQ-версией. +Гибридная версия проходит все функциональные тесты, +используемые для последовательной версии. + +### Способ проверки +Корректность реализации проверялась с помощью функциональных тестов Google Test. + +Проверялись: +размеры результирующей матрицы; +массив col_ptr; +массив row_ind; +значения комплексных элементов с точностью 1e-9. + +Сравнение результатов реализовано функцией: +CompareMatrices(...) + +### Функциональные тесты +Используется 14 тестов. +| № теста | Описание | Проверяемый случай | +| ------- | -------------------------------- | ----------------------------------- | +| 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | +| 1 | Диагональные 2×2 | Корректность умножения | +| 2 | Нулевой результат | Отсутствие ненулевых элементов | +| 3 | Мнимые числа | Работа с чисто мнимыми значениями | +| 4 | Комплексные коэффициенты | Корректность комплексной арифметики | +| 5 | Прямоугольные матрицы | Умножение матриц разных размеров | +| 6 | Разреженные 4×4 | Работа CCS-структуры | +| 7 | Один ненулевой столбец | Частично заполненная матрица | +| 8 | Крайние индексы | Проверка граничных строк | +| 9 | Несколько потоковых блоков | Корректность распределения | +| 10 | Полностью заполненная диагональ | Проверка накопления | +| 11 | Центральный элемент | Корректность индексации | +| 12 | Разреженные комплексные значения | Проверка знаков и мнимой части | +| 13 | Несортированные элементы столбца | Проверка сортировки строк | + +Все функциональные тесты успешно пройдены +Результаты совпадают с SEQ +с точностью 1e-9. ## 7. Экспериментальная среда @@ -119,14 +165,17 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri ## 8. Результаты | Режим | Workers (p) | Time (сек) | Speedup | Efficiency | | :---- | :---------: | :--------: | :-----: | :--------: | -| SEQ | 1 | 0.000166 | 1.00 | 1.00 | -| ALL | 2 | 0.000399 | 0.42 | 0.21 | -| ALL | 4 | 0.005986 | 0.03 | 0.01 | -| ALL | 8 | 0.026888 | 0.01 | 0.00 | -| ALL | 16 | 0.103833 | 0.00 | 0.00 | - +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| ALL | 2 | 0.000399 | 0.42 | 0.21 | +| ALL | 4 | 0.005986 | 0.03 | 0.01 | +| ALL | 8 | 0.026888 | 0.01 | 0.00 | +| ALL | 16 | 0.103833 | 0.00 | 0.00 | +- Speedup = `T_seq / T_par` +- Efficiency = `Speedup / threads` +- База для `T_seq` — замер SEQ-версии ## 9. Выводы +В ходе работы была реализована гибридная версия алгоритма с использованием MPI и OpenMP. Гибридная модель MPI + OpenMP позволяет эффективно выполнять умножение разреженных матриц на многопроцессорных системах. Преимущества: @@ -137,6 +186,4 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri - сложность реализации; - необходимость синхронизации процессов; - накладные расходы на передачу данных. -Данная реализация является наиболее производительной среди всех разработанных версий при больших -объёмах вычислений.ть вычисления с минимальными изменениями исходного кода. -На задачах большего размера эффективность OpenMP будет выше. \ No newline at end of file +Несмотря на увеличение накладных расходов, связанных с MPI-коммуникациями и синхронизацией процессов, гибридная реализация обеспечивает возможность масштабирования вычислений на распределённые системы. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md index 9151d8c31e..7564ae3905 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md @@ -50,7 +50,15 @@ OpenMP-реализация должна давать **идентичный** S Используется директива: #pragma omp parallel for default(none) shared(a, b, local_values, local_rows) -Каждый поток обрабатывает собственный столбец. +Каждый поток независимо обрабатывает собственный столбец: +ProcessColumn(j, a, b, local_values[j], local_rows[j]); + +Для исключения гонок данных: + +каждый поток записывает результат только в собственные контейнеры: +- local_values[j] +- local_rows[j] +- объединение результатов выполняется после завершения параллельной области. Shared-переменные: - a; @@ -68,6 +76,16 @@ Private-переменные: - явные critical sections отсутствуют; - используется неявный барьер после parallel for. +Схема распараллеливания: + Matrix B columns + ┌─────┬─────┬─────┬─────┐ + │ j0 │ j1 │ j2 │ ... │ + └─────┴─────┴─────┴─────┘ + ↓ ↓ ↓ + Thread0 Thread1 Thread2 + ↓ ↓ ↓ + local_values/local_rows + ## 5. Детали реализации - `omp/include/ops_omp.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsOMP`. - `omp/src/ops_omp.cpp` — реализация методов. @@ -87,12 +105,38 @@ std::vector> local_rows(c.cols); OpenMP-реализация проходит все функциональные тесты, используемые для последовательной версии. -Результаты OMP сравнивались с SEQ. -Проверялись: -- совпадение структуры CCS; -- совпадение комплексных значений; -- стабильность результатов при различном числе потоков. +### Способ проверки +Корректность реализации проверялась с помощью функциональных тестов Google Test. +Проверялись: +размеры результирующей матрицы; +массив col_ptr; +массив row_ind; +значения комплексных элементов с точностью 1e-9. + +Сравнение результатов реализовано функцией: +CompareMatrices(...) + +### Функциональные тесты +Используется 14 тестов. +| № теста | Описание | Проверяемый случай | +| ------- | -------------------------------- | ----------------------------------- | +| 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | +| 1 | Диагональные 2×2 | Корректность умножения | +| 2 | Нулевой результат | Отсутствие ненулевых элементов | +| 3 | Мнимые числа | Работа с чисто мнимыми значениями | +| 4 | Комплексные коэффициенты | Корректность комплексной арифметики | +| 5 | Прямоугольные матрицы | Умножение матриц разных размеров | +| 6 | Разреженные 4×4 | Работа CCS-структуры | +| 7 | Один ненулевой столбец | Частично заполненная матрица | +| 8 | Крайние индексы | Проверка граничных строк | +| 9 | Несколько потоковых блоков | Корректность распределения | +| 10 | Полностью заполненная диагональ | Проверка накопления | +| 11 | Центральный элемент | Корректность индексации | +| 12 | Разреженные комплексные значения | Проверка знаков и мнимой части | +| 13 | Несортированные элементы столбца | Проверка сортировки строк | + +Все функциональные тесты успешно пройдены Результаты совпадают с SEQ с точностью 1e-9. @@ -125,17 +169,17 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri | OMP | 4 | 0.001694 | 0.10 | 0.02 | | OMP | 8 | 0.001913 | 0.09 | 0.01 | +- Speedup = `T_seq / T_par` +- Efficiency = `Speedup / threads` +- База для `T_seq` — замер SEQ-версии ## 9. Выводы +В ходе работы была разработана параллельная версия алгоритма с использованием OpenMP. OpenMP позволяет быстро распараллелить вычисления за счёт директив компилятора и минимального объёма изменений в последовательном коде. В данной реализации параллельная обработка выполняется по столбцам результирующей матрицы, что обеспечивает независимость вычислений между потоками. Преимуществами OpenMP являются простота интеграции, хорошая масштабируемость на многоядерных процессорах и низкие накладные расходы при работе с вычислительно интенсивными задачами. -Реализация показала ускорение по сравнению с последовательной версией при сохранении корректности -результатов. Недостатком подхода является ограничение одной вычислительной машиной с общей памятью. Кроме того, при небольших размерах матриц эффект от распараллеливания может быть незначительным из-за накладных расходов на создание и синхронизацию потоков. -Таким образом, технология OpenMP является эффективным средством ускорения операции умножения -разреженных комплексных матриц в формате CCS на системах с общей памятью. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md index cbc75099ef..3a29f983f5 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md @@ -27,16 +27,11 @@ а также исследование эффективности различных технологий параллельного программирования. В работе реализованы следующие версии алгоритма: - -последовательная (SEQ); - -OpenMP; - -oneTBB; - -STL threads; - -гибридная MPI + OpenMP. +- последовательная (SEQ); +- OpenMP; +- oneTBB; +- STL threads; +- гибридная MPI + OpenMP. ## 2. Единая постановка задачи ### Входные данные @@ -96,9 +91,9 @@ export PPC_NUM_PROC=2 Тип данных: complex Метрики -- **Speedup** = `T_seq / T_par`. -- **Efficiency** = `Speedup / total_workers` (total_workers = число потоков × число процессов для MPI). -- База для `T_seq` — замер SEQ-версии. +- Speedup = `T_seq / T_par` +- Efficiency = `Speedup / total_workers` (total_workers = число потоков × число процессов для MPI) +- База для `T_seq` — замер SEQ-версии ## 4. Сводка корректности Корректность проверялась при помощи общего набора функциональных тестов. @@ -129,22 +124,25 @@ CompareMatrices() Все тесты были успешно пройдены. ## 5. Агрегированные результаты -| Ranks | Threads per rank | Workers (p) | Time (сек) | Speedup | Efficiency | -| ------- | ---------------- | ----------- | ---------- | -------- | ---------- | -| 1 (SEQ) | 1 | 1 | 0.000166 | 1.0000 | 1.0000 | -| 1 | 2 | 2 | 0.000502 | 0.3302 | 0.1651 | -| 1 | 4 | 4 | 0.001694 | 0.0978 | 0.0245 | -| 1 | 8 | 8 | 0.001913 | 0.0866 | 0.0108 | -| 1 | 16 | 16 | 0.008535 | 0.0194 | 0.0012 | -| 2 | 1 | 2 | 0.001216 | 0.1363 | 0.0682 | -| 2 | 2 | 4 | 0.001273 | 0.1302 | 0.0326 | -| 2 | 4 | 8 | 0.001195 | 0.1388 | 0.0174 | -| 2 | 8 | 16 | 0.001162 | 0.1427 | 0.0089 | -| 4 | 1 | 4 | 0.001527 | 0.1086 | 0.0272 | -| 4 | 2 | 8 | 0.002967 | 0.0559 | 0.0070 | -| 4 | 4 | 16 | 0.004881 | 0.0340 | 0.0021 | -| 8 | 1 | 8 | 0.000399 | 0.4151 | 0.0519 | -| 8 | 2 | 16 | 0.005986 | 0.0277 | 0.0017 | +| Технология | Конфигурация | Workers | Time (с) | Speedup | Efficiency | +| ---------- | ------------ | ------- | -------- | -------- | ---------- | +| SEQ | 1 процесс | 1 | 0.000166 | 1.00 | 1.00 | +| OpenMP | 2 потока | 2 | 0.000502 | 0.33 | 0.17 | +| | 4 потока | 4 | 0.001694 | 0.10 | 0.02 | +| | 8 потоков | 8 | 0.001913 | 0.09 | 0.01 | +| | 16 потоков | 16 | 0.008535 | 0.02 | 0.00 | +| STL | 2 потока | 2 | 0.001527 | 0.11 | 0.05 | +| | 4 потока | 4 | 0.002967 | 0.06 | 0.01 | +| | 8 потоков | 8 | 0.004881 | 0.03 | 0.00 | +| | 16 потоков | 16 | 0.008424 | 0.02 | 0.00 | +| TBB | 2 потока | 2 | 0.001216 | 0.14 | 0.07 | +| | 4 потока | 4 | 0.001273 | 0.13 | 0.03 | +| | 8 потоков | 8 | 0.001195 | 0.14 | 0.02 | +| | 16 потоков | 16 | 0.001162 | 0.14 | 0.01 | +| ALL | 1x2 | 2 | 0.000399 | 0.42 | 0.21 | +| (MPI+OMP) | 1x4 | 4 | 0.005986 | 0.03 | 0.01 | +| | 1x8 | 8 | 0.026888 | 0.01 | 0.00 | +| | 1x16 | 16 | 0.103833 | 0.00 | 0.00 | ## 6. Интерпретация различий SEQ @@ -218,3 +216,7 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri Параллельные версии продемонстрировали корректную работу и возможность использования многопоточных вычислений. На данной задаче наибольший практический интерес представляют OpenMP и гибридная реализация. + +## 9. Источники + + [Документация курса «Параллельное программирование»](https://learning-process.github.io/parallel_programming_course/ru/) diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md index f359545ee0..ade47b67ef 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md @@ -121,22 +121,37 @@ marker позволяет избежать повторной инициализ ## 5. Проверка корректности ### Способ проверки -Результат сравнивается с эталонной матрицей: -- размеры; -- col_ptr; -- row_ind; -- значения комплексных чисел с точностью 1e-9. +Корректность реализации проверялась с помощью функциональных тестов Google Test. + +Проверялись: +размеры результирующей матрицы; +массив col_ptr; +массив row_ind; +значения комплексных элементов с точностью 1e-9. + +Сравнение результатов реализовано функцией: +CompareMatrices(...) ### Функциональные тесты Используется 14 тестов. - -Примеры тестов -| Тест | Описание | -| ---------------------- | ----------------------------------- | -| 1×1 | Проверка умножения комплексных чисел| -| Нулевая матрица | Проверка отсутствия ложных элементов| -| Несовместимые размеры | Проверка ValidationImpl() | -| Разреженные матрицы 4×4| Проверка корректности CCS | +| № теста | Описание | Проверяемый случай | +| ------- | -------------------------------- | ----------------------------------- | +| 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | +| 1 | Диагональные 2×2 | Корректность умножения | +| 2 | Нулевой результат | Отсутствие ненулевых элементов | +| 3 | Мнимые числа | Работа с чисто мнимыми значениями | +| 4 | Комплексные коэффициенты | Корректность комплексной арифметики | +| 5 | Прямоугольные матрицы | Умножение матриц разных размеров | +| 6 | Разреженные 4×4 | Работа CCS-структуры | +| 7 | Один ненулевой столбец | Частично заполненная матрица | +| 8 | Крайние индексы | Проверка граничных строк | +| 9 | Несколько потоковых блоков | Корректность распределения | +| 10 | Полностью заполненная диагональ | Проверка накопления | +| 11 | Центральный элемент | Корректность индексации | +| 12 | Разреженные комплексные значения | Проверка знаков и мнимой части | +| 13 | Несортированные элементы столбца | Проверка сортировки строк | + +Все функциональные тесты успешно пройдены ## 6. Экспериментальная среда @@ -157,18 +172,22 @@ mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecF mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" ## 7. Результаты -Примеры тестов -| Режи | Время | -| ---------------------- | ------- | -| pipeline | 0.000164| -| task_run | 0.000166| +В таблице представлены результаты замеров времени выполнения последовательной версии алгоритма + +| Режим | Workers (p) | Время (сек) | Speedup | Efficiency | +| :---------------------------- | :---------: | :---------: | :-----: | :--------: | +| Последовательная версия (SEQ) | 1 | 0.000166 | 1.0 | 1.0 | Наиболее затратным участком является двойной проход по ненулевым элементам столбцов. ## 8. Выводы -Реализован корректный алгоритм умножения разреженных комплексных матриц в формате CCS. +В ходе работы была реализована последовательная версия алгоритма умножения разреженных комплексных матриц в формате CCS. Реализация корректно выполняет обработку ненулевых элементов, формирует результирующую матрицу в столбцовом формате хранения и поддерживает операции над комплексными числами. + +Проведённое тестирование подтвердило корректность работы алгоритма для различных типов входных данных: + +- квадратных и прямоугольных матриц; +- полностью и частично разреженных структур; +- комплексных значений; +- случаев с нулевым результатом. -Последовательная версия: -- обеспечивает корректность вычислений; -- поддерживает разреженное хранение; -- служит базой для сравнения параллельных технологий. \ No newline at end of file +Последовательная версия используется как базовая реализация для сравнения эффективности параллельных алгоритмов. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md index cbfd954e75..8d42f43220 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md @@ -43,13 +43,15 @@ OpenMP-реализация должна давать **идентичный** S ## 4. Схема распараллеливания В STL-версии распараллеливание выполнено с использованием std::thread. Все столбцы результирующей -матрицы делятся между потоками. +матрицы делятся между потоками блоками: +int cols_per_thread = (b.cols + num_threads - 1) / num_threads; Каждый поток: 1. Получает диапазон столбцов; 2. Выполняет вычисление соответствующих столбцов результата; 3. Сохраняет локальные значения в отдельные контейнеры. -После завершения работы потоков основной поток объединяет локальные результаты в итоговую CCS- -структуру. +После завершения вычислений выполняется: +1) ожидание потоков (join); +2) последовательная сборка результирующей CCS-матрицы. ## 5. Детали реализации - `stl/include/ops_stl.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsSTL`. @@ -82,15 +84,43 @@ cols_per_thread = th.join(); ## 6. Проверка корректности -STL-реализация успешно проходит все функциональные тесты. -Для проверки корректности использованы функциональные тесты: -- умножение матриц размером 1×1; -- матрицы с различной плотностью; -- прямоугольные матрицы; -- матрицы с нулевыми столбцами; -- комплексные значения; -- полностью разреженные случаи. -Сравнение результатов выполняется с использованием допуска 1e-9. +STL-реализация проходит все функциональные тесты, +используемые для последовательной версии. + +### Способ проверки +Корректность реализации проверялась с помощью функциональных тестов Google Test. + +Проверялись: +размеры результирующей матрицы; +массив col_ptr; +массив row_ind; +значения комплексных элементов с точностью 1e-9. + +Сравнение результатов реализовано функцией: +CompareMatrices(...) + +### Функциональные тесты +Используется 14 тестов. +| № теста | Описание | Проверяемый случай | +| ------- | -------------------------------- | ----------------------------------- | +| 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | +| 1 | Диагональные 2×2 | Корректность умножения | +| 2 | Нулевой результат | Отсутствие ненулевых элементов | +| 3 | Мнимые числа | Работа с чисто мнимыми значениями | +| 4 | Комплексные коэффициенты | Корректность комплексной арифметики | +| 5 | Прямоугольные матрицы | Умножение матриц разных размеров | +| 6 | Разреженные 4×4 | Работа CCS-структуры | +| 7 | Один ненулевой столбец | Частично заполненная матрица | +| 8 | Крайние индексы | Проверка граничных строк | +| 9 | Несколько потоковых блоков | Корректность распределения | +| 10 | Полностью заполненная диагональ | Проверка накопления | +| 11 | Центральный элемент | Корректность индексации | +| 12 | Разреженные комплексные значения | Проверка знаков и мнимой части | +| 13 | Несортированные элементы столбца | Проверка сортировки строк | + +Все функциональные тесты успешно пройдены +Результаты совпадают с SEQ +с точностью 1e-9. ## 7. Экспериментальная среда @@ -118,9 +148,12 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri | STL | 4 | 0.002967 | 0.06 | 0.01 | | STL | 8 | 0.004881 | 0.03 | 0.00 | | STL | 16 | 0.008424 | 0.02 | 0.00 | - +- Speedup = `T_seq / T_par` +- Efficiency = `Speedup / threads` +- База для `T_seq` — замер SEQ-версии ## 9. Выводы +В ходе работы была разработана многопоточная версия алгоритма с использованием стандартных средств C++ (std::thread). Использование STL-потоков позволяет реализовать переносимое распараллеливание без привязки к конкретной библиотеке параллельного программирования. Преимуществами реализации являются: @@ -131,5 +164,3 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri - необходимость ручного управления потоками; - более сложная синхронизация; - большие накладные расходы по сравнению с OpenMP. -Реализация показала корректную работу и обеспечила ускорение вычислений при обработке больших -матриц. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md index f36643fc8d..a72eed83b2 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md @@ -44,9 +44,7 @@ OpenMP-реализация должна давать **идентичный** S 5. Сохранить ненулевые значения в матрицу результата. ## 4. Схема распараллеливания -Используется: - -```cpp +В версии TBB используется параллельный цикл: oneapi::tbb::parallel_for(...) Каждый столбец результирующей матрицы вычисляется независимо. Для хранения промежуточных результатов используются локальные контейнеры: @@ -54,6 +52,13 @@ oneapi::tbb::parallel_for(...) - local_rows. После завершения параллельного участка выполняется последовательная сборка итоговой CCS-матрицы. +Особенности реализации: +- отсутствуют общие изменяемые данные внутри вычисления столбца; +- каждая задача использует локальные структуры хранения; +- после завершения parallel_for результаты объединяются последовательно. + +Параллелизм достигается за счёт динамического распределения задач планировщиком TBB. + ## 5. Детали реализации - `tbb/include/ops_tbb.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsTBB`. - `tbb/src/ops_tbb.cpp` — реализация методов. @@ -79,8 +84,43 @@ ProcessColumn(j, a, b, local_values[j], local_rows[j]); что исключает гонки данных. ## 6. Проверка корректности -Использованы те же функциональные тесты, что и для остальных реализаций. -Все тесты успешно пройдены. +TBB-реализация проходит все функциональные тесты, +используемые для последовательной версии. + +### Способ проверки +Корректность реализации проверялась с помощью функциональных тестов Google Test. + +Проверялись: +размеры результирующей матрицы; +массив col_ptr; +массив row_ind; +значения комплексных элементов с точностью 1e-9. + +Сравнение результатов реализовано функцией: +CompareMatrices(...) + +### Функциональные тесты +Используется 14 тестов. +| № теста | Описание | Проверяемый случай | +| ------- | -------------------------------- | ----------------------------------- | +| 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | +| 1 | Диагональные 2×2 | Корректность умножения | +| 2 | Нулевой результат | Отсутствие ненулевых элементов | +| 3 | Мнимые числа | Работа с чисто мнимыми значениями | +| 4 | Комплексные коэффициенты | Корректность комплексной арифметики | +| 5 | Прямоугольные матрицы | Умножение матриц разных размеров | +| 6 | Разреженные 4×4 | Работа CCS-структуры | +| 7 | Один ненулевой столбец | Частично заполненная матрица | +| 8 | Крайние индексы | Проверка граничных строк | +| 9 | Несколько потоковых блоков | Корректность распределения | +| 10 | Полностью заполненная диагональ | Проверка накопления | +| 11 | Центральный элемент | Корректность индексации | +| 12 | Разреженные комплексные значения | Проверка знаков и мнимой части | +| 13 | Несортированные элементы столбца | Проверка сортировки строк | + +Все функциональные тесты успешно пройдены +Результаты совпадают с SEQ +с точностью 1e-9. ## 7. Экспериментальная среда @@ -103,20 +143,22 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri ## 8. Результаты | Режим | Workers (p) | Time (сек) | Speedup | Efficiency | | :---- | :---------: | :--------: | :-----: | :--------: | -| SEQ | 1 | 0.000166 | 1.00 | 1.00 | -| TBB | 2 | 0.001216 | 0.14 | 0.07 | -| TBB | 4 | 0.001273 | 0.13 | 0.03 | -| TBB | 8 | 0.001195 | 0.14 | 0.02 | -| TBB | 16 | 0.001162 | 0.14 | 0.01 | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| TBB | 2 | 0.001216 | 0.14 | 0.07 | +| TBB | 4 | 0.001273 | 0.13 | 0.03 | +| TBB | 8 | 0.001195 | 0.14 | 0.02 | +| TBB | 16 | 0.001162 | 0.14 | 0.01 | +- Speedup = `T_seq / T_par` +- Efficiency = `Speedup / threads` +- База для `T_seq` — замер SEQ-версии TBB обеспечивает хорошую балансировку при неравномерном распределении ненулевых элементов. -Однако runtime TBB создаёт дополнительные накладные расходы -на управление задачами. - +Однако runtime TBB создаёт дополнительные накладные расходы на управление задачами. ## 9. Выводы +В работе была реализована версия алгоритма с использованием библиотеки Intel oneTBB. TBB предоставляет удобный и современный механизм распараллеливания вычислений. Преимущества: - автоматическое управление потоками; @@ -125,4 +167,3 @@ TBB предоставляет удобный и современный меха Недостатки: - дополнительная зависимость от библиотеки; - более сложная настройка среды. -Реализация продемонстрировала высокую производительность и удобство разработки. From 198e3d3fc18ac6985094c1bcd469ace9b48c8477 Mon Sep 17 00:00:00 2001 From: GoriachevaKsenia Date: Thu, 4 Jun 2026 17:17:58 +0300 Subject: [PATCH 3/5] Fix report --- .../all/report.md | 17 ++-- .../omp/report.md | 48 +++++++--- .../report.md | 45 +++++----- .../seq/report.md | 88 +++++++++++++------ .../stl/report.md | 12 +-- .../tbb/report.md | 12 +-- 6 files changed, 139 insertions(+), 83 deletions(-) diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md index 1ca9df09bb..1ba046649a 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/all/report.md @@ -64,7 +64,9 @@ int cols_per_proc = OpenMP Внутри процесса используется: +```cpp #pragma omp parallel for +``` для обработки локальных столбцов. Сборка результата @@ -123,7 +125,7 @@ CompareMatrices(...) ### Функциональные тесты Используется 14 тестов. -| № теста | Описание | Проверяемый случай | +| № теста | Описание | Проверяемый случай | | ------- | -------------------------------- | ----------------------------------- | | 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | | 1 | Диагональные 2×2 | Корректность умножения | @@ -165,11 +167,11 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri ## 8. Результаты | Режим | Workers (p) | Time (сек) | Speedup | Efficiency | | :---- | :---------: | :--------: | :-----: | :--------: | -| SEQ | 1 | 0.000166 | 1.00 | 1.00 | -| ALL | 2 | 0.000399 | 0.42 | 0.21 | -| ALL | 4 | 0.005986 | 0.03 | 0.01 | -| ALL | 8 | 0.026888 | 0.01 | 0.00 | -| ALL | 16 | 0.103833 | 0.00 | 0.00 | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| ALL | 2 | 0.000399 | 0.42 | 0.21 | +| ALL | 4 | 0.005986 | 0.03 | 0.01 | +| ALL | 8 | 0.026888 | 0.01 | 0.00 | +| ALL | 16 | 0.103833 | 0.00 | 0.00 | - Speedup = `T_seq / T_par` - Efficiency = `Speedup / threads` - База для `T_seq` — замер SEQ-версии @@ -186,4 +188,5 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri - сложность реализации; - необходимость синхронизации процессов; - накладные расходы на передачу данных. -Несмотря на увеличение накладных расходов, связанных с MPI-коммуникациями и синхронизацией процессов, гибридная реализация обеспечивает возможность масштабирования вычислений на распределённые системы. \ No newline at end of file +Несмотря на увеличение накладных расходов, связанных с MPI-коммуникациями и синхронизацией процессов, +гибридная реализация обеспечивает возможность масштабирования вычислений на распределённые системы. \ No newline at end of file diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md index 7564ae3905..3a5ddaa1ea 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/omp/report.md @@ -5,6 +5,7 @@ - Variant: 7 ## 1. Контекст + OpenMP позволяет эффективно распараллеливать циклы с независимыми итерациями в системах с общей памятью. @@ -21,34 +22,41 @@ OpenMP позволяет эффективно распараллеливать Входные данные: Две разреженные комплексные матрицы: -- A — комплексная матрица размера m × n + +- A — комплексная матрица размера m × n - B — комплексная матрица размера n × k -представленные в формате CCS: + представленные в формате CCS: Выходные данные: Матрица: -C = A * B +C = A \* B в формате CCS. OpenMP-реализация должна давать **идентичный** SEQ результат при любом количестве потоков. ## 3. Базовый алгоритм + Последовательная версия (SEQ): 1. Проверить корректность входных данных. 2. Инициализировать структуру результата. 3. Для каждого столбца матрицы B: + - пройти по ненулевым элементам; - выполнить умножение элементов; - накопить значения в accumulator. + 4. Отсортировать индексы строк. 5. Сохранить ненулевые значения в матрицу результата. ## 4. Схема распараллеливания + Параллелизация выполняется по столбцам результирующей матрицы. Используется директива: +```cpp #pragma omp parallel for default(none) shared(a, b, local_values, local_rows) +``` Каждый поток независимо обрабатывает собственный столбец: ProcessColumn(j, a, b, local_values[j], local_rows[j]); @@ -56,23 +64,27 @@ ProcessColumn(j, a, b, local_values[j], local_rows[j]); Для исключения гонок данных: каждый поток записывает результат только в собственные контейнеры: + - local_values[j] - local_rows[j] - объединение результатов выполняется после завершения параллельной области. Shared-переменные: + - a; - b; - local_values; - local_rows. Private-переменные: + - j; - локальные accumulator; - marker; - used_rows. Синхронизация: + - явные critical sections отсутствуют; - используется неявный барьер после parallel for. @@ -87,25 +99,30 @@ Private-переменные: local_values/local_rows ## 5. Детали реализации + - `omp/include/ops_omp.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsOMP`. - `omp/src/ops_omp.cpp` — реализация методов. ### Особенности + Для каждого столбца используются локальные буферы: -std::vector> local_values(c.cols); -std::vector> local_rows(c.cols); +`std::vector> local_values(c.cols);` +`std::vector> local_rows(c.cols);` Это устраняет гонки данных. ### Схема памяти + - a, b — shared; - local_values[j] — private для столбца; - временные аккумуляторы — private. ## 6. Проверка корректности + OpenMP-реализация проходит все функциональные тесты, используемые для последовательной версии. ### Способ проверки + Корректность реализации проверялась с помощью функциональных тестов Google Test. Проверялись: @@ -118,8 +135,9 @@ OpenMP-реализация проходит все функциональные CompareMatrices(...) ### Функциональные тесты + Используется 14 тестов. -| № теста | Описание | Проверяемый случай | +| № теста | Описание | Проверяемый случай | | ------- | -------------------------------- | ----------------------------------- | | 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | | 1 | Диагональные 2×2 | Корректность умножения | @@ -153,27 +171,31 @@ CMake: 4.0.1 RAM: 32 GB ### Сборка + cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release cmake --build build --config Release --parallel ### Запуск тестов + cd build/bin -mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" -mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" +mpiexec -n 4 ./ppc*func_tests --gtest_filter="\_GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc*perf_tests --gtest_filter="\_GoriachevaKMultSparseComplexMatrixCcsPerfTest*" ## 8. Результаты + | Режим | Workers (p) | Time (сек) | Speedup | Efficiency | | :---- | :---------: | :--------: | :-----: | :--------: | -| SEQ | 1 | 0.000166 | 1.00 | 1.00 | -| OMP | 2 | 0.000502 | 0.33 | 0.17 | -| OMP | 4 | 0.001694 | 0.10 | 0.02 | -| OMP | 8 | 0.001913 | 0.09 | 0.01 | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| OMP | 2 | 0.000502 | 0.33 | 0.17 | +| OMP | 4 | 0.001694 | 0.10 | 0.02 | +| OMP | 8 | 0.001913 | 0.09 | 0.01 | - Speedup = `T_seq / T_par` -- Efficiency = `Speedup / threads` +- Efficiency = `Speedup / threads` - База для `T_seq` — замер SEQ-версии ## 9. Выводы + В ходе работы была разработана параллельная версия алгоритма с использованием OpenMP. OpenMP позволяет быстро распараллелить вычисления за счёт директив компилятора и минимального объёма изменений в последовательном коде. В данной реализации параллельная обработка выполняется diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md index 3a29f983f5..289a42d27f 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md @@ -39,7 +39,7 @@ - A — комплексная матрица размера m × n - B — комплексная матрица размера n × k представленные в формате CCS: - +```cpp struct SparseMatrixCCS { int rows; int cols; @@ -48,6 +48,7 @@ struct SparseMatrixCCS { std::vector row_ind; std::vector col_ptr; }; +``` где: values — ненулевые элементы; @@ -65,10 +66,10 @@ C = A * B ### Крайние случаи -| Случай | Ожидаемое поведение | +| Случай | Ожидаемое поведение | | ---------------------------------------- | -------------------------------------- | -| Несовместимые размеры |ValidationImpl() возвращает false | -| Пустые col_ptr |ValidationImpl() возвращает false | +| Несовместимые размеры | ValidationImpl() возвращает false | +| Пустые col_ptr | ValidationImpl() возвращает false | | Полностью нулевая результирующая матрица | values и row_ind пустые | | Матрица 1×1 | Корректное умножение комплексных чисел | @@ -125,24 +126,24 @@ CompareMatrices() ## 5. Агрегированные результаты | Технология | Конфигурация | Workers | Time (с) | Speedup | Efficiency | -| ---------- | ------------ | ------- | -------- | -------- | ---------- | -| SEQ | 1 процесс | 1 | 0.000166 | 1.00 | 1.00 | -| OpenMP | 2 потока | 2 | 0.000502 | 0.33 | 0.17 | -| | 4 потока | 4 | 0.001694 | 0.10 | 0.02 | -| | 8 потоков | 8 | 0.001913 | 0.09 | 0.01 | -| | 16 потоков | 16 | 0.008535 | 0.02 | 0.00 | -| STL | 2 потока | 2 | 0.001527 | 0.11 | 0.05 | -| | 4 потока | 4 | 0.002967 | 0.06 | 0.01 | -| | 8 потоков | 8 | 0.004881 | 0.03 | 0.00 | -| | 16 потоков | 16 | 0.008424 | 0.02 | 0.00 | -| TBB | 2 потока | 2 | 0.001216 | 0.14 | 0.07 | -| | 4 потока | 4 | 0.001273 | 0.13 | 0.03 | -| | 8 потоков | 8 | 0.001195 | 0.14 | 0.02 | -| | 16 потоков | 16 | 0.001162 | 0.14 | 0.01 | -| ALL | 1x2 | 2 | 0.000399 | 0.42 | 0.21 | -| (MPI+OMP) | 1x4 | 4 | 0.005986 | 0.03 | 0.01 | -| | 1x8 | 8 | 0.026888 | 0.01 | 0.00 | -| | 1x16 | 16 | 0.103833 | 0.00 | 0.00 | +| ---------- | ------------ | ------- | -------- | ------- | ---------- | +| SEQ | 1 процесс | 1 | 0.000166 | 1.00 | 1.00 | +| OpenMP | 2 потока | 2 | 0.000502 | 0.33 | 0.17 | +| | 4 потока | 4 | 0.001694 | 0.10 | 0.02 | +| | 8 потоков | 8 | 0.001913 | 0.09 | 0.01 | +| | 16 потоков | 16 | 0.008535 | 0.02 | 0.00 | +| STL | 2 потока | 2 | 0.001527 | 0.11 | 0.05 | +| | 4 потока | 4 | 0.002967 | 0.06 | 0.01 | +| | 8 потоков | 8 | 0.004881 | 0.03 | 0.00 | +| | 16 потоков | 16 | 0.008424 | 0.02 | 0.00 | +| TBB | 2 потока | 2 | 0.001216 | 0.14 | 0.07 | +| | 4 потока | 4 | 0.001273 | 0.13 | 0.03 | +| | 8 потоков | 8 | 0.001195 | 0.14 | 0.02 | +| | 16 потоков | 16 | 0.001162 | 0.14 | 0.01 | +| ALL | 1x2 | 2 | 0.000399 | 0.42 | 0.21 | +| (MPI+OMP) | 1x4 | 4 | 0.005986 | 0.03 | 0.01 | +| | 1x8 | 8 | 0.026888 | 0.01 | 0.00 | +| | 1x16 | 16 | 0.103833 | 0.00 | 0.00 | ## 6. Интерпретация различий SEQ diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md index ade47b67ef..8d6fbe2039 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/seq/report.md @@ -5,6 +5,7 @@ - Variant: 7 ## 1. Контекст + Разреженные матрицы широко используются в научных вычислениях, численных методах, моделировании физических процессов, графовых алгоритмах и задачах линейной алгебры. @@ -27,19 +28,23 @@ ## 2. Постановка задачи ### Входные данные + Две разреженные комплексные матрицы: -- A — комплексная матрица размера m × n + +- A — комплексная матрица размера m × n - B — комплексная матрица размера n × k -представленные в формате CCS: + представленные в формате CCS: +```cpp struct SparseMatrixCCS { - int rows; - int cols; +int rows; +int cols; - std::vector values; - std::vector row_ind; - std::vector col_ptr; +std::vector values; +std::vector row_ind; +std::vector col_ptr; }; +``` где: values — ненулевые элементы; @@ -47,11 +52,13 @@ row_ind — индексы строк элементов; col_ptr — указатели начала столбцов. ### Выходные данные + Матрица: -C = A * B +C = A \* B в формате CCS. ### Ограничения + - число столбцов матрицы A должно совпадать с числом строк матрицы B; - массивы col_ptr не должны быть пустыми. @@ -59,68 +66,81 @@ C = A * B | Случай | Ожидаемое поведение | | ---------------------------------------- | -------------------------------------- | -| Несовместимые размеры |ValidationImpl() возвращает false | -| Пустые col_ptr |ValidationImpl() возвращает false | +| Несовместимые размеры | ValidationImpl() возвращает false | +| Пустые col_ptr | ValidationImpl() возвращает false | | Полностью нулевая результирующая матрица | values и row_ind пустые | | Матрица 1×1 | Корректное умножение комплексных чисел | ## 3. Базовый алгоритм ### Идея алгоритма + Умножение выполняется по столбцам матрицы B. Для каждого столбца: + 1. Выбираются ненулевые элементы текущего столбца B; 2. Для каждого элемента находится соответствующий столбец матрицы A; 3. Производится накопление результата через временный аккумулятор; 4. Ненулевые значения сохраняются в CCS-структуру результата. ### Пошаговое описание + 1. Проверить корректность входных данных. 2. Инициализировать структуру результата. 3. Для каждого столбца матрицы B: + - пройти по ненулевым элементам; - выполнить умножение элементов; - накопить значения в accumulator. + 4. Отсортировать индексы строк. 5. Сохранить ненулевые значения в матрицу результата. ### Асимптотика + Пусть: + - nnz(A) — число ненулевых элементов A; - nnz(B) — число ненулевых элементов B. Тогда: + - Время: -O(nnz(A) * nnz(B)) + O(nnz(A) \* nnz(B)) - Память: -O(rows) -для временного аккумулятора. + O(rows) + для временного аккумулятора. ### Инварианты корректности + - структура CCS сохраняется; - индексы строк внутри столбца отсортированы; - нулевые элементы не сохраняются; - размеры результирующей матрицы корректны. ## 4. Детали реализации + - `seq/include/ops_seq.hpp` — объявление класса `GoriachevaKMultSparseComplexMatrixCcsSEQ`. - `seq/src/ops_seq.cpp` — реализация методов. -| Метод | Назначение | -| ---------------------- | -------------------------------------------------------- | -| `ValidationImpl()` | Проверяет совместимость размеров и корректность структуры| -| `PreProcessingImpl()` | Инициализирует выходную матрицу | -| `RunImpl()` | Выполняет последовательное умножение | -| `PostProcessingImpl()` | Завершает обработку | +| Метод | Назначение | +| ---------------------- | --------------------------------------------------------- | +| `ValidationImpl()` | Проверяет совместимость размеров и корректность структуры | +| `PreProcessingImpl()` | Инициализирует выходную матрицу | +| `RunImpl()` | Выполняет последовательное умножение | +| `PostProcessingImpl()` | Завершает обработку | + +### Особенности реализации -#### Особенности реализации Для накопления значений используются: -std::vector accumulator(a.rows); -std::vector marker(a.rows, -1); +`std::vector accumulator(a.rows);` +`std::vector marker(a.rows, -1);` marker позволяет избежать повторной инициализации элементов аккумулятора. ## 5. Проверка корректности + ### Способ проверки + Корректность реализации проверялась с помощью функциональных тестов Google Test. Проверялись: @@ -133,8 +153,10 @@ marker позволяет избежать повторной инициализ CompareMatrices(...) ### Функциональные тесты + Используется 14 тестов. -| № теста | Описание | Проверяемый случай | + +| № теста | Описание | Проверяемый случай | | ------- | -------------------------------- | ----------------------------------- | | 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | | 1 | Диагональные 2×2 | Корректность умножения | @@ -163,25 +185,33 @@ CMake: 4.0.1 RAM: 32 GB ### Сборка + cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release cmake --build build --config Release --parallel ### Запуск тестов + cd build/bin -mpiexec -n 4 ./ppc_func_tests --gtest_filter="*GoriachevaKViolationOrderElemVecFuncTests*" -mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatrixCcsPerfTest*" +mpiexec -n 4 ./ppc*func_tests --gtest_filter="\_GoriachevaKViolationOrderElemVecFuncTests*" +mpiexec -n 4 ./ppc*perf_tests --gtest_filter="\_GoriachevaKMultSparseComplexMatrixCcsPerfTest*" ## 7. Результаты + В таблице представлены результаты замеров времени выполнения последовательной версии алгоритма -| Режим | Workers (p) | Время (сек) | Speedup | Efficiency | -| :---------------------------- | :---------: | :---------: | :-----: | :--------: | +| Режим | Workers (p) | Время (сек) | Speedup | Efficiency | +| :---------------------------: | :---------: | :---------: | :-----: | :--------: | | Последовательная версия (SEQ) | 1 | 0.000166 | 1.0 | 1.0 | Наиболее затратным участком является двойной проход по ненулевым элементам столбцов. ## 8. Выводы -В ходе работы была реализована последовательная версия алгоритма умножения разреженных комплексных матриц в формате CCS. Реализация корректно выполняет обработку ненулевых элементов, формирует результирующую матрицу в столбцовом формате хранения и поддерживает операции над комплексными числами. + +В ходе работы была реализована последовательная версия алгоритма +умножения разреженных комплексных матриц в формате CCS. +Реализация корректно выполняет обработку ненулевых элементов, +формирует результирующую матрицу в столбцовом формате хранения и +поддерживает операции над комплексными числами. Проведённое тестирование подтвердило корректность работы алгоритма для различных типов входных данных: @@ -190,4 +220,4 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri - комплексных значений; - случаев с нулевым результатом. -Последовательная версия используется как базовая реализация для сравнения эффективности параллельных алгоритмов. \ No newline at end of file +Последовательная версия используется как базовая реализация для сравнения эффективности параллельных алгоритмов. diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md index 8d42f43220..b3d4059e0b 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/stl/report.md @@ -101,7 +101,7 @@ CompareMatrices(...) ### Функциональные тесты Используется 14 тестов. -| № теста | Описание | Проверяемый случай | +| № теста | Описание | Проверяемый случай | | ------- | -------------------------------- | ----------------------------------- | | 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | | 1 | Диагональные 2×2 | Корректность умножения | @@ -143,11 +143,11 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri ## 8. Результаты | Режим | Workers (p) | Time (сек) | Speedup | Efficiency | | :---- | :---------: | :--------: | :-----: | :--------: | -| SEQ | 1 | 0.000166 | 1.00 | 1.00 | -| STL | 2 | 0.001527 | 0.11 | 0.05 | -| STL | 4 | 0.002967 | 0.06 | 0.01 | -| STL | 8 | 0.004881 | 0.03 | 0.00 | -| STL | 16 | 0.008424 | 0.02 | 0.00 | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| STL | 2 | 0.001527 | 0.11 | 0.05 | +| STL | 4 | 0.002967 | 0.06 | 0.01 | +| STL | 8 | 0.004881 | 0.03 | 0.00 | +| STL | 16 | 0.008424 | 0.02 | 0.00 | - Speedup = `T_seq / T_par` - Efficiency = `Speedup / threads` - База для `T_seq` — замер SEQ-версии diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md index a72eed83b2..08ab502197 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/tbb/report.md @@ -101,7 +101,7 @@ CompareMatrices(...) ### Функциональные тесты Используется 14 тестов. -| № теста | Описание | Проверяемый случай | +| № теста | Описание | Проверяемый случай | | ------- | -------------------------------- | ----------------------------------- | | 0 | Матрицы 1×1 | Базовое умножение комплексных чисел | | 1 | Диагональные 2×2 | Корректность умножения | @@ -143,11 +143,11 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri ## 8. Результаты | Режим | Workers (p) | Time (сек) | Speedup | Efficiency | | :---- | :---------: | :--------: | :-----: | :--------: | -| SEQ | 1 | 0.000166 | 1.00 | 1.00 | -| TBB | 2 | 0.001216 | 0.14 | 0.07 | -| TBB | 4 | 0.001273 | 0.13 | 0.03 | -| TBB | 8 | 0.001195 | 0.14 | 0.02 | -| TBB | 16 | 0.001162 | 0.14 | 0.01 | +| SEQ | 1 | 0.000166 | 1.00 | 1.00 | +| TBB | 2 | 0.001216 | 0.14 | 0.07 | +| TBB | 4 | 0.001273 | 0.13 | 0.03 | +| TBB | 8 | 0.001195 | 0.14 | 0.02 | +| TBB | 16 | 0.001162 | 0.14 | 0.01 | - Speedup = `T_seq / T_par` - Efficiency = `Speedup / threads` - База для `T_seq` — замер SEQ-версии From aadecfdbc97077d0d68e8687b3a2017717d51222 Mon Sep 17 00:00:00 2001 From: GoriachevaKsenia Date: Thu, 4 Jun 2026 17:23:33 +0300 Subject: [PATCH 4/5] Fix report --- tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md index 289a42d27f..7b20918c75 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md @@ -2,7 +2,8 @@ - Student: Горячева Ксения Александровна, group: 3823Б1ФИ2 - Variant: 7 -- Local reports: [seq/report.md](seq/report.md) · [omp/report.md](omp/report.md) · [tbb/report.md](tbb/report.md) · [stl/report.md](stl/report.md) · [all/report.md](all/report.md) +- Local reports: [seq/report.md](seq/report.md) · [omp/report.md](omp/report.md) · +[tbb/report.md](tbb/report.md) · [stl/report.md](stl/report.md) · [all/report.md](all/report.md) ## 1. Введение Разреженные матрицы широко применяются в задачах вычислительной математики, From 58cd8b558d21e504422957f9ec6d0e6ed7b45212 Mon Sep 17 00:00:00 2001 From: GoriachevaKsenia Date: Thu, 4 Jun 2026 17:31:12 +0300 Subject: [PATCH 5/5] Fix report --- tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md | 1 + 1 file changed, 1 insertion(+) diff --git a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md index 7b20918c75..61f4fa6ec6 100644 --- a/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md +++ b/tasks/goriacheva_k_mult_sparse_complex_matrix_ccs/report.md @@ -222,3 +222,4 @@ mpiexec -n 4 ./ppc_perf_tests --gtest_filter="*GoriachevaKMultSparseComplexMatri ## 9. Источники [Документация курса «Параллельное программирование»](https://learning-process.github.io/parallel_programming_course/ru/) +