zhirnova_alyona_lab_5

zhirnova_alyona_lab_5/README.md

@@ -0,0 +1,29 @@
+# Лабораторная работа №5 - Работа с брокером сообщений
+
+### Задачи 
+1. Кратко: реализовать умножение двух больших квадратных матриц.
+2. Подробно: сделать два алгоритма: обычный и параллельный (задание со * - реализовать это в рамках одного алгоритма). В параллельном алгоритме предусмотреть ручное задание количества потоков (число потоков = 1 как раз и реализует задание со *), каждый из которых будет выполнять умножение элементов матрицы в рамках своей зоны ответственности.
+
+## Скриншот работы программы:
+![1.png](screenshots/1.png)    
+
+## Описание программы:
+1. Программа умножает две большие матрицы и сравнивает скорость работы двух методов:
+* Обычный метод - работает в одном процессе
+* Параллельный метод - распределяет работу между несколькими процессами
+2. Запускает benchmark для квадратных матриц размером 100, 300 и 500.
+
+## Запуск:
+1. Скачайте папку с репозитория
+2. Запустите с помощью команды:
+`python matrix_multiply.py`
+3. Ознакомьтесь с результатом работы программы
+
+## Что делает данная лабораторная работа:
+Программа реализует умножение больших квадратных матриц двумя способами: последовательным алгоритмом и параллельным алгоритмом с использованием многопроцессорности. Программа включает функционал для benchmarking производительности на матрицах различных размеров.
+
+## Вывод
+Программа демонстрирует эффективность параллельных вычислений для задач с большой вычислительной сложностью, показывая как размер задачи влияет на эффективность распараллеливания. 
+
+## Видео:
+https://rutube.ru/video/private/8d58707b8ad7b09a214ebfb9a889394c/?p=HhCOysJT6AyC83xhdZ49pQ

zhirnova_alyona_lab_5/matrix_multiply.py

@@ -0,0 +1,69 @@
+import multiprocessing as mp
+import time
+import random
+
+def matrix_multiply_sequential(A, B):
+    n = len(A)
+    C = [[0] * n for _ in range(n)]
+    for i in range(n):
+        for k in range(n):
+            for j in range(n):
+                C[i][j] += A[i][k] * B[k][j]
+    return C
+
+def multiply_chunk(args):
+    start, end, A, B = args
+    n = len(B)
+    C_part = [[0] * n for _ in range(end - start)]
+    for i in range(start, end):
+        for k in range(n):
+            for j in range(n):
+                C_part[i - start][j] += A[i][k] * B[k][j]
+    return (start, end, C_part)
+
+def matrix_multiply_parallel(A, B, processes=1):
+    n = len(A)
+    if processes == 1:
+        return matrix_multiply_sequential(A, B)
+    
+    chunk_size = n // processes
+    chunks = []
+    for i in range(processes):
+        start = i * chunk_size
+        end = n if i == processes - 1 else (i + 1) * chunk_size
+        chunks.append((start, end, A, B))
+    
+    with mp.Pool(processes=processes) as pool:
+        results = pool.map(multiply_chunk, chunks)
+    
+    C = [[0] * n for _ in range(n)]
+    for start, end, C_part in results:
+        for i in range(start, end):
+            C[i] = C_part[i - start]
+    return C
+
+def generate_matrix(n):
+    return [[random.randint(1, 100) for _ in range(n)] for _ in range(n)]
+
+if __name__ == '__main__':
+    sizes = [100, 300, 500]
+    processes_list = [1, 2, 4, 8]
+    
+    for size in sizes:
+        A = generate_matrix(size)
+        B = generate_matrix(size)
+        print(f"\nРазмер матрицы: {size}x{size}")
+        
+        # Последовательная версия
+        start_time = time.time()
+        matrix_multiply_sequential(A, B)
+        seq_time = time.time() - start_time
+        print(f"Последовательный алгоритм: {seq_time:.4f} сек")
+        
+        # Параллельные версии
+        for processes in processes_list:
+            start_time = time.time()
+            matrix_multiply_parallel(A, B, processes)
+            par_time = time.time() - start_time
+            speedup = seq_time / par_time
+            print(f"Параллельный (процессы: {processes}): {par_time:.4f} сек (ускорение: {speedup:.2f}x)")