kamyshov_danila_lab_5/README.md

@@ -0,0 +1,32 @@
+# Лабораторная работа №5 - Вспоминаем математику или параллельное перемножение матриц
+
+Задание:
+
+Кратко: реализовать умножение двух больших квадратных матриц.
+
+Подробно: в лабораторной работе требуется сделать два алгоритма: обычный и параллельный (задание со * - реализовать это в рамках одного алгоритма). В параллельном алгоритме предусмотреть ручное задание количества потоков (число потоков = 1 как раз и реализует задание со *), каждый из которых будет выполнять умножение элементов матрицы в рамках своей зоны ответственности.
+
+Сделать несколько бенчмарков последовательного и параллельного алгоритма на умножение двух матриц размером 100x100, 300x300, 500x500 элементов.
+
+<p>
+    <div>Код</div>
+    <img src="screens/img1.png" width="650" title="Код">
+</p>
+<p>
+    <div>Код</div>
+    <img src="screens/img2.png" width="650" title="Код">
+</p>
+<p>
+    <div>Код</div>
+    <img src="screens/img3.png" width="650" title="Код">
+</p>
+<p>
+    <div>Работа программы</div>
+    <img src="screens/img4.png" width="650" title="Работа программы">
+</p>
+
+Вывод: Параллельный алгоритм в условии данной задачи не имеет смысла использовать
+
+# Видео
+
+Видео с разбором лабораторной работы - https://drive.google.com/file/d/1Utik4HitmCrlgQ_1WLUZL2Rvek9uGVnR/view?usp=sharing

kamyshov_danila_lab_5/src/main/java/org/example/MatrixMultiplication.java

@@ -0,0 +1,100 @@
+package org.example;
+
+import java.util.Random;
+import java.util.Scanner;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class MatrixMultiplication {
+
+    public static int[][] sequentialMatrixMultiply(int[][] matrixA, int[][] matrixB) {
+        int rowsA = matrixA.length;
+        int colsA = matrixA[0].length;
+        int colsB = matrixB[0].length;
+
+        int[][] result = new int[rowsA][colsB];
+
+        for (int i = 0; i < rowsA; i++) {
+            for (int j = 0; j < colsB; j++) {
+                for (int k = 0; k < colsA; k++) {
+                    result[i][j] += matrixA[i][k] * matrixB[k][j];
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public static int[][] parallelMatrixMultiply(int[][] matrixA, int[][] matrixB, int numThreads) throws InterruptedException {
+        int rowsA = matrixA.length;
+        int colsA = matrixA[0].length;
+        int colsB = matrixB[0].length;
+
+        int[][] result = new int[rowsA][colsB];
+
+        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
+        int chunkSize = rowsA / numThreads;
+
+        for (int i = 0; i < numThreads; i++) {
+            int startRow = i * chunkSize;
+            int endRow = (i + 1) * chunkSize;
+
+            executor.submit(() -> {
+                for (int row = startRow; row < endRow; row++) {
+                    for (int col = 0; col < colsB; col++) {
+                        for (int k = 0; k < colsA; k++) {
+                            result[row][col] += matrixA[row][k] * matrixB[k][col];
+                        }
+                    }
+                }
+            });
+        }
+
+        executor.shutdown();
+        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        int[] matrixSizes = {100, 300, 500};
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.print("Введите количество потоков: ");
+        int numThreads = scanner.nextInt();
+
+        Random random = new Random();
+
+        for (int size : matrixSizes) {
+            int[][] matrixA = new int[size][size];
+            int[][] matrixB = new int[size][size];
+
+            for (int i = 0; i < size; i++) {
+                for (int j = 0; j < size; j++) {
+                    matrixA[i][j] = random.nextInt(10);
+                    matrixB[i][j] = random.nextInt(10);
+                }
+            }
+
+            long startTime = System.currentTimeMillis();
+            int[][] sequentialResult = sequentialMatrixMultiply(matrixA, matrixB);
+            long sequentialTime = System.currentTimeMillis() - startTime;
+
+            startTime = System.currentTimeMillis();
+            try {
+                int[][] parallelResult = parallelMatrixMultiply(matrixA, matrixB, numThreads);
+                long parallelTime = System.currentTimeMillis() - startTime;
+
+                System.out.println("Matrix size: " + size + "x" + size);
+                System.out.println("Sequential algorithm time: " + sequentialTime + " milliseconds");
+                System.out.println("Parallel algorithm time (" + numThreads + " threads): " + parallelTime + " milliseconds");
+                System.out.println("=============================");
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+        scanner.close();
+    }
+}