Коллективные операции передачи данных

#include <iostream>
#include <mpi.h>
#include <limits.h>
 
using namespace std;
 
int main(int argc, char* argv[]) {
    setlocale(LC_ALL, "Russian");
 
    MPI_Init(&argc, &argv);
 
    int size, rank;
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 
    if (size <= 1) {
        cout << "Количество процессов должно быть больше 1." << endl;
        MPI_Finalize();
        return 1;
    }
 
    int* matrix = nullptr;
    int M = 0, N = 0;
    int local_rows = 0, remainder_rows=0;
    int* local_matrix = nullptr;
 
    if (rank == 0) {
        cout << "Enter the number of rows (M): ";
        cin >> M;
        cout << "Enter the number of columns (N): ";
        cin >> N;
 
        if (M < size) {
            cout << "M should be greater than or equal to the number of processes." << endl;
            MPI_Finalize();
            return 1;
        }
 
        matrix = (int*)malloc(M * N * sizeof(int));
        if (matrix == nullptr) {
            cout << "Ошибка выделения памяти." << endl;
            MPI_Finalize();
            return 1;
        }
 
        // Инициализация матрицы
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                matrix[i * N + j] = rand() % 10;  // Пример заполнения случайными числами от 0 до 9
                cout << matrix[i * N + j] << " ";
            }
            cout << endl;
        }
 
        int kolPskaliar = size;
        local_rows = M / kolPskaliar;
        
    }
 
    // Широковещательная рассылка размеров матрицы от процесса 0 ко всем остальным
    MPI_Bcast(&M, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&local_rows, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
    
    local_matrix = (int*)malloc(local_rows * N * sizeof(int));
 
    // Используем MPI_Scatter для равномерного распределения строк по процессам
    MPI_Scatter(matrix, local_rows * N, MPI_INT, local_matrix, local_rows * N, MPI_INT, 0, MPI_COMM_WORLD);
 
 
    if ((rank == size - 1)) {
        remainder_rows = (M % (size * local_rows));
        local_rows += remainder_rows;
        cout << "Last process (rank " << rank << ") receives additional rows: " << remainder_rows << endl;
 
    }
 
 
 
 
    // Вывод локальной матрицы
    cout << "Prots " << rank << ". Local matrix:" << endl;
    for (int i = 0; i < local_rows; i++) {
        for (int j = 0; j < N; j++) {
            cout << local_matrix[i * N + j] << " ";
        }
        cout << endl;
    }
 
    // Редукция для нахождения минимальной суммы среди всех процессов
    int local_min_sum = INT_MAX;
    for (int i = 0; i < local_rows; i++) {
        int row_sum = 0;
        for (int j = 0; j < N; j++) {
            row_sum += local_matrix[i * N + j];
        }
        if (row_sum < local_min_sum) {
            local_min_sum = row_sum;
        }
    }
 
    // Сбор результатов
    int* all_min_sums = nullptr;
    if (rank == 0) {
        all_min_sums = (int*)malloc(size * sizeof(int));
        if (all_min_sums == nullptr) {
            cout << "Ошибка выделения памяти." << endl;
            MPI_Finalize();
            return 1;
        }
 
    }
 
    MPI_Gather(&local_min_sum, 1, MPI_INT, all_min_sums, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
    // Вывод минимальной суммы среди всех процессов
    if (rank == 0) {
        int global_min_sum = INT_MAX;
        for (int i = 0; i < size; i++) {
            if (all_min_sums[i] < global_min_sum) {
                global_min_sum = all_min_sums[i];
            }
        }
        cout << "\n min S : " << global_min_sum << endl;
 
        free(all_min_sums);
        free(matrix);
    }
 
    free(local_matrix);
    MPI_Finalize();
 
    return 0;
}