pair.c

mpi 结合vc编程用模拟退火法算一个最小路径的值

    rbuffer = (char *)malloc((unsigned)(alloc_len));
#endif
    if (!sbuffer || !rbuffer) {
	fprintf( stderr, "Could not allocate %d bytes\n", alloc_len );
	exit(1 );
    }
    memset( sbuffer, 0, alloc_len );
    memset( rbuffer, 0, alloc_len );

    MPI_Win_create( rbuffer, len, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win );

    SetupTest( from );
    ConfirmTest( reps, len, ctx );
    elapsed_time = 0;
    if(ctx->is_master){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,0,MPI_COMM_WORLD,&status);
	t0=MPI_Wtime();
	for(i=0;i<reps;i++){
	    MPI_Put( sbuffer, len, MPI_BYTE, to, 
		     0, len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	}
	t1=MPI_Wtime();
	elapsed_time = t1 -t0;
    }

    else if(ctx->is_slave){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Send(sbuffer,len,MPI_BYTE,from,0,MPI_COMM_WORLD);
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Put( sbuffer, len, MPI_BYTE, from, 
		     0, len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	}
    }
    else {
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	}
    }

    FinishTest();
    MPI_Win_free( &win );
#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    shfree( sbuffer );
    shfree( rbuffer );
#else
    free(sbuffer );
    free(rbuffer );
#endif
    return(elapsed_time);
}

double round_trip_nc_put( int reps, int len, PairData ctx)
{
    double elapsed_time;
    int  i, to = ctx->destination, from = ctx->source;
    int  recv_from;
    char *rbuffer,*sbuffer, *rp, *sp, *rlast, *slast;
    double t0, t1;
    MPI_Win win;
    MPI_Status status;

#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    sbuffer = (char *)shmalloc((unsigned)(2 * CacheSize ));
    rbuffer = (char *)shmalloc((unsigned)(2 * CacheSize ));
#else
    sbuffer = (char *)malloc((unsigned)(2 * CacheSize ));
    rbuffer = (char *)malloc((unsigned)(2 * CacheSize ));
#endif
    slast   = sbuffer + 2 * CacheSize - len;
    rlast   = rbuffer + 2 * CacheSize - len;
    if (!sbuffer || !rbuffer) {
	fprintf( stderr, "Could not allocate %d bytes\n", 4 * CacheSize );
	exit(1 );
    }
    sp = sbuffer;
    rp = rbuffer;
    memset( sbuffer, 0, 2*CacheSize );
    memset( rbuffer, 0, 2*CacheSize );

    MPI_Win_create( rbuffer, len, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win );

    SetupTest( from );
    ConfirmTest( reps, len, ctx );
    elapsed_time = 0;
    if(ctx->is_master){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,0,MPI_COMM_WORLD,&status);
	t0=MPI_Wtime();
	for(i=0;i<reps;i++){
	    MPI_Put( sp, len, MPI_BYTE, to, 
		     (int)(rp - rbuffer), len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	    sp += len;
	    rp += len;
	    if (sp > slast) sp = sbuffer;
	    if (rp > rlast) rp = rbuffer;
	}
	t1=MPI_Wtime();
	elapsed_time = t1 -t0;
    }

    else if(ctx->is_slave){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Send(sbuffer,len,MPI_BYTE,from,0,MPI_COMM_WORLD);
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Put( sp, len, MPI_BYTE, from, 
		     (int)(rp - rbuffer), len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	    sp += len;
	    rp += len;
	    if (sp > slast) sp = sbuffer;
	    if (rp > rlast) rp = rbuffer;
	}
    }
    else {
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	}
    }

    FinishTest();
    MPI_Win_free( &win );
#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    shfree( sbuffer );
    shfree( rbuffer );
#else
    free(sbuffer );
    free(rbuffer );
#endif
    return(elapsed_time);
}
#endif

