C++ MPI_Barrier函数代码示例

OGeek|极客世界-中国程序员成长平台 › 门户 › 编程› C++›C++教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

本文整理汇总了C++中MPI_Barrier函数的典型用法代码示例。如果您正苦于以下问题：C++ MPI_Barrier函数的具体用法？C++ MPI_Barrier怎么用？C++ MPI_Barrier使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。

在下文中一共展示了MPI_Barrier函数的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的C++代码示例。

示例1: main

int main( int argc, char *argv[] )
{
    int errs = 0;
    int *ranks;
    int *ranksout;
    MPI_Group gworld, grev, gself;
    MPI_Comm  comm;
    MPI_Comm  commrev;
    int rank, size, i;
    double start, end, time1, time2;

    MTest_Init( &argc, &argv );

    comm = MPI_COMM_WORLD;

    MPI_Comm_size( comm, &size );
    MPI_Comm_rank( comm, &rank );

    ranks    = malloc(size*sizeof(int));
    ranksout = malloc(size*sizeof(int));
    if (!ranks || !ranksout) {
        fprintf(stderr, "out of memory\n");
        MPI_Abort(MPI_COMM_WORLD, 1);
    }

    /* generate a comm with the rank order reversed */
    MPI_Comm_split(comm, 0, (size-rank-1), &commrev);
    MPI_Comm_group(commrev, &grev);
    MPI_Comm_group(MPI_COMM_SELF, &gself);
    MPI_Comm_group(comm, &gworld);

    /* sanity check correctness first */
    for (i=0; i < size; i++) {
        ranks[i] = i;
        ranksout[i] = -1;
    }
    MPI_Group_translate_ranks(grev, size, ranks, gworld, ranksout);
    for (i=0; i < size; i++) {
        if (ranksout[i] != (size-i-1)) {
            if (rank == 0)
                printf("%d: (gworld) expected ranksout[%d]=%d, got %d\n", rank, i, (size-rank-1), ranksout[i]);
            ++errs;
        }
    }
    MPI_Group_translate_ranks(grev, size, ranks, gself, ranksout);
    for (i=0; i < size; i++) {
        int expected = (i == (size-rank-1) ? 0 : MPI_UNDEFINED);
        if (ranksout[i] != expected) {
            if (rank == 0)
                printf("%d: (gself) expected ranksout[%d]=%d, got %d\n", rank, i, expected, ranksout[i]);
            ++errs;
        }
    }

    /* now compare relative performance */

    /* we needs lots of procs to get a group large enough to have meaningful
     * numbers.  On most testing machines this means that we're oversubscribing
     * cores in a big way, which might perturb the timing results.  So we make
     * sure everyone started up and then everyone but rank 0 goes to sleep to
     * let rank 0 do all the timings. */
    MPI_Barrier(comm);

    if (rank != 0) {
        sleep(10);
    }
    else /* rank==0 */ {
        sleep(1); /* try to avoid timing while everyone else is making syscalls */

        MPI_Group_translate_ranks(grev, size, ranks, gworld, ranksout); /*throwaway iter*/
        start = MPI_Wtime();
        for (i = 0; i < NUM_LOOPS; ++i) {
            MPI_Group_translate_ranks(grev, size, ranks, gworld, ranksout);
        }
        end = MPI_Wtime();
        time1 = end - start;

        MPI_Group_translate_ranks(grev, size, ranks, gself, ranksout); /*throwaway iter*/
        start = MPI_Wtime();
        for (i = 0; i < NUM_LOOPS; ++i) {
            MPI_Group_translate_ranks(grev, size, ranks, gself, ranksout);
        }
        end = MPI_Wtime();
        time2 = end - start;

        /* complain if the "gworld" time exceeds 2x the "gself" time */
        if (fabs(time1 - time2) > (2.00 * time2)) {
            printf("too much difference in MPI_Group_translate_ranks performance:\n");
            printf("time1=%f time2=%f\n", time1, time2);
            printf("(fabs(time1-time2)/time2)=%f\n", (fabs(time1-time2)/time2));
            if (time1 < time2) {
                printf("also, (time1<time2) is surprising...\n");
            }
            ++errs;
        }
    }

    free(ranks);
    free(ranksout);

//.........这里部分代码省略.........

开发者ID:OngOngoing，项目名称:219351_homework，代码行数:101，代码来源:gtranksperf.c

示例2: main

int main(int argc, char **argv)
{
    int np[2];
    ptrdiff_t n[4], ni[4], no[4];
    ptrdiff_t alloc_local_forw, alloc_local_back, alloc_local, howmany;
    ptrdiff_t local_ni[4], local_i_start[4];
    ptrdiff_t local_n[4], local_start[4];
    ptrdiff_t local_no[4], local_o_start[4];
    double err, *in;
    pfft_complex *out;
    pfft_plan plan_forw=NULL, plan_back=NULL;
    MPI_Comm comm_cart_2d;

    /* Set size of FFT and process mesh */
    ni[0] = ni[1] = ni[2] = ni[3] = 8;
    n[0] = 13;
    n[1] = 14;
    n[2] = 15;
    n[3] = 17;
    for(int t=0; t<4; t++)
        no[t] = ni[t];
    np[0] = 2;
    np[1] = 2;
    howmany = 1;

    /* Initialize MPI and PFFT */
    MPI_Init(&argc, &argv);
    pfft_init();

    /* Create two-dimensional process grid of size np[0] x np[1], if possible */
    if( pfft_create_procmesh_2d(MPI_COMM_WORLD, np[0], np[1], &comm_cart_2d) ) {
        pfft_fprintf(MPI_COMM_WORLD, stderr, "Error: This test file only works with %d processes.\n", np[0]*np[1]);
        MPI_Finalize();
        return 1;
    }

    /* Get parameters of data distribution */
    alloc_local_forw = pfft_local_size_many_dft_r2c(4, n, ni, n, howmany,
                       PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
                       comm_cart_2d, PFFT_TRANSPOSED_OUT,
                       local_ni, local_i_start, local_n, local_start);

    alloc_local_back = pfft_local_size_many_dft_c2r(4, n, n, no, howmany,
                       PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
                       comm_cart_2d, PFFT_TRANSPOSED_IN,
                       local_n, local_start, local_no, local_o_start);

    /* Allocate enough memory for both trafos */
    alloc_local = (alloc_local_forw > alloc_local_back) ?
                  alloc_local_forw : alloc_local_back;
    in  = pfft_alloc_real(2 * alloc_local);
    out = pfft_alloc_complex(alloc_local);

    /* Plan parallel forward FFT */
    plan_forw = pfft_plan_many_dft_r2c(
                    4, n, ni, n, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
                    in, out, comm_cart_2d, PFFT_FORWARD, PFFT_TRANSPOSED_OUT| PFFT_MEASURE| PFFT_DESTROY_INPUT);

    /* Plan parallel backward FFT */
    plan_back = pfft_plan_many_dft_c2r(
                    4, n, n, no, howmany, PFFT_DEFAULT_BLOCKS, PFFT_DEFAULT_BLOCKS,
                    out, in, comm_cart_2d, PFFT_BACKWARD, PFFT_TRANSPOSED_IN| PFFT_MEASURE| PFFT_DESTROY_INPUT);

    /* Initialize input with random numbers */
    pfft_init_input_real(4, ni, local_ni, local_i_start,
                         in);

    /* execute parallel forward FFT */
    pfft_execute(plan_forw);

    /* execute parallel backward FFT */
    pfft_execute(plan_back);

    /* Scale data */
    for(ptrdiff_t l=0; l < local_ni[0] * local_ni[1] * local_ni[2] * local_ni[3]; l++)
        in[l] /= (n[0]*n[1]*n[2]*n[3]);

    /* Print error of back transformed data */
    MPI_Barrier(MPI_COMM_WORLD);
    err = pfft_check_output_real(4, ni, local_ni, local_i_start, in, comm_cart_2d);
    pfft_printf(comm_cart_2d, "Error after one forward and backward trafo of size n=(%td, %td, %td, %td):\n", n[0], n[1], n[2], n[3]);
    pfft_printf(comm_cart_2d, "maxerror = %6.2e;\n", err);

    /* free mem and finalize */
    pfft_destroy_plan(plan_forw);
    pfft_destroy_plan(plan_back);
    MPI_Comm_free(&comm_cart_2d);
    pfft_free(in);
    pfft_free(out);
    MPI_Finalize();
    return 0;
}

开发者ID:v4m4，项目名称:pfft，代码行数:92，代码来源:simple_check_ousam_r2c_4d_transposed.c

示例3: main

int main (int argc, char *argv[])
{
    int numtasks, namelen, rank, dest = 1, tag = 111, source = 0, size, i, j;
    double start_time=0, elapsed_time=0, acum;
    double *outmsg, *inmsg;
    char hostname[256];
    MPI_Status status,status2;
    MPI_Request send_request,recv_request;
    
    if (argc < 2)
    {	printf("Usage: %s size [where size is the number elements (double) to send ]\n", argv[0]);
        return 0;
    }
    
    size = atoi(argv[1]);
    
    outmsg=(double*)malloc(sizeof(double)*size);
    if(outmsg==NULL)
    {
        printf("Unable to allocate memory\n");
        return;
    }
    inmsg=(double*)malloc(sizeof(double)*size);
    if(inmsg==NULL)
    {
        printf("Unable to allocate memory\n");
        return;
    }
    
    MPI_Init (&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &numtasks);   // get number of processes
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);       // get current process id
    MPI_Get_processor_name(hostname, &namelen); // get CPU name
    
    //Initialize the msg buffer to the rank id.
    for (i = 0; i < size; i++)
        outmsg[i] = rank;
    
    //Define as Source the left neighbour
    if (rank == 0)  source=numtasks-1;
    else            source=rank-1;
    //Define the destiny the rigth neighbour
    if(rank==numtasks-1) dest=0;
    else                 dest=rank+1;
    
    start_time = MPI_Wtime();
    acum=0;
    for (i=0; i<numtasks; i++) {
        if (rank==0) printf("it: %2d - Rank %d (%s) sending data (%g) to rank %d\n",i,rank, hostname, inmsg[0], dest);
        MPI_Isend(outmsg, size, MPI_DOUBLE, dest, tag,MPI_COMM_WORLD,&send_request);
        MPI_Recv (inmsg, size, MPI_DOUBLE, source, tag, MPI_COMM_WORLD,&status);
        acum = acum + inmsg[0];
        if (rank==0) printf("it: %2d - Rank %d received data (%g) from rank %d (acum=%g)\n",i,rank,outmsg[0],source,acum);
        MPI_Wait(&send_request, &status2);
        //Copy the inmsg to outmsg for the next iteration.
        for (j = 0; j < size; j++) outmsg[j] = inmsg[j];
    }

    MPI_Barrier(MPI_COMM_WORLD);
    elapsed_time = MPI_Wtime() - start_time;
    printf(" Rank %d: Elapsed time to send %6d double(s) across a ring made up by %2d (acum=%g) in %g ms\n", rank, size, numtasks, acum, elapsed_time*1e03);
    
    MPI_Finalize ();
}

