Подякувати Студентському архіву довільною сумою
Admin
26.02.2023 12:38
Дякуємо, що користуєтесь нашим архівом!
Паралельне виконання операцій над матрицями на структурі типу Ікосаедр
Інформація про навчальний заклад
ВУЗ:
Національний університет Львівська політехніка
Інститут:
ІКТА
Факультет:
Не вказано
Кафедра:
Кафедра ЕОМ
Інформація про роботу
Рік:
2024
Тип роботи:
Курсова робота
Предмет:
Моделювання паралельних обчислювальних процесів
Частина тексту файла (без зображень, графіків і формул):
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ УНІВЕРСИТЕТ „ЛЬВІВСЬКА ПОЛІТЕХНІКА”
ІКТАМ
Кафедра ЕОМ
Курсова робота
з дисципліни: “ Моделювання паралельних обчислювальних процесів”
на тему: “Паралельне виконання операцій над матрицями на
структурі типу Ікосаедр”
Варіант № 5
Завдання до роботи
Розробити структуру та описати процедуру перемноження матриці А (розмірністю n1*n2) на матрицю В (розмірністю n2*n3) на структурі типу Ікосаедер. Для цієї структури визначити час виконання алгоритму, відсоток послідовної частини алгоритму та ефективність алгоритму для значень, що задані в таблиці 1.
Таблиця 1. Варіанти завдань до курсової роботи за темою
“Паралельне виконання операцій над матрицями на структурі типу Ікосаедр”
№ варіанту
Розміри матриць
Тип початкового завантаження даних*
Співвідношення часових параметрів
n1
n2
n3
4
60
1100
80
2*
tU = 8tS = 9tP =10tZ = 15tW
Примітки:
2* – завантаження початкових даних в процесори з спільної пам’яті;
tU – час виконання однієї операції множення;
tS – час виконання однієї операції сумування;
tP – час виконання однієї операції пересилання даних між процесорами;
tZ – час виконання операції завантаження одних даних;
tW – час виконання операції вивантаження одних даних.
Анотація
В даній курсовій роботі розроблено алгоритм паралельного перемноження матриці на матрицю на структурі типу Ікосаедр з завантаженням даних з спільної пам’яті. Вхідні матриці мають розмірності 60*1100 та 1100*80 відповідно.
Здійснена програмна реалізація даного алгоритму. Програма написана на мові С++ з використання технології МРІ і має консольний інтерфейс.
Здійснений розрахунок числових характеристик роботи алгоритму на даній структурі, таких як час виконання множення для заданих вхідних даних, частка послідовних обчислень та ефективність алгоритму. Проведено також порівняння ефективності даного паралельного алгоритму перемноження матриць з послідовним алгоритмом.
Зміст
Вступ 5
1. Теоретичний розділ 6
2. Аналіз (розробка) граф-схеми виконання заданої функції 9
3. Розробка функціональної схеми 12
4. Розрахунковий розділ 14
5. Розробка програми 17
Висновки 20
Література 21
Вступ
На даний час у світі дедалі більше розповсюджуються паралельні комп’ютерні системи.
Для розв’язання багатьох задач (прогноз погоди, задачі гідро- і газодинаміки, квантової хімії, астрономії, спектроскопії, біології, ядерної фізики) необхідна висока продуктивність та висока швидкість передачі інформації по каналах зв’язку, великі об’єми оперативної і постійної пам’яті, які не можуть забезпечити типові обчислювальні засоби. Одним з шляхів забезпечення таких вимог є організація паралельних та розподілених обчислень і створення відповідних технічних засобів їх реалізації. Причому, ефективність паралельної обробки залежить як від продуктивності комп’ютерів, так і від розмірів і структури пам’яті, пропускної здатності каналів зв’язку, використаних мов програмування, компіляторів, операційних систем та інших факторів.
Такий широкий обсяг параметрів вимагає проведення досліджень на різних рівнях: на рівні розпаралелення алгоритмів, створення спеціальних мов програмування, компіляторів, багатопроцесорних систем, кластерів і систем, що розподілені на великих територіях.
Для скорочення термінів розробки паралельних систем та дослідження їх роботи використовується моделювання.
При розробці паралельних алгоритмів розв’язання складних науково-технічних задач принциповим моментом являється аналіз ефективності використання паралелізму, що полягає зазвичай в оцінці отримуваного прискорення процесу обчислень (скорочення часу вирішення задачі). Формування подібних оцінок прискорення може здійснюватися стосовно вибраного обчислювального алгоритму (оцінка ефективності розпаралелювання конкретного алгоритму). Інший важливий підхід полягає в побудові оцінок максимально можливого прискорення процесу вирішення задачі конкретного типу (оцінка ефективності паралельного способу вирішення задачі).
Теоретичний розділ
Кожна паралельна система складається з певної кількості процесорів і модулів пам'яті, які зв'язані через певні комутаційні структури. Враховуючи особливості задач, які будуть виконуватися на обчислювальній системі, структура зв'язків системи має відповідати різним критеріям, насамперед, забезпечувати по можливості високу коннективність (гарантувати зв'язок між двома будь-якими процесорами або модулями пам'яті без потреби переходу через проміжні пункти комутацій). Окpiм цього, має забезпечуватись найбільша кількість одночасних зв'язків, щоб комутаційна мережа не обмежувала продуктивність вузлів паралельної обробки інформації. Проте існують різноманітні обмеження: кількість ліній зв'язку на один процесор не може збільшуватися безмежно, має також місце фізичне обмеження на ширину частотної смуги пропускання (швидкість передачі) комутаційної мережі.
Множення матриці на вектор і матриці на матрицю є базовими макроопераціями для багатьох задач. Для їх реалізації використовуються різні алгоритми та різні структури. Різноманітність варіантів алгоритмів виникає через різноманітність обчислювальних систем і різноманітність розмірів задач.
В даній курсовій роботі досліджується структура типу Ікосаедр, і ефективність паралельного алгоритму множення матриць на цій структурі.
Для кращого розуміння особливостей роботи алгоритму розглянемо детальніше базові властивості ікосаедра.
У ікосаедра нараховується 12 вершин (В), 30 ребер (Р), 20 граней (Г) у вигляді однакових правильних трикутників, які збігаються у вершинах утворюючи пентагон з властивостями золотої пропорції (рис. 1.1).
В геометрії ікосаедра переплітаються ідеї і конструкції цілого ряду математичних теорій, що лягли в основу багатьох досліджень в різних галузях науки.
Рис. 1.1. 3D модель ікосаедра
Як видно в ікосаедра 12 вершин, тобто, у нашій системі буде 12 процесорів, при чому кожен з них має зв’язок з п’ятьма сусідніми.
При розробці системи були задіяні 28 зв’язків, щоб максимально точно показати реалізацію алгоритму на даній структурі.
На основі варіанту завантаження початкових даних і вивантаження результатів у систему відбувається з спільної пам'яті і в спільну пам'ять відповідно. В такому випадку в нас іде послідовний доступ, що вагомо збільшує час виконання алгоритму.
Реалізація завантаження відбувається двома процесами, щоб максимально зменшити час доступу до пам’яті. Дана реалізація дає можливість прискорити виконання алгоритму, і зробити меншими затрати на завантаження даних з пам’яті.
Вивантаження реалізовується що кожен процесор вивантажує свої результати в пам'ять, процес також відбувається послідовно.
На рисунку 1.2 наведено граф, який відображає схему обміну даними (вхідними та вихідними).
Рис. 1.2. Схема обміну даними
Даному графу відповідає матриця суміжності, яка наведена в таблиці 1.2.
Таблиця 1.2. Матриця суміжності
0
1
2
3
4
5
6
7
8
9
10
11
0
–
1
1
1
1
–
–
–
–
–
–
–
1
1
–
1
–
–
1
1
–
–
–
1
–
2
1
1
–
1
–
–
1
1
–
–
–
–
3
1
–
1
–
1
–
–
1
1
–
–
–
4
1
–
–
1
–
1
–
–
1
1
–
–
5
1
1
–
–
1
–
–
–
–
1
1
–
6
–
1
1
–
–
–
–
1
–
–
–
1
7
–
–
1
1
–
–
1
–
1
–
–
1
8
–
–
–
1
1
–
–
1
–
1
–
1
9
–
–
–
–
1
1
–
–
1
–
1
1
10
–
1
–
–
–
1
1
–
–
1
–
1
11
–
–
–
–
–
–
1
1
1
1
1
1
2. Аналіз (розробка) граф-схеми виконання заданої функції
Згідно завдання потрібно розробити алгоритм перемноження матриці на матрицю на структурі типу Ікосаедр з завантаженням даних з спільної пам’яті.
Така структура дозволяє проводити множення над окремими частинами матриць паралельно.
На рис. 2.1 наведено результат розробки граф-схеми виконання алгоритму перемноження двох матриць на структурі типу Ікосаедр з завантаженням даних з спільної пам’яті.
Рис. 2.1. Граф-схема виконання алгоритму множення двох матриць на структурі Ікосаедр з спільною пам’яттю
Дані завантажуються з спільної пам’яті у пам’ять нульового процесора та одинадцятого процесора. Але кожен завантажує відповідно першу і другу половину матриці А і цілу матрицю В. Як було сказано раніше завантаження з пам’яті відбувається послідовно. Пізніше нульовий процесор розсилає відповідні горизонтальні смуги першої половини першої матриці сусіднім процесорам залежно від їхнього рангу. Одинадцятий процесор також відсилає відповідні горизонтальні смуги другої половини першої патриці сусіднім процесорам. Друга матриця розбивається вертикальними смугами але розбиття другої матриці іде не на всі процесори, а лише на 10. Так нульовий процесор відсилатиме вертикальні смуги другої матриці відповідно до рангу сусідніх процесів, а це означає що розсилатиметься лише перша половина другої матриці.
В той же час одинадцятий процесор відсилатиме вертикальні смуги другої матриці сусіднім процесам, а це означає, що розсилатиметься лише друга половина другої матриці. Відповідно до алгоритму, кожен процесор здійснює множення відповідної горизонтальної смуги першої матриці на відповідні вертикальні смуги другої матриці. Результатом множення є відповідний блок результуючої матриці.
Тому можна підсумувати, що вданому алгоритмі реалізовані 2 типи пересилань. Початкове пересилання це розсилання іншим процесорам частини матриць відповідно до рангу процесу. Це пересилання відбувається з 0 всім сусіднім, і з 11 всім сусіднім, ці пересилання виконуються паралельно. Наступний тип пересилань це пересилання при обчислені. Відповідно процесори від 1 до 10 обмінюються даними за деякою схемою.
Рис. 2.2. Граф-схема покрокового виконання алгоритму множення двох матриць на структурі Ікосаедр з спільною пам’яттю
3. Розробка функціональної схеми
Після запуску паралельної програми нульовий процесор зчитує вхідні дані з пам’яті, після нього зчитувати починає одинадцятий процесор. В цей же час нульовий процесор розсилає відповідні дані на процесори 1-5, з якими він має безпосередні лінії зв’язку. Після цього він розпочинає множення своїх смуг першої матриці на цілу другу матрицю.
Процесори з першого по п’ятий в свою чергу приймають необхідні для роботи дані з нульового процесора. Після цього вони розпочинають множення.
Коли одинадцятий процесор прочитає дані з пам’яті, він розпочне пересилку вхідних даних сусіднім процесам, і після цього також розпочинає множення.
Процеси від 1 по 10 перемножують свої рядки матриці А на стовпці матриці B. Після перемноження своїх даних, процесори пересилають сусіднім процесам свою під матрицю В і приймаються від сусіднього його під матрицю В.
В такому випадку на 5 кроці інтерації відбувається пересилання між верхньою і нижньою групою процесорів.
Всі процесори, повністю виконавши задане їм множення, відсилають результати у пам’яті по черзі відповідно до свого рангу. Остаточний результат множення матриць буде записано в пам'ять.
Результати розробки функціональної схеми наведені на рис. 3.1.
4. Розрахунковий розділ
Множення відбувається наступним чином нульовий і одинадцятий процесор множать виділену йому горизонтальну смугу матриці A на матрицю B, а інші відповідно до свого рангу процесори перемножують відповідну під матриця матрицю А та під матрицю B.
За заданими вхідними даними виразимо тривалість всіх операцій, які виконуються, через тривалість операції вивантаження даних tw. І так маємо:
tU = 15*tw
tS = 15/8*tw
tP = 15/9*tw
tz = 15/10*tw
Дані завантажуються з спільної пам’яті.
Часом завантаження вважаємо час завантаження вхідних даних з зовнішньої пам’яті у пам’ять нульового і одинадцятого процесора. Час завантаження даних у пам’ять процесора з рангом 0 або 11 дорівнює половині кількості елементів матриці A та загальній кількості елементів матриці B помноженій на час завантаження одного елементу даних tZ:
TZ0 = (N1/2*N2 + N2*N3) * tZ = (30*1100 + 1100*80) * tZ = 121 000 * tZ.
Операція початкового завантаження матриць A та B виконується послідовно тому загальний час завантаження з пам’яті буде рівний сумі завантажень 0 і 11 процесора.
TZ = TZ0 + TZ11 = 121 000 * tZ.+ 121 000 * tZ.=242000 tZ = 363000 tw
Для того, щоб розпочати множення, необхідно розіслати необхідні для роботи дані на кожен процесор. Це займе час TP1.
Пересилання даних з нульового процесора на п’ять сусідніх виконується послідовно. Кількість операцій пересилання дорівнює:
(5+5+5+5+5)*N2 + 5*N2*N3/10 = 25*N2 + 5*N2*N3/10
Далі кількість операцій пересилання, які необхідно виконати процесору 11 буде така сама, але час цих пересилань іде паралельно з пересиланнями нульового процесору з деяким зміщенням в часі.
Тепер порахуємо чому дорівнює загальний час пересилання даних:
TP1 = (25*N2 + 5*N2*N3/10 ) * tP + Tz0 = 71500 * tP + 121 000 * tZ = 71500 *15/9 tw + 181500 * tw = 119166* tw + 181500 * tw = 300666*tw
Множення виконується на всіх процесорах незалежно, а значить паралельно.
Отже, час множення дорівнює:
TU = 10*5*1100*8 * tU = = 440000* tU = 440000*15*tw = 6600000* tw.
Кількість операцій сумування дорівнює кількості операцій множення. Отже, час виконання сумування дорівнює:
TS = 5*N2*N3 * tS = 5*1100*80 * tS = 440000* tS = 440000 * 15/8*tw = 825000* tw.
Загальний час пересилання знаходимо як суму TP1 пересилання вхідних даних та TP2 пересилання даних між процесами під час обчислення, а саме пересилання між 1-10 процесори:
TP = TP1 + TP2 = 300666*tw + 8800*9 * tp = 300666*tw + 132000*tw= 432666tw.
Часом вивантаження вважаємо час вивантаження матриці результату з пам’яті процесорів у зовнішню пам’ять. Він дорівнює:
TW = 12*N1/12*N3 * tW = 60*80 * tW = 4800 * tW.
Загальний час роботи дорівнює сумі всіх знайдених вище часових значень:
Т = TZ + TP + TU + TS + TW = (363000 + 432666+ 6600000+825000+4800)* tw = 8225466* tw.
Для порівняння обчислимо умовний час виконання послідовного алгоритму:
Час завантаження і час вивантаження будуть такими ж як і в паралельному алгоритмі:
TZпос = 231000* tw.
TWпос = 4800 * tZ.
Пересилань ніяких не буде, тому час пересилання TPпос = 0.
Час множення буде рівним:
TUпос = (N1*N2*N3) * tU = (60*1100*80) * tU = 5280000 * tU = 5280000* 15*tw = 79 200 000 * tw.
Час сумування буде рівним:
TSпос = (N1*N2*N3) * tS = (60*1100*80) * tS = 5280000 * tS = 5280000* 15/8*tw = 9900000* tw.
TПОС = ТZпос + TUпос + ТSпос + TWпос = (231000+ 79 200 000 + 9900000+ 4800) * tw = 89335800 * tw
Як бачимо, час виконання послідовного алгоритму перемноження однакових матриць на одному процесорі приблизно в 89335800/8225466=10,8 раз більший, ніж паралельного алгоритму на структурі типу Ікосаедр.
Для характеристики алгоритму визначимо коефіцієнт К, який характеризує відсоток послідовних обчислень. В нашому випадку він буде рівний:
K = (TZ + TP′ + TW) / T = (363000+ 300666 + 4800) / 8225466 ≈ 0,08.
Примітка: TP′ – частка пересилань, яка виконується послідовно.
Також порахуємо ефективність паралельного алгоритму. Ефективність визначається як відношення часу виконання алгоритму на одно процесорній системі, до часу потрібного для виконання на багатопроцесорної системі, помноженого на кількість процесорів в ній.
E = TПОС / (T * P) = 89335800/(8225466 * 12) ≈ 0,9.
5. Розробка програми
Лістинг програми наведений у додатку. Дана програма написана на мові C++. Програма має консольний інтерфейс.
На рис. 5.1 представлено вікно консолі з результатами виконання програми (в якості кількості процесів вводимо значення 12, оскільки ікосаедр є моделлю 12-процесорної системи).
Рис. 5.1. Вікно консолі з розробленої програми
Завдяки тому, що при написанні коду програми були використані засоби технології MPI, дана програма не просто імітує роботу паралельної системи, а дійсно є цілком працездатною і може бути запущеною на паралельній системі, яка досліджується у цій курсовій роботі – структурі типу Ікосаедр.
В програмі спільну пам'ять було реалізовано за допомогою файлу. Читання і запис якого іде послідовно, що допомагає максимально відобразити процес читання і запис у спільній пам’яті.
Граф-схема програми наведена на рис 5.2.
Рис. 5.2. Загальна граф-схема програми
Для обміну інформацією між процесами використовуються функції бібліотеки MPI 2.0 MPI_Send() та MPI_Recv(). Це парні функції, які призначені відповідно для відправки та прийому повідомлень.
Генерація вхідних даних виконується іншою програмою. Всі інші процеси отримують вхідні дані відповідно до алгоритму, який реалізований в курсовій.
Нульовий і одинадцятий процесори відкривають файл на читання, читання і запис реалізовані послідовно, і відбувається за допомогою зміщень.
Розповсюдження вхідних даних виконується не напряму, а із врахуванням структури системи (з врахуванням фізичних зв’язків між вузлами системи). Вивантаження результатів відбувається в спільну пам'ять, тобто іде послідовний запис у файл.
Висновки
Під час виконання цієї курсової роботи я розробив паралельний алгоритм перемноження матриці на матрицю на структурі типу Ікосаедр та його програмну реалізацію. Також було проведено деякі обчислення, які дають уявлення про характеристики даного паралельного алгоритму та порівняння його із звичайним послідовним алгоритмом. В результаті проведеної роботи можна зробити наступні висновки. Для алгоритму, реалізованого на структурі типу Ікосаедр та матриць розмірності 60*1100 і 1100*80, умовний час виконання в інтервалах виконання операції завантаження виявився рівним Т = 8225466 * tw, а для послідовного алгоритму – TПОС = 89335800 * tw, що приблизно в 10,8 раз довше. Ефективність розпаралелення виявилась рівною Е ≈ 0,9., що є досить добрим показником.
Розроблений у цій курсовій роботі паралельний алгоритм є ефективним та може використовуватись, коли немає жорстких обмежень щодо ефективності використання пам’яті (наприклад, таких як недопустимість дублювання вхідних даних).
Література
http://www.intuit.ru/department/calculate/paralltp/5/9.html – Теорія і практика паралельних обчислень
Організація паралельних обчислень: Навчальний посібник з дисципліни “Паралельні та розподілені обчислення” для студентів базового напрямку 6.0915 "Комп'ютерна інженерія" / Укладачі: Є. Ваврук, О. Лашко – Львів: Національний університет “Львівська політехніка”, 2007, 70 с.
http://www.mpiforum.org – Повний варіант описів стандартів МРІ.
Бройнль Т. Паралельне програмування: Початковий курс: Навчальний посібник. – К.:Вища школа.,1997.
http://www.parallel.ru – Інформаційно-аналітичний центр з паралельних обчислень.
http://www.csa.ru – Інститут високопродуктивних обчислень і баз даних.
http://www.hpc.nw.ru – Високопродуктивні обчислення.
Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб: БХВ-Петербург, 2002.
Воеводин В.В. Математические основы параллельных вычислений.- М.: Изд-во МГУ, 1991.
ДОДАТОК. Текст програми на С з використанням бібліотеки МРІ
#include "mpi.h"
#include <stdio.h>
#include <iostream>
#include <fstream>
#define SIZE_N 60
#define SIZE_K 1100
#define SIZE_M 80
using namespace std;
int main(int argc, char* argv[])
{
int nn=6, nnn=10;
int tempMatrix[1100*8];
//int k=0;
//int buf;
ifstream read_memory;
ofstream write_memory,mem;
//вхідні матриці
int MatrixA[30*1100];
int MatrixB[1100*80];
//матриця результату
int MatrixRes[5*80];
//підматриця - таких підмариць 12
int recvMatrixA[5*1100];
//підматриця - таких підмариць 10
int recvMatrixB[1100*8];
//початкові занчення
MPI_Status Status;
int ProcNum, ProcRank;
//ініціалізація MPI
MPI_Init(&argc, &argv);
//визначення к-сті процесів, їхні номера, і загальну групу
MPI_Comm_size(MPI_COMM_WORLD, &ProcNum);
MPI_Comm_rank(MPI_COMM_WORLD, &ProcRank);
//читання матриць з памяті яка є спільною
//в даному випадку читання проводиться 0 і 11 процесом
if ((ProcRank==0)||(ProcRank==11))
{
if (ProcRank==11)
{
MPI_Barrier(MPI_COMM_WORLD);
}
read_memory.open("memory.txt",ios::in|ios::binary);
if(read_memory)
{
cout<<" Processor "<<ProcRank<< " reads from memory "<<endl;
if (ProcRank==11)
{
read_memory.seekg(132000);
}
read_memory.read(reinterpret_cast<char*>(MatrixA),sizeof(MatrixA));
read_memory.seekg(264000);
read_memory.read(reinterpret_cast<char*>(MatrixB),sizeof(MatrixB));
read_memory.close();
cout<<"Processor "<<ProcRank<<" finished reading from memory"<<endl;
}
}
if (ProcRank!=11)
{
MPI_Barrier(MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD);
//////////////////////////////////////////////////////////////////////////
//пересилання нульовим процесором підматриць А і В, сусідніми процесами
if (ProcRank == 0)
{
//пересилання підматриці А
//розбиття на горизонтальні смуги відповідно до рангу процесора
for (int i = 1; i < 6; i++)
{
MPI_Send(MatrixA+SIZE_K*5*i, SIZE_K*5, MPI_INT, i, 0, MPI_COMM_WORLD);
}
//пересилання підматриці B
//розбиття на вертикальні смуги відповідно до рангу процесора
for (int i=0;i<5;i++)
{
for (int j=0;j<8;j++)
{
for (int k=0;k<SIZE_K;k++)
{
tempMatrix[j*SIZE_K+k] = MatrixB[SIZE_M*k+j+i*8];
}
}
MPI_Send(tempMatrix, SIZE_K*8, MPI_INT, i+1, 0, MPI_COMM_WORLD);
}
}
if(ProcRank >= 1 && ProcRank <= 5)
{
MPI_Recv(recvMatrixA, SIZE_K*5, MPI_INT, 0, 0, MPI_COMM_WORLD, &Status);
MPI_Recv(recvMatrixB, SIZE_K*8, MPI_INT, 0, 0, MPI_COMM_WORLD, &Status);
}
//////////////////////////////////////////////////////////////////////////
//пересилання одинадцятим процесором підматриць А і В, сусідніми процесами
if (ProcRank == 11)
{
//пересилання підматриці А
//розбиття на горизонтальні смуги відповідно до рангу процесора
for (int i = 1; i < 6; i++)
{
MPI_Send(MatrixA+SIZE_K*5*i, SIZE_K*5, MPI_INT, i+5, 0, MPI_COMM_WORLD);
}
//пересилання підматриці B
//розбиття на вертикальні смуги відповідно до рангу процесора
for (int i=5;i<10;i++)
{
for (int j=0;j<8;j++)
{
for (int k=0;k<SIZE_K;k++)
{
tempMatrix[j*SIZE_K+k] = MatrixB[SIZE_M*k+j+i*8];
}
}
MPI_Send(tempMatrix, SIZE_K*8, MPI_INT, i+1, 0, MPI_COMM_WORLD);
}
}
if(ProcRank >= 6 && ProcRank <= 10)
{
MPI_Recv(recvMatrixA, SIZE_K*5, MPI_INT, 11, 0, MPI_COMM_WORLD, &Status);
MPI_Recv(recvMatrixB, SIZE_K*8, MPI_INT, 11, 0, MPI_COMM_WORLD, &Status);
}
//////////////////////////////////////////////////////////////////////////
//множення нульовим і одинадцятим процесорами своєї підматриці А на цілу матрицю В
if (ProcRank==0 || ProcRank==11)
{
for (int i=0;i<5;i++)
{
for (int j=0;j<SIZE_M;j++)
{
MatrixRes[i*SIZE_M+j]=0;
for (int k=0;k<SIZE_K;k++)
MatrixRes[i*SIZE_M+j]=MatrixRes[i*SIZE_M+j]+MatrixA[i*SIZE_K+k]*MatrixB[SIZE_M*k+j];
}
}
}
//////////////////////////////////////////////////////////////////////////
//множення процесорами 1-10 своєїх підматриці А на підматрицю матрицю В
if(ProcRank >= 1 && ProcRank <= 10)
{
for (int i=0;i<5;i++)
{
for (int j=0;j<SIZE_M/10;j++)
{
MatrixRes[i*SIZE_M+8*(ProcRank-1)+j]=0;
for (int k=0;k<SIZE_K;k++)
MatrixRes[i*SIZE_M+j+8*(ProcRank-1)]=MatrixRes[i*SIZE_M+j+8*(ProcRank-1)]+recvMatrixA[i*SIZE_K+k]*recvMatrixB[j*SIZE_K+k];
}
}
//кроки ітерації, обмін підматрицями В за певною схемою
for (int ii=1;ii<5;ii++)
{
for (int jj=0;jj<SIZE_K*8;jj++)
{
tempMatrix[jj]=recvMatrixB[jj];
}
if (ProcRank == 1)
{
MPI_Send(tempMatrix, SIZE_K*8, MPI_INT, 5, 0, MPI_COMM_WORLD);
MPI_Recv(recvMatrixB, SIZE_K*8, MPI_INT, ProcRank+1, 0, MPI_COMM_WORLD, &Status);
for (int i=0;i<5;i++)
{
for (int j=0;j<SIZE_M/10;j++)
{
MatrixRes[i*SIZE_M+8*(ProcRank+ii-1)+j]=0;
for (int k=0;k<SIZE_K;k++)
MatrixRes[i*SIZE_M+j+8*(ProcRank+ii-1)]=MatrixRes[i*SIZE_M+8*(ProcRank+ii-1)+j]+recvMatrixA[i*SIZE_K+k]*recvMatrixB[j*SIZE_K+k];
}
}
}
if (ProcRank==2)
{
MPI_Send(tempMatrix, SIZE_K*8, MPI_INT, ProcRank-1, 0, MPI_COMM_WORLD);
MPI_Recv(recvMatrixB, SIZE_K*8, MPI_INT, ProcRank+1, 0, MPI_COMM_WORLD, &Status);
if (ii>3)
{
for (int i=0;i<5;i++)
{
for (int j=0;j<SIZE_M/10;j++)
{
MatrixRes[i*SIZE_M+8*(ii-4)+j]=0;
for (int k=0;k<SIZE_K;k++)
MatrixRes[i*SIZE_M+j+8*(ii-4)]=MatrixRes[i*SIZE_M+j+8*(ii-4)]+recvMatrixA[i*SIZE_K+k]*recvMatrixB[j*SIZE_K+k];
}
}
}
else
{
for (int i=0;i<5;i++)
{
for (int j=0;j<SIZE_M/10;j++)
{
MatrixRes[i*SIZE_M+8*(ProcRank+ii-1)+j]=0;
for (int k=0;k<SIZE_K;k++)
MatrixRes[i*SIZE_M+j+8*(ProcRank+ii-1)]=MatrixRes[i*SIZE_M+j+8*(ProcRank+ii-1)]+recvMatrixA[i*SIZE_K+k]*recvMatrixB[j*SIZE_K+k];
}
}
}
}
if (ProcRank==3)
{
MPI_Send(tempMatrix, SIZE_K*8, MPI_INT, ProcRank-1, 0, MPI_COMM_WORLD);
MPI_Recv(recvMatrixB, SIZE_K*8, MPI_INT, ProcRank+1, 0, MPI_COMM_WORLD, &Status);
if (ii>2)
{
for (int i=0;i<5;i++)
{
for (int j=0;j<SIZE_M/10;j++)
{
MatrixRes[i*SIZE_M+8*(ii-3)+j]=0;
29.03.2013 10:03-
Ділись своїми роботами та отримуй миттєві бонуси!
0%
Оголошення від адміністратора