#ifdef HAVE_MPI_GET
double exchange_get( int reps, int len, PairData ctx)
{
    double elapsed_time;
    int  i, to = ctx->destination, from = ctx->source;
    int  recv_from;
    char *sbuffer,*rbuffer;
    double t0, t1;
    MPI_Status status;
    MPI_Win    win;
    int        alloc_len;
  
    alloc_len = len;
    if (alloc_len == 0) alloc_len = sizeof(double);

#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    sbuffer = (char *)shmalloc((unsigned)(alloc_len));
    rbuffer = (char *)shmalloc((unsigned)(alloc_len));
#else
    sbuffer = (char *)malloc((unsigned)(alloc_len));
    rbuffer = (char *)malloc((unsigned)(alloc_len));
#endif
    if (!sbuffer || !rbuffer) {
	fprintf( stderr, "Could not allocate %d bytes\n", alloc_len );
	exit(1 );
    }
    memset( sbuffer, 0, alloc_len );
    memset( rbuffer, 0, alloc_len );

    MPI_Win_create( rbuffer, len, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win );

    SetupTest( from );
    ConfirmTest( reps, len, ctx );

    elapsed_time = 0;
    if(ctx->is_master){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,0,MPI_COMM_WORLD,&status);
	t0=MPI_Wtime();
	for(i=0;i<reps;i++){
	    MPI_Get( rbuffer, len, MPI_BYTE, to, 
		     0, len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	}
	t1 = MPI_Wtime();
	elapsed_time = t1-t0;
    }
    else if(ctx->is_slave){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Send(sbuffer,len,MPI_BYTE,from,0,MPI_COMM_WORLD);
	for(i=0;i<reps;i++){
	    MPI_Get( rbuffer, len, MPI_BYTE, from, 
		     0, len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	}
    }
    else {
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	}
    }

    FinishTest();
    MPI_Win_free( &win );
#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    shfree( sbuffer );
    shfree( rbuffer );
#else
    free(sbuffer );
    free(rbuffer );
#endif
    return(elapsed_time);
}
double round_trip_get( int reps, int len, PairData ctx)
{
    double elapsed_time;
    int  i, to = ctx->destination, from = ctx->source;
    int  recv_from;
    char *rbuffer,*sbuffer;
    double t0, t1;
    MPI_Win win;
    MPI_Status status;
    int alloc_len;

    alloc_len = len;
    if (alloc_len == 0) alloc_len = sizeof(double);

#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    sbuffer = (char *)shmalloc((unsigned)(alloc_len));
    rbuffer = (char *)shmalloc((unsigned)(alloc_len));
#else
    sbuffer = (char *)malloc((unsigned)(alloc_len));
    rbuffer = (char *)malloc((unsigned)(alloc_len));
#endif
    if (!sbuffer || !rbuffer) {
	fprintf( stderr, "Could not allocate %d bytes\n", alloc_len );
	exit(1 );
    }
    memset( sbuffer, 0, alloc_len );
    memset( rbuffer, 0, alloc_len );

    MPI_Win_create( rbuffer, len, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win );

    SetupTest( from );
    ConfirmTest( reps, len, ctx );
    elapsed_time = 0;
    if(ctx->is_master){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,0,MPI_COMM_WORLD,&status);
	t0=MPI_Wtime();
	for(i=0;i<reps;i++){
	    MPI_Get( rbuffer, len, MPI_BYTE, to, 
		     0, len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	}
	t1=MPI_Wtime();
	elapsed_time = t1 -t0;
    }

    else if(ctx->is_slave){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Send(sbuffer,len,MPI_BYTE,from,0,MPI_COMM_WORLD);
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Get( rbuffer, len, MPI_BYTE, from, 
		     0, len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	}
    }
    else {
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	}
    }

    FinishTest();
    MPI_Win_free( &win );
#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    shfree( sbuffer );
    shfree( rbuffer );
#else
    free(sbuffer );
    free(rbuffer );
#endif
    return(elapsed_time);
}

