pm_genproc.c

mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环境

/*
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 */


#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#include <stdio.h>
#include "mpi.h"
#include "mpe.h"
#include "pmandel.h"

#ifndef DEBUG
#define DEBUG 0
#endif
#define DEBUG_POINTS 0

/* I used the line:
gcc -P -E pm_genproc.c | sed 's/{[ ]*{/{@{/' | tr "@" "\n" | indent -st > pm_genproc_cleanedup.c
   to clean this up and see what it looked like.  Eek!
*/


/* hope this doesn't cause anybody problems */
double drand48();

#define DISP( a, b ) (int)((char *)(&(a)) - (char *)(&(b)))

void
FreeMPITypes()
{
  MPI_Type_free(&winspecs_type);
  MPI_Type_free(&flags_type);
  MPI_Type_free(&rect_type);
}

void 
DefineMPITypes()
{
  Winspecs winspecs;
  Flags flags;
  rect rectangle;
  MPI_Aint a, b;

  int len[4];
  MPI_Aint disp[4];
  MPI_Datatype types[4];

  NUM_type = MPI_DOUBLE;

  MPI_Type_contiguous( 8, MPI_INT, &winspecs_type );
  MPI_Type_commit( &winspecs_type );

  /* Skip the initial 4 pointers in flags, these should not
     be exchanged between processes.
   */
  len[0] = 12; /* 12 ints */
  len[1] = 2;  /* 2 doubles */
  len[2] = 6;  /* 6 NUM_types */

  MPI_Address( (void*)&flags.breakout, &a );
  MPI_Address( (void*)&flags, &b );
  disp[0] = a - b;
  MPI_Address( (void*)&flags.boundary_sq, &a );
  disp[1] = a - b;
  MPI_Address( (void*)&flags.rmin, &a );
  disp[2] = a - b;
  types[0] = MPI_INT;
  types[1] = MPI_DOUBLE;
  types[2] = NUM_type;
  MPI_Type_struct( 3, len, disp, types, &flags_type );
  MPI_Type_commit( &flags_type );

  len[0] = 5;
  MPI_Address( (void*)&rectangle.l, &a );
  MPI_Address( (void*)&rectangle, &b );
  disp[0] = a - b;
  types[0] = MPI_INT;
  MPI_Type_struct( 1, len, disp, types, &rect_type );
  MPI_Type_commit( &rect_type );

}


GetDefaultWinspecs( winspecs )
Winspecs *winspecs;
{
  winspecs->height = DEF_height;
  winspecs->width  = DEF_width;
  winspecs->bw     = DEF_bw;
  winspecs->xpos   = DEF_xpos;
  winspecs->ypos   = DEF_ypos;
  winspecs->numColors = DEF_numColors;
#if DEBUG
  fprintf( debug_file, "height = %d\nwidth = %d\nbw = %d\nxpos = %d\n",
	   winspecs->height, winspecs->width, winspecs->bw, winspecs->xpos );
  fprintf( debug_file, "ypos = %d\nnumColor = %d\n", winspecs->ypos,
	   winspecs->numColors );
  fflush( debug_file );
#endif
  return 0;
}

