rкод не првильно считает время выполнения программы, то есть при увеличении поток время должно уменьшатся, а в данном коде наоборо
#include <mpi.h>
#include <iostream>
#include <vector>
#include <random>
#include <locale>
#include <chrono>  // Для std::chrono

// Функция для генерации случайной матрицы
void generate_matrix(std::vector<double>& matrix, int rows, int cols) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(0, 10);
    for (int i = 0; i < rows * cols; ++i) {
        matrix[i] = dis(gen);
    }
}

// Функция для генерации случайного вектора
void generate_vector(std::vector<double>& vec, int size) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(0, 10);
    for (int i = 0; i < size; ++i) {
        vec[i] = dis(gen);
    }
}

int main(int argc, char** argv) {
    setlocale(0, "rus");
    MPI_Init(&argc, &argv);

    int rank, size;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);

    // Увеличиваем размерность задачи
    int N = 8; // Размерность матрицы N x N (можно изменять для тестов)
    bool debug = false; // Флаг для отладки (заполнение единицами)
    
    if (argc > 1) {
        N = atoi(argv[1]); // Получение размера матрицы из аргументов командной строки
    }

    if (argc > 2 && std::string(argv[2]) == "debug") {
        debug = true; // Включаем отладку, если передан параметр "debug"
    }

    const int block_size = N / size; // Размер блока для каждого процесса

    std::vector<double> matrix;
    std::vector<double> vector(N);
    std::vector<double> local_matrix(block_size * N);
    std::vector<double> local_result(block_size, 0);
    std::vector<double> result(N, 0);

    if (rank == 0) {
        // Генерация данных в процессе 0
        matrix.resize(N * N);
        
        if (debug) {
            // Заполнение матрицы и вектора единицами для отладки
            std::fill(matrix.begin(), matrix.end(), 1.0);
            std::fill(vector.begin(), vector.end(), 1.0);
        } else {
            // Генерация случайных данных
            generate_matrix(matrix, N, N);
            generate_vector(vector, N);
        }

        // Для отладки: вывод матрицы и вектора
        std::cout << "Matrix:" << std::endl;
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                std::cout << matrix[i * N + j] << " ";
            }
            std::cout << std::endl;
        }
        std::cout << "Vector:" << std::endl;
        for (double val : vector) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }

    // Создание производного типа данных для строки матрицы
    MPI_Datatype row_type;
    MPI_Type_contiguous(N, MPI_DOUBLE, &row_type);
    MPI_Type_commit(&row_type);

    // Начало замера времени
    auto start_time = std::chrono::high_resolution_clock::now();

    // Рассылка строк матрицы
    MPI_Scatter(matrix.data(), block_size, row_type, local_matrix.data(), block_size * N, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // Рассылка вектора
    MPI_Bcast(vector.data(), N, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // Локальное умножение
    for (int i = 0; i < block_size; ++i) {
        for (int j = 0; j < N; ++j) {
            local_result[i] += local_matrix[i * N + j] * vector[j];
        }
    }

    // Сбор результатов
    MPI_Gather(local_result.data(), block_size, MPI_DOUBLE, result.data(), block_size, MPI_DOUBLE, 0, MPI_COMM_WORLD);

    // Окончание замера времени
    auto end_time = std::chrono::high_resolution_clock::now();

    if (rank == 0) {
        std::cout << "Result: " << std::endl;
        for (double val : result) {
            std::cout << val << " ";
        }
        std::cout << std::endl;

        // Вывод времени в миллисекундах
        std::chrono::duration<double> elapsed_time = end_time - start_time;
        std::cout << "Running time: " << elapsed_time.count() * 1000 << " milliseconds" << std::endl;
    }

    MPI_Type_free(&row_type);
    MPI_Finalize();
    return 0;
}