double round_trip_nc_get( int reps, int len, PairData ctx)
{
    double elapsed_time;
    int  i, to = ctx->destination, from = ctx->source;
    int  recv_from;
    char *rbuffer,*sbuffer, *rp, *sp, *rlast, *slast;
    double t0, t1;
    MPI_Win win;
    MPI_Status status;

#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    sbuffer = (char *)shmalloc((unsigned)(2 * CacheSize ));
    rbuffer = (char *)shmalloc((unsigned)(2 * CacheSize ));
#else
    sbuffer = (char *)malloc((unsigned)(2 * CacheSize ));
    rbuffer = (char *)malloc((unsigned)(2 * CacheSize ));
#endif
    slast   = sbuffer + 2 * CacheSize - len;
    rlast   = rbuffer + 2 * CacheSize - len;
    if (!sbuffer || !rbuffer) {
	fprintf( stderr, "Could not allocate %d bytes\n", 4 * CacheSize );
	exit(1 );
    }
    sp = sbuffer;
    rp = rbuffer;
    memset( sbuffer, 0, 2*CacheSize );
    memset( rbuffer, 0, 2*CacheSize );

    MPI_Win_create( rbuffer, len, 1, MPI_INFO_NULL, MPI_COMM_WORLD, &win );

    SetupTest( from );
    ConfirmTest( reps, len, ctx );
    elapsed_time = 0;
    if(ctx->is_master){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Recv(rbuffer,len,MPI_BYTE,recv_from,0,MPI_COMM_WORLD,&status);
	t0=MPI_Wtime();
	for(i=0;i<reps;i++){
	    MPI_Get( rp, len, MPI_BYTE, to, 
		     (int)(sp - sbuffer), len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	    sp += len;
	    rp += len;
	    if (sp > slast) sp = sbuffer;
	    if (rp > rlast) rp = rbuffer;
	}
	t1=MPI_Wtime();
	elapsed_time = t1 -t0;
    }

    else if(ctx->is_slave){
	recv_from = MPI_ANY_SOURCE;
	if (source_type == SpecifiedSource) recv_from = to;
	MPI_Send(sbuffer,len,MPI_BYTE,from,0,MPI_COMM_WORLD);
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Get( rp, len, MPI_BYTE, from, 
		     (int)(sp - sbuffer), len, MPI_BYTE, win );
	    MPI_Win_fence( 0, win );
	    sp += len;
	    rp += len;
	    if (sp > slast) sp = sbuffer;
	    if (rp > rlast) rp = rbuffer;
	}
    }
    else {
	for(i=0;i<reps;i++){
	    MPI_Win_fence( 0, win );
	    MPI_Win_fence( 0, win );
	}
    }

    FinishTest();
    MPI_Win_free( &win );
#if defined(HAVE_SHMALLOC) && !defined(HAVE_MPI_ALLOC_MEM)
    shfree( sbuffer );
    shfree( rbuffer );
#else
    free(sbuffer );
    free(rbuffer );
#endif
    return(elapsed_time);
}
#endif

/* 
   The following implements code to ensure that there is a pending receive
   that will never be satisfied
 */
#define NEVER_SENT_TAG  1000000000

static MPI_Request pending_req = MPI_REQUEST_NULL;
static void SetupTest( int from )
{
    static int dummy;
    if (MsgPending) {
	MPI_Irecv( &dummy, 1, MPI_INT, from, NEVER_SENT_TAG,
		   MPI_COMM_WORLD, &pending_req );
    }
}
static void FinishTest( void )
{
    if (MsgPending && pending_req != MPI_REQUEST_NULL) {
	MPI_Cancel( &pending_req );
	pending_req = MPI_REQUEST_NULL;
    }
}

/* 
   This routine confirms that all processes have consistent data.  If not,
   it generates an error message and invokes MPI_Abort
 */
void ConfirmTest( int reps, int len, PairData ctx )
{
    int msginfo[2], err=0;
    MPI_Status status;
    
    if (ctx->is_master) {
	MPI_Recv( msginfo, 2, MPI_INT, ctx->destination, 9999, 
		  MPI_COMM_WORLD, &status );
	if (msginfo[0] != reps) {
	    fprintf( stderr, "Expected %d but partner has %d for reps\n",
		     reps, msginfo[0] );
	    err++;
	}
	if (msginfo[1] != len) {
	    fprintf( stderr, "Expected %d but partner has %d for len\n",
		     len, msginfo[1] );
	    err++;
	}
	if (err) {
	    fflush( stderr );
	    MPI_Abort( MPI_COMM_WORLD, 1 );
	}
    }
    else if (ctx->is_slave) { 
	msginfo[0] = reps;
	msginfo[1] = len;
	MPI_Send( msginfo, 2, MPI_INT, ctx->source, 9999, MPI_COMM_WORLD );
    }
}