GetDefaultFlags( winspecs, flags )
Winspecs *winspecs;
Flags *flags;
{
  flags->logfile   = DEF_logfile;
  flags->inf       = DEF_inf;
  flags->outf      = DEF_outf;
  flags->winspecs  = winspecs;
  flags->breakout  = DEF_breakout;
  flags->randomize = DEF_randomize;
  flags->colReduceFactor = DEF_colReduceFactor;
  flags->loop      = DEF_loop;
  flags->zoom      = DEF_zoom;
  flags->askNeighbor = DEF_askNeighbor;
  flags->sendMasterComplexity = DEF_sendMasterComplexity;
  flags->drawBlockRegion = DEF_drawBlockRegion;
  flags->fractal   = DEF_fractal;
  flags->maxiter   = DEF_maxiter;
  flags->boundary_sq = DEF_boundary * DEF_boundary;
  flags->epsilon   = DEF_epsilon;
  NUM_ASSIGN( flags->rmin, DEF_rmin);
  NUM_ASSIGN( flags->rmax, DEF_rmax);
  NUM_ASSIGN( flags->imin, DEF_imin);
  NUM_ASSIGN( flags->imax, DEF_imax);
  NUM_ASSIGN( flags->julia_r, DEF_julia_r);
  NUM_ASSIGN( flags->julia_i, DEF_julia_i);

  flags->no_remote_X       = DEF_no_remote_X;
  flags->with_tracking_win = DEF_with_tracking_win;

#if DEBUG
  fprintf( debug_file, "logfile = %s\n", flags->logfile );
  fprintf( debug_file, "inf = %s\n", flags->inf );
  fprintf( debug_file, "outf = %s\n", flags->outf );
  fprintf( debug_file, "breakout = %d\n", flags->breakout );
  fprintf( debug_file, "randomize = %d\n", flags->randomize );
  fprintf( debug_file, "colReduceFactor = %d\n", flags->colReduceFactor );
  fprintf( debug_file, "loop = %d\n", flags->loop );
  fprintf( debug_file, "zoom = %d\n", flags->zoom );
  fprintf( debug_file, "askNeighbor = %d\n", flags->askNeighbor );
  fprintf( debug_file, "sendMasterComplexity = %d\n", flags->sendMasterComplexity);
  fprintf( debug_file, "drawBlockRegion = %d\n", flags->drawBlockRegion );
  fprintf( debug_file, "fractal = %d\n", flags->fractal );
  fprintf( debug_file, "maxiter = %d\n", flags->maxiter );
  fprintf( debug_file, "boundary_sq = %lf\n", flags->boundary_sq );
  fprintf( debug_file, "epsilon = %lf\n", flags->epsilon );
  fprintf( debug_file, "rmin = %lf\n", flags->rmin );
  fprintf( debug_file, "rmax = %lf\n", flags->rmax );
  fprintf( debug_file, "imin = %lf\n", flags->imin );
  fprintf( debug_file, "imax = %lf\n", flags->imax );
  fprintf( debug_file, "julia_r = %lf\n", flags->julia_r );
  fprintf( debug_file, "julia_i = %lf\n", flags->julia_i );
  fprintf( debug_file, "no_remote_X = %d\n", flags->no_remote_X );
  fprintf( debug_file, "with_tracking_win = %d\n", flags->with_tracking_win );
  fflush( debug_file );
#endif
  return 0;
}

int
GetWinspecs( argc, argv, winspecs )
int *argc;
char **argv;
Winspecs *winspecs;
{
  int myid;
  int numranks;

  MPI_Comm_rank( MPI_COMM_WORLD, &myid );
  MPI_Comm_size( MPI_COMM_WORLD, &numranks );
  
  if (!myid) {
    GetIntArg( argc, argv, "-height", &(winspecs->height) );
    GetIntArg( argc, argv, "-width",  &(winspecs->width) );
    winspecs->bw = IsArgPresent( argc, argv, "-bw" );
    GetIntArg( argc, argv, "-xpos", &(winspecs->xpos) );
    GetIntArg( argc, argv, "-ypos", &(winspecs->ypos) );
    GetIntArg( argc, argv, "-colors", &(winspecs->numColors) );
  }

#if DEBUG
  fprintf( debug_file, "[%d] before windspecs bcast\n", myid );
  fflush( debug_file );
#endif
  MPI_Bcast( winspecs, 1, winspecs_type, 0, MPI_COMM_WORLD );
#if DEBUG
  fprintf( debug_file, "[%d] after windspecs bcast\n", myid );
  fflush( debug_file );
#endif

  /* Each rank gets a color. Divide color range evenly.  */
  winspecs->my_tracking_color = (winspecs->numColors/numranks) * myid;

#if DEBUG
  fprintf( debug_file, "[%d]height = %d\n", myid, winspecs->height );
  fprintf( debug_file, "[%d]width = %d\n", myid, winspecs->width );
  fprintf( debug_file, "[%d]bw = %d\n", myid, winspecs->bw );
  fprintf( debug_file, "[%d]xpos = %d\n", myid, winspecs->xpos );
  fprintf( debug_file, "[%d]ypos = %d\n", myid, winspecs->ypos );
  fprintf( debug_file, "[%d]numColors = %d\n", myid, winspecs->numColors );
  fflush( debug_file );
#endif
  return 0;
}

