import numpy as np
import time
from concurrent.futures import ThreadPoolExecutor

def sequential_matrix_multiply(matrix_a, matrix_b):
    """Выполняет последовательное умножение матриц."""
    return np.dot(matrix_a, matrix_b)

def parallel_matrix_multiply(matrix_a, matrix_b, num_threads=1):
    """
    Выполняет параллельное умножение матриц с использованием заданного количества потоков.
    Каждый поток обрабатывает свою часть строк матрицы A.
    """
    result = np.zeros_like(matrix_a)
    rows, cols = matrix_a.shape
    chunk_size = rows // num_threads

    def multiply_chunk(start_row, end_row):
        """Умножение части матрицы A на матрицу B."""
        nonlocal result
        for i in range(start_row, end_row):
            result[i] = np.dot(matrix_a[i], matrix_b)

    with ThreadPoolExecutor(max_workers=num_threads) as executor:
        futures = []
        for i in range(0, rows, chunk_size):
            end_row = min(i + chunk_size, rows)
            futures.append(executor.submit(multiply_chunk, i, end_row))

        for future in futures:
            future.result()

    return result

def benchmark(matrix_size, num_threads=1):
    """
    Измеряет время выполнения последовательного и параллельного умножения матриц
    заданного размера с использованием заданного количества потоков.
    """
    matrix_a = np.random.randint(0, 10, size=(matrix_size, matrix_size))
    matrix_b = np.random.randint(0, 10, size=(matrix_size, matrix_size))

    # Замер времени для последовательного алгоритма
    start_time = time.time()
    sequential_result = sequential_matrix_multiply(matrix_a, matrix_b)
    sequential_time = time.time() - start_time

    # Замер времени для параллельного алгоритма
    start_time = time.time()
    parallel_result = parallel_matrix_multiply(matrix_a, matrix_b, num_threads)
    parallel_time = time.time() - start_time

    return sequential_time, parallel_time

if __name__ == "__main__":
    matrix_sizes = [100, 300, 500]
    num_threads = int(input("Введите количество потоков: "))

    for size in matrix_sizes:
        print(f"Matrix size: {size}x{size}")
        sequential_time, parallel_time = benchmark(size, num_threads)

        print(f"Sequential algorithm time: {sequential_time:.6f} seconds")
        print(f"Parallel algorithm time ({num_threads} threads): {parallel_time:.6f} seconds")

        print("="*30)