C++ MPI帮助查找最多n个数字

我在使用MPI_Send和MPI_Recv计算数组大小的最大值时遇到问题。 我的逻辑是在主设备中生成数组大小的数字，并在主设备和从设备之间分割这些数字

我发现以下错误：

[compute-0-8:19284] *** Process received signal ***
[compute-0-8:19284] Signal: Segmentation fault (11)
[compute-0-8:19284] Signal code: Address not mapped (1)
[compute-0-8:19284] Failing at address: 0x2995ee4b50
[compute-0-8:19284] [ 0] /lib64/tls/libpthread.so.0 [0x3a2b50c320]
[compute-0-8:19284] [ 1] ./project/project.out(main+0x27c) [0x408b9e]
[compute-0-8:19284] [ 2] /lib64/tls/libc.so.6(__libc_start_main+0xdb) [0x3a2ac1c4bb]
[compute-0-8:19284] [ 3] ./project/project.out(__gxx_personality_v0+0x8a) [0x40877a]
[compute-0-8:19284] *** End of error message ***
mpirun noticed that job rank 0 with PID 19283 on node compute-0-8.local exited on signal 15 (Terminated). 

这是我的密码

#include "mpi.h" 
#include <stdio.h> 
#include <math.h> 
#include <stdlib.h> 

#define TRIALS 20 
// n = 10000, 100000, 1000000
#define ARRAY_SIZE 1000000 

int main(int argc, char *argv[]) 
{ 
    int myid, numprocs; 
    double startwtime, endwtime; 
    int namelen; 
    int* numbers = new int[ARRAY_SIZE]; 
    int i, j, max, part_max; 
    int slaveSize, masterSize, startIndex, endIndex; 
    double totalTime; 

    char processor_name[MPI_MAX_PROCESSOR_NAME]; 

    MPI_Init(&argc,&argv); 
    MPI_Comm_size(MPI_COMM_WORLD,&numprocs); 
    MPI_Comm_rank(MPI_COMM_WORLD,&myid); 
    MPI_Get_processor_name(processor_name,&namelen); 
    MPI_Status status;

    fprintf(stderr,"Process %d on %s\n", myid, processor_name); 
    fflush(stderr); 

    //check if master   
    if (myid == 0) 
    { 
        //master is generating data set of size n
        for (i=0; i < ARRAY_SIZE; i++) 
            numbers[i] = i;

        slaveSize = (int) floor(ARRAY_SIZE / numprocs); 
        masterSize = slaveSize + ARRAY_SIZE % numprocs; 
        //printf("slaveSize = %d , masterSize = %d\n", slaveSize, masterSize); 
    } 

    startIndex = masterSize + (myid - 1) * slaveSize; 
    endIndex = startIndex + slaveSize; 

    if (myid != 0)
    {
        for (int i = 1; i < numprocs; i++)
            MPI_Send(&numbers,1,MPI_INT,i,10,MPI_COMM_WORLD);
    }
    else
    {
        MPI_Recv(&numbers,1,MPI_INT,0,10,MPI_COMM_WORLD,&status);
    }

    totalTime = 0; 

    //trials
    for (j = 1; j <= TRIALS; j++) 
    { 
        if (myid == 0) 
        { 
            startwtime = MPI_Wtime(); 
        } 

        max = 0; 
        part_max = numbers[0]; 


        //CALCULATE THE MAX

        if (myid == 0) // master 
        { 
            // compute max of master's numbers 
            for (i = 1; i < masterSize; i++) 
            { 
                if (part_max < numbers[i])
                    part_max = numbers[i]; 
            } 
        } 
        else 
        { 
            for (i = startIndex; i < endIndex; i++) 
            { 
                if (part_max < numbers[i])
                    part_max = numbers[i]; 
            } 
        } 

        if (myid == 0)
        {
            for (int i = 1; i < numprocs; i++)
                MPI_Recv(&part_max,1,MPI_INT,i,11,MPI_COMM_WORLD,&status);
        }
        else
        {
            MPI_Send(&max,1,MPI_INT,0,11,MPI_COMM_WORLD);
        }

        if (myid == 0) 
        { 
            double runTime; 
            endwtime = MPI_Wtime(); 
            runTime = endwtime - startwtime; 

            printf("Trial %d : Execution time (sec) = %f\n", j, runTime); 
            printf("Max = %d \n", max); 
            totalTime += runTime; 
        } 
    } // end for 
    if (myid == 0) 
        printf("Average time for %d trials = %f", TRIALS, totalTime/TRIALS); 

    MPI_Finalize(); 
}

#包括“mpi.h”
#包括
#包括
#包括
#定义试验20
//n=10000，100000，1000000
#定义数组大小1000000
int main（int argc，char*argv[]）
{ 
int myid，numprocs；
双开始时间，结束时间；
int namelen；
整数*数字=新整数[数组大小]；
int i，j，max，part_max；
int slaveSize、masterSize、startIndex、endIndex；
双倍总时间；
字符处理器名称[最大处理器名称]；
MPI_Init（&argc，&argv）；
MPI通信大小（MPI通信世界和numprocs）；
MPI通信等级（MPI通信世界和myid）；
MPI获取处理器名称（处理器名称和名称）；
MPI_状态；
fprintf（标准，“进程%d在%s\n上”，myid，处理器名称）；
fflush（stderr）；
//检查主机是否正常工作
如果（myid==0）
{ 
//master正在生成大小为n的数据集
对于（i=0；i对于（j=1；j无法判断这是否是唯一的问题，但您只是在主线程中初始化
slaveSize
和
masterSize
。在从属线程中，
startIndex
和
endIndex
是未定义的，因为您是从未初始化的大小计算它们的。（除非这些堆栈变量以某种方式共享，但这样就得到了一个普通的旧竞争条件。）

您的
Send
和
Recv
看起来也不平衡。第一次
MPI\u发送将被调用
（numprocs-1）²
次，但只有一个
MPI\u Recv
与之匹配？
无法判断这是否是唯一的问题，但您只是在主线程中初始化
slaveSize
和
masterSize
。在从属线程中，
startIndex
和
endIndex
是未定义的，因为您是从这些大小计算它们的ch是未初始化的（除非这些堆栈变量以某种方式共享，但这样就得到了一个普通的旧竞争条件）

你的
Send
和
Recv
看起来也不是很平衡。第一次
MPI\u Send
会被调用
（numprocs-1）次，但只有一次
MPI\u Recv
来匹配它？
马特说了什么；这段代码有太多错误

为什么阵列在所有处理器上都是全尺寸的？究竟是什么
您使用MPI_Send/Recv for？在根目录上有一个大数组，在其他地方有一个小数组，
使用MPI_散布分布大数组，在本地计算最大值，并执行MPI_减少（…MPI_max…）
如Mat所说；此代码有太多错误

为什么阵列在所有处理器上都是全尺寸的？究竟是什么
您使用MPI_Send/Recv for？在根目录上有一个大数组，在其他地方有一个小数组，
使用MPI_分散分布大阵列，在本地计算最大值，并执行MPI_减少（…MPI_最大值…）