GetFlags( argc, argv, winspecs, flags )
int *argc;
char **argv;
Winspecs *winspecs;
Flags *flags;
{
  double x, y;
  int myid, strLens[3];

  MPI_Comm_rank( MPI_COMM_WORLD, &myid );

  if (myid == 0) {
    GetStringArg( argc, argv, "-l", &(flags->logfile) );
    GetStringArg( argc, argv, "-i", &(flags->inf) );
      /* if reading from input file, disable zooming */
    if (flags->inf) {
      flags->zoom = 0;
    }
    GetStringArg( argc, argv, "-o", &(flags->outf) );
    GetIntArg( argc, argv, "-breakout", &(flags->breakout) );
    if (IsArgPresent( argc, argv, "-randomize" )) {
      flags->randomize = 0;
    }
    if (IsArgPresent( argc, argv, "+randomize" )) {
      flags->randomize = 1;
    }
    GetIntArg( argc, argv, "-colreduce", &(flags->colReduceFactor) );
    flags->loop = IsArgPresent( argc, argv, "-loop" );
    if (IsArgPresent( argc, argv, "-zoom" )) {
      flags->zoom = 0;
    }
    if (IsArgPresent( argc, argv, "+zoom" ) && !flags->inf ) {
      flags->zoom = 1;
    }
    flags->askNeighbor = IsArgPresent( argc, argv, "-neighbor" );
    flags->sendMasterComplexity = IsArgPresent( argc, argv, "-complexity" );
    flags->drawBlockRegion = IsArgPresent( argc, argv, "-delaydraw" );

    GetIntArg( argc, argv, "-with_tracking_win", &(flags->with_tracking_win) );
    GetIntArg( argc, argv, "-no_remote_X", &(flags->no_remote_X) );
    
    if (IsArgPresent( argc, argv, "-mandel" )) {
      flags->fractal = MBROT;
    } else if (IsArgPresent( argc, argv, "-julia" )) {
      flags->fractal = JULIA;
    } else if (IsArgPresent( argc, argv, "-newton" )) {
      flags->fractal = NEWTON;
    }
    
    GetIntArg( argc, argv, "-maxiter", &(flags->maxiter) );
    if (GetDoubleArg( argc, argv, "-boundary", &x )) {
      flags->boundary_sq = x * x;
    }
    GetDoubleArg( argc, argv, "-epsilon", &(flags->epsilon) );
    if (GetDoubleArg( argc, argv, "-rmin", &x )) {
      NUM_ASSIGN( flags->rmin, DBL2NUM( x ) );
    }
    if (GetDoubleArg( argc, argv, "-rmax", &x )) {
      NUM_ASSIGN( flags->rmax, DBL2NUM( x ) );
    }

    if (GetDoubleArg( argc, argv, "-imin", &x )) {
      NUM_ASSIGN( flags->imin, DBL2NUM( x ) );
    }
    if (GetDoubleArg( argc, argv, "-imax", &x )) {
      NUM_ASSIGN( flags->imax, DBL2NUM( x ) );
    }
    if (GetDoubleArg( argc, argv, "-radius", &x )) {
      if (GetDoubleArg( argc, argv, "-rcenter", &y )) {
	NUM_ASSIGN( flags->rmin, DBL2NUM( y-x ) );
	NUM_ASSIGN( flags->rmax, DBL2NUM( y+x ) );
      }
      if (GetDoubleArg( argc, argv, "-icenter", &y )) {
	NUM_ASSIGN( flags->imin, DBL2NUM( y-x ) );
	NUM_ASSIGN( flags->imax, DBL2NUM( y+x ) );
      }
    }
    strLens[0] = (flags->logfile) ? strlen(flags->logfile)+1 : 0;
    strLens[1] = (flags->inf)     ? strlen(flags->inf)+1     : 0;
    strLens[2] = (flags->outf)    ? strlen(flags->outf)+1    : 0;
  } /* End of myid == 0 */

#if DEBUG
     fprintf( stderr, "%d about to broadcast flags info\n", myid );
#endif
  MPI_Bcast( flags, 1, flags_type, 0, MPI_COMM_WORLD );

#if DEBUG
  fprintf (stderr, "%d about to broadcast string lengths\n", myid );
#endif
  MPI_Bcast( strLens, 3, MPI_INT, 0, MPI_COMM_WORLD );

  if (myid != 0) {

    if (flags->logfile != 0) {
      free(flags->logfile);
      flags->logfile = 0;
    }
    if (flags->inf != 0) {
      free(flags->inf);
      flags->inf = 0;
    }
    if (flags->outf != 0) {
      free(flags->outf);
      flags->outf = 0;
    }
    flags->logfile = (strLens[0]) ?
      (char *)malloc( strLens[0] * sizeof( char ) ) : 0;
    flags->inf = (strLens[1]) ?
      (char *)malloc( strLens[1] * sizeof( char ) ) : 0;
    flags->outf = (strLens[2]) ?
      (char *)malloc( strLens[2] * sizeof( char ) ) : 0;
  }
#if DEBUG
  fprintf( stderr, "%d about to broadcast strings\n", myid );
#endif
  if (strLens[0]) 
    MPI_Bcast( flags->logfile, strLens[0], MPI_CHAR, 0, MPI_COMM_WORLD );
  if (strLens[1]) 
    MPI_Bcast( flags->inf,     strLens[1], MPI_CHAR, 0, MPI_COMM_WORLD );
  if (strLens[2]) 
    MPI_Bcast( flags->outf,    strLens[2], MPI_CHAR, 0, MPI_COMM_WORLD );

#if DEBUG
  fprintf( debug_file, "[%d]logfile = %s\n", myid, flags->logfile );
  fprintf( debug_file, "[%d]inf = %s\n", myid, flags->inf );
  fprintf( debug_file, "[%d]outf = %s\n", myid, flags->outf );
  fprintf( debug_file, "[%d]breakout = %d\n", myid, flags->breakout );
  fprintf( debug_file, "[%d]randomize = %d\n", myid, flags->randomize );
  fprintf( debug_file, "[%d]colReduceFactor = %d\n", myid,
	   flags->colReduceFactor );
  fprintf( debug_file, "[%d]loop = %d\n", myid, flags->loop );
  fprintf( debug_file, "[%d]zoom = %d\n", myid, flags->zoom );
  fprintf( debug_file, "[%d]askNeighbor = %d\n", myid, flags->askNeighbor );
  fprintf( debug_file, "[%d]sendMasterComplexity = %d\n", myid,
	   flags->sendMasterComplexity );
  fprintf( debug_file, "[%d]drawBlockRegion = %d\n", myid,
	   flags->drawBlockRegion );
  fprintf( debug_file, "[%d]fractal = %d\n", myid, flags->fractal );
  fprintf( debug_file, "[%d]maxiter = %d\n", myid, flags->maxiter );
  fprintf( debug_file, "[%d]boundary_sq = %lf\n", myid, flags->boundary_sq );
  fprintf( debug_file, "[%d]epsilon = %lf\n", myid, flags->epsilon );
  fprintf( debug_file, "[%d]rmin = %lf\n", myid, flags->rmin );
  fprintf( debug_file, "[%d]rmax = %lf\n", myid, flags->rmax );
  fprintf( debug_file, "[%d]imin = %lf\n", myid, flags->imin );
  fprintf( debug_file, "[%d]imax = %lf\n", myid, flags->imax );
  fprintf( debug_file, "[%d]julia_r = %lf\n", myid, flags->julia_r );
  fprintf( debug_file, "[%d]julia_i = %lf\n", myid, flags->julia_i );
  fprintf( debug_file, "[%d]no_remote_X = %d\n", myid, flags->no_remote_X );
  fprintf( debug_file, "[%d]with_tracking_win = %d\n", myid, flags->with_tracking_win );
  fflush( debug_file );
#endif
  return 0;
}