开发者ID:jlerida，项目名称:hpc-course，代码行数:64，代码来源:mpi_nonblockingring.c

示例4: main

int main(int argc, char **argv) {
    int i, j, rank, nranks, peer, bufsize, errors;
    double  *win_buf, *src_buf, *dst_buf;
    MPI_Win buf_win;

    MTest_Init(&argc, &argv);

    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &nranks);

    bufsize = XDIM * YDIM * sizeof(double);
    MPI_Alloc_mem(bufsize, MPI_INFO_NULL, &win_buf);
    /* Alloc_mem is not required for the origin buffers for RMA operations - 
       just for the Win_create memory */
    MPI_Alloc_mem(bufsize, MPI_INFO_NULL, &src_buf);
    MPI_Alloc_mem(bufsize, MPI_INFO_NULL, &dst_buf);

    if (rank == 0)
        if (verbose) printf("MPI RMA Strided Put Test:\n");

    for (i = 0; i < XDIM*YDIM; i++) {
        *(win_buf  + i) = 1.0 + rank;
        *(src_buf + i) = 1.0 + rank;
    }

    MPI_Win_create(win_buf, bufsize, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &buf_win);

    peer = (rank+1) % nranks;

    /* Perform ITERATIONS strided put operations */

    for (i = 0; i < ITERATIONS; i++) {
      MPI_Aint idx_loc[SUB_YDIM];
      int idx_rem[SUB_YDIM];
      int blk_len[SUB_YDIM];
      MPI_Datatype src_type, dst_type;

      void *base_ptr = dst_buf;
      MPI_Aint base_int;

      MPI_Get_address(base_ptr, &base_int);

      if (rank == 0)
        if (verbose) printf(" + iteration %d\n", i);

      for (j = 0; j < SUB_YDIM; j++) {
        MPI_Get_address(&src_buf[j*XDIM], &idx_loc[j]);
        idx_loc[j] = idx_loc[j] - base_int;
        idx_rem[j] = j*XDIM*sizeof(double);
        blk_len[j] = SUB_XDIM*sizeof(double);
      }

      MPI_Type_create_hindexed(SUB_YDIM, blk_len, idx_loc, MPI_BYTE, &src_type);
      MPI_Type_create_indexed_block(SUB_YDIM, SUB_XDIM*sizeof(double), idx_rem, MPI_BYTE, &dst_type);

      MPI_Type_commit(&src_type);
      MPI_Type_commit(&dst_type);

      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, peer, 0, buf_win);
      MPI_Put(base_ptr, 1, src_type, peer, 0, 1, dst_type, buf_win);
      MPI_Win_unlock(peer, buf_win);

      MPI_Type_free(&src_type);
      MPI_Type_free(&dst_type);
    }

    MPI_Barrier(MPI_COMM_WORLD);

    /* Verify that the results are correct */

    MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, buf_win);
    errors = 0;
    for (i = 0; i < SUB_XDIM; i++) {
      for (j = 0; j < SUB_YDIM; j++) {
        const double actual   = *(win_buf + i + j*XDIM);
        const double expected = (1.0 + ((rank+nranks-1)%nranks));
        if (actual - expected > 1e-10) {
          SQUELCH( printf("%d: Data validation failed at [%d, %d] expected=%f actual=%f\n",
              rank, j, i, expected, actual); );
          errors++;
          fflush(stdout);
        }
      }

开发者ID:jimmycao，项目名称:mpi-test，代码行数:83，代码来源:put_base.c

示例5: MPI_Barrier

void FieldStatic::finalize() {
    MPI_Barrier(MPI_COMM_WORLD);
}

开发者ID:bamx23，项目名称:diploma，代码行数:3，代码来源:field-static.cpp

示例6: MPI_Recv

double timeStepper::computeDt(int &numReads, int &numWrites)
{
  // Time step control
  array minSpeedTemp,maxSpeedTemp;
  array minSpeed,maxSpeed;
  elemOld->computeMinMaxCharSpeeds(directions::X1,
                                   minSpeedTemp, maxSpeedTemp,
                                   numReads,numWrites
                                  );
  minSpeedTemp = minSpeedTemp/XCoords->dX1;
  maxSpeedTemp = maxSpeedTemp/XCoords->dX1;
  maxSpeed     = af::max(maxSpeedTemp,af::abs(minSpeedTemp));

  if(params::dim>1)
  {
    elemOld->computeMinMaxCharSpeeds(directions::X2,
                                     minSpeedTemp, maxSpeedTemp,
                                     numReads,numWrites
                                    );
    minSpeedTemp = minSpeedTemp/XCoords->dX2;
    maxSpeedTemp = maxSpeedTemp/XCoords->dX2;
    maxSpeed    += af::max(maxSpeedTemp,af::abs(minSpeedTemp));
  }

  if(params::dim>2)
  {
    elemOld->computeMinMaxCharSpeeds(directions::X3,
                                     minSpeedTemp, maxSpeedTemp,
                                     numReads,numWrites);
    minSpeedTemp = minSpeedTemp/XCoords->dX3;
    maxSpeedTemp = maxSpeedTemp/XCoords->dX3;
    maxSpeed    += af::max(maxSpeedTemp,af::abs(minSpeedTemp));
  }
  array maxInvDt_af = af::max(af::max(af::max(maxSpeed,2),1),0);
  double maxInvDt = maxInvDt_af.host<double>()[0];

  /* Use MPI to find minimum over all processors */
  if (world_rank == 0) 
  {
    double temp; 
    for(int i=1;i<world_size;i++)
    {
      MPI_Recv(&temp, 1, MPI_DOUBLE, i, i, PETSC_COMM_WORLD,MPI_STATUS_IGNORE);
      if( maxInvDt < temp)
      {
        maxInvDt = temp;
      }
    }
  }
  else
  {
    MPI_Send(&maxInvDt, 1, MPI_DOUBLE, 0, world_rank, PETSC_COMM_WORLD);
  }
  MPI_Barrier(PETSC_COMM_WORLD);
  MPI_Bcast(&maxInvDt,1,MPI_DOUBLE,0,PETSC_COMM_WORLD);
  MPI_Barrier(PETSC_COMM_WORLD);
  
  double newDt = params::CourantFactor/maxInvDt;
    
  if (newDt > params::maxDtIncrement*dt)
  {
    newDt = params::maxDtIncrement*dt;
  }
  dt = newDt;
}

开发者ID:AFD-Illinois，项目名称:grim，代码行数:65，代码来源:timestep.cpp