Pixel2Complex( flags, x, y, nx, ny )
Flags *flags;
int x, y;
NUM *nx, *ny;
{
  NUM_PTR_ASSIGN(
    nx,
    NUM_ADD(
      NUM_MULT(
	DBL2NUM( (double)x / flags->winspecs->width ),
	NUM_SUB( flags->rmax, flags->rmin )),
      flags->rmin )
  );

  NUM_PTR_ASSIGN(
    ny,
    NUM_ADD(
      NUM_MULT(
        DBL2NUM( (double)y / flags->winspecs->height ),
        NUM_SUB( flags->imin, flags->imax )),
      flags->imax )
  );

/*
  fprintf( stderr, "In (%d %d) to (%lf,%lf)-(%lf,%lf)\n",
	   flags->winspecs->width, flags->winspecs->height,
	   flags->rmin, flags->imin, flags->rmax, flags->imax );
  fprintf( stderr, "Converted (%d, %d) to (%lf, %lf)\n",
	   x, y, *nx, *ny );
*/

  return 0;
}


StrContainsNonWhiteSpace( str )
char *str;
{
  while (*str) {
    if (!isspace( *str )) return 1;
    str++;
  }
  return 0;
}




/* Q_Create - create the queue */
void Q_Create( q, randomize )
rect_queue *q;
int randomize;
{
  q->head = q->tail = 0;       /* create the queue */
  q->size = 100;
  q->r = (rect *) malloc( q->size * sizeof( rect ) );
  q->randomPt = 1;
  q->randomize = randomize;
}

void Q_Destroy(q)
rect_queue *q;
{
  if ( (q != NULL) && (q->r != NULL) ) {
    free(q->r);
  }
}

/* Q_Checksize - check if the queue is full.  If so, double the size */
void Q_Checksize( q )
rect_queue *q;
{
  if (q->head == q->tail+1 ||
      !q->head && q->tail == q->size - 1) {
				/* if the queue is full */
    q->r = (rect *) realloc( q->r, sizeof( rect ) * q->size * 2 );
				/* get a bigger queue */
    if (q->tail < q->head) {
      memcpy( q->r + q->size, q->r, q->tail * sizeof( rect ) );
				/* copy over any data that needs to be moved */
      q->tail += q->size;
    }
    if (q->randomize && q->randomPt<q->head) {
      q->randomPt += q->size;
    }
    q->size *= 2;
  }
}

void
Q_Print( q )
rect_queue *q;
{
  int i;
  i = q->head;
  while (i!=q->tail) {
    fprintf( debug_file, "queue[%d] = (%d %d %d %d)\n", i, q->r[i].l, q->r[i].r,
	    q->r[i].t, q->r[i].b );
    i++;
    if (i==q->size) i = 0;
  }
}

int
Q_CheckValidity( q )
rect_queue *q;
{
  int i;
  i = q->head;
  while (i != q->tail) {
    if (q->r[i].l > 10000 ||
	q->r[i].r > 10000 ||
	q->r[i].t > 10000 ||
	q->r[i].b > 10000 ||
	q->r[i].length > 10000) {
      fprintf( debug_file, "Error in queue[%d]: (%d %d %d %d %d)\n",
	       i, q->r[i].l, q->r[i].r, q->r[i].t, q->r[i].b, q->r[i].length );
    }