pm_genproc.c

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

    if (++i == q->size) i=0;
  }
  return 0;
}


/* Q_Enqueue - add a rectangle to the queue */
void Q_Enqueue( q, r )
rect_queue *q;
rect *r;
{
#if DEBUG
  Q_CheckValidity( q );
#endif
  Q_Checksize( q );
  q->r[q->tail] = *r;
#if DEBUG>1
  fprintf( debug_file, "added to queue at %d\n", q->tail );
#endif
  if (++q->tail == q->size) q->tail = 0;
#if DEBUG>2
  fprintf( debug_file, "Added to queue:\n" );
  Q_Print( q );
#endif
#if DEBUG
  Q_CheckValidity( q );
#endif
}

/* Q_Dequeue - remove a rectangle from the queue */
void Q_Dequeue( q, r )
rect_queue *q;
rect *r;
{
  double rand_no;
#if DEBUG
  Q_CheckValidity( q );
#endif
  *r = q->r[q->head];
#if DEBUG>1
  fprintf( debug_file, "remove from queue at %d\n", q->head );
#endif
  if (++q->head == q->size) q->head = 0;
  if (q->randomize && ((q->head == q->randomPt) ||
		    (q->head == q->randomPt + 1))) {
    int i, j, numItems;
    rect temp;
    numItems = (q->tail<q->head)
	? q->size-q->head + q->tail
	    : q->tail - q->head;
    for (i=q->head; i!=q->tail; i++) {
      rand_no = drand48();
      j = (int)(rand_no * numItems) + q->head;
      if (j>=q->size) j-=q->size;
      temp = q->r[j];
      q->r[j] = q->r[i];
      q->r[i] = temp;
      if (i==q->size-1) {
	i = -1;
      }
    }
    q->randomPt = q->tail;
  }
#if DEBUG>2
  fprintf( debug_file, "Removed from queue:\n" );
  Q_Print( q );
#endif
#if DEBUG
  Q_CheckValidity( q );
#endif
}




int RectBorderLen( r )
rect *r;
{
  return (r->r-r->l) ?
           (r->b-r->t) ?
	     (2 * (r->r-r->l+r->b-r->t) )
	   :
	     (r->r - r->l + 1)
	 :
	   (r->b-r->t) ?
	     (r->b - r->t + 1)
	   :
	     1;
}

void
PrintHelp( progName )
char *progName;
{
  printf( "Options recognized by %s:\n", progName );
  printf( "(defaults are in parentheses () )\n" );
/*
  printf( "   -o <filename>              (<stdout>) output file\n" );
*/
  printf( "   -i <filename>              (none) input file\n" );
#if LOG
  printf( "   -l <filename>              (\"%s\") name of log file\n", DEF_logfile );
#endif
  printf( "   -xpos <xpos>               (%d) window horizontal coordinate\n",
	  DEF_xpos );
 printf( "   -ypos <xpos>               (%d) window vertical coordinate\n",
	  DEF_ypos );
  printf( "   -width <width>             (%d) width of computed area in points\n", DEF_width );
  printf( "   -height <height>           (%d) height of computed area in points\n", DEF_height );
  printf( "   -boundary <boundary>       (%.1lf) boundary value for M-set computation\n", DEF_boundary );
  printf( "   -maxiter <max. iter>       (%d) maximum # of iterations for M-set\n", DEF_maxiter );
  printf( "                              compuptation algorithm\n" );
  printf( "   -rmin <real min.>          (%.2lf) minimum real coordinate of computed area\n", DEF_rmin );
  printf( "   -rmax <real max.>          (%.2lf) maximum real coordinate of computed area\n", DEF_rmax );
  printf( "   -imin <imag. min.>         (%.2lf) minimum imaginary coordinate of computed\n", DEF_imin );
  printf( "                              area\n" );
  printf( "   -imax <imag. max.>         (%.2lf) maximum imaginary coordinate of computed\n", DEF_imax );
  printf( "                              area\n" );
  printf( "\n" );
  printf( "      alternate form: (if specified, overrides <r|i><min|max>)\n" );
  printf( "   -rcenter <real center>     (%.2lf) center real coordinate of computed area\n", (DEF_rmin+DEF_rmax)/2 );
  printf( "   -icenter <imag. center>    (%.2lf) center imaginary coordinate of computed\n", (DEF_imin+DEF_imax)/2 );
  printf( "                              area\n" );
  printf( "   -radius <area radius>      (%.2lf) radius of the computed area\n", (DEF_rmax - DEF_rmin) );
  printf( "\n" );
  printf( "   -breakout <breakout size>  (%d) maximum length or width rectangle to\n", DEF_breakout );
  printf( "                              subdivide\n" );
  printf( "   -no_remote_X <0|1>         (%d) Boolean, if true (1) all X display is handled\n", DEF_no_remote_X );
  printf( "                                   is handled by rank 0.\n");
  printf( "   -with_tracking_win <0|1>   (%d) Boolean, if true (1) add a second output window\n", DEF_with_tracking_win );
  printf( "                                   showing who computed what part of the output.\n");
  printf( "   -tol <num pixels>          (2) Integer (mouse drag tolerence),\n"
          "                                  When using the mouse to zoom in on a picture,\n"
          "                                  dragging less than this number of pixels\n"
          "                                  will be interpreted as a simple click for\n" );
  printf( "                                  the purpose of quitting the program.\n" );
  printf( "   -colors <# of colors>      (%d) number of colors to request\n", DEF_numColors );
  printf( "   -colreduce <reduce factor> (%d) factor by which to scale down iteration\n", DEF_colReduceFactor );
  printf( "                              values to reduce color changes\n" );
  printf( "   <+,->zoom                  (%s) turn on (off) drag&zoom\n",
	  DEF_zoom ? "on" : "off" );
  printf( "   <+,->randomize             (%sset) (on,off) compute regions in as random of\n",
	 DEF_randomize ? "" : "not " );
  printf( "                              order as possible\n" );
/*
     printf( "   -tasksize <# of pixels>  (%d) approximate number of pixels to assign a slave\n", DEF_tasksize );
     printf( "        process after each request for work\n" );
*/
  printf( "   -bw                        (%sset) draw in black and white instead of\n", DEF_bw ? "" : "not " );
  printf( "                              color\n" );
  exit( 0 );
}


MPE_Color Iter2Color( flags, iter )
Flags *flags;
int iter;
{
  if (flags->winspecs->bw) {
    return ( (iter == flags->maxiter) ? MPE_BLACK :
	    ((iter / flags->colReduceFactor) % 2 ) ? MPE_WHITE : MPE_BLACK);
  } else {
    if (iter == flags->maxiter) {
      return MPE_BLACK;
    } else {
      return flags->winspecs->colorArray[ (iter / flags->colReduceFactor) %
			        flags->winspecs->numColors ];
    }
  }
}

void
ChunkIter2Color( flags, iterData, colorData, size )
Flags *flags;
int *iterData, size;
int *colorData;
{
  int i;

  for (i=0; i<size; i++) {
    *colorData = Iter2Color( flags, *iterData );
#if DEBUG>1
    fprintf( debug_file, "iter %d to color %d\n", *iterData, *colorData );
    fflush( debug_file );
#endif
    colorData++;
    iterData++;
  }
}




ComputeChunk( flags, r, pointData, iterData, maxnpoints, npoints )
Flags *flags;
rect *r;
int *iterData, maxnpoints, *npoints;
MPE_Point *pointData;
{
  int i, x, y;
#if DEBUG
  fprintf( debug_file, "Compute directly (%d %d %d %d %d)\n",
	   r->l, r->r, r->t, r->b, r->length );
  fflush( debug_file );
#endif
  CalcField( flags->fractal, iterData, r->l, r->r, r->t, r->b );
    /* compute the field */

  *npoints = (r->r - r->l + 1) * (r->b - r->t + 1);
  x = r->l;  y = r->t;
  for (i=0; i<*npoints; i++) {
    pointData[i].x = x++;
    pointData[i].y = y;
    pointData[i].c = Iter2Color( flags, iterData[i] );
#if DEBUG>2
    fprintf( debug_file, "computed (%d %d) %d\n", pointData[i].x,
	     pointData[i].y, pointData[i].c );
#endif
    if (x > r->r) {
      x = r->l;
      y++;
    }
  }
  return 0;
}



DrawChunk( graph, colorData, r, flags )
MPE_XGraph graph;
int *colorData;
rect r;
Flags *flags;
{
  int a, b;

  for (b=r.t; b<=r.b; b++) {
    for (a=r.l; a<=r.r; a++) {
      MPE_Draw_point( graph, a, b, *colorData );
#if DEBUG>1
      fprintf( debug_file, "put color %d at (%d %d)\n", *colorData,
	       a, b );
      fflush( debug_file );
#endif
      colorData++;
    }
  }

  if (flags->with_tracking_win) {
    MPE_Update(tracking_win);
  }

  MPE_Update(graph);
  return 0;
}


#if DEBUG>2
#define LOOP( start, toContinue, incrBefore, fn, check, lbl, incrAfter ) \
  start; \
  while (toContinue) { \
    incrBefore; \
    pointPtr->x = x; \
    pointPtr->y = y; \
    pointPtr->c = Iter2Color( flags, fn( re, im ) ); \
    fprintf( debug_file, "computed (%d %d) %d\n", pointPtr->x, \
             pointPtr->y, pointPtr->c ); \
    check \
  lbl \
    incrAfter; \
  }
#else
#define LOOP( start, toContinue, incrBefore, fn, check, lbl, incrAfter ) \
  start; \
  while (toContinue) { \
    incrBefore; \
    pointPtr->x = x; \
    pointPtr->y = y; \
    pointPtr->c = Iter2Color( flags, fn( re, im ) ); \
    check \
  lbl \
    incrAfter; \
  }
#endif

/*
    fprintf(stderr, "computed (%d %d) to be %d\n", x, y, pointPtr->c ); \
*/

/* really, all these stupid loop macros will make it easier! */

#define LOOP_TOP( fn, check, lbl ) \
  LOOP( (y=r.t, x=r.l+1), x<=r.r, NUM_ASSIGN( re, NUM_ADD( re, rstep ) ), \
        fn, check, lbl, (pointPtr++,x++) );

#define LOOP_RIGHT( fn, check, lbl ) \
  LOOP( (x=r.r, y=r.t+1), y<=r.b, NUM_ASSIGN( im, NUM_ADD( im, istep ) ), \
        fn, check, lbl, (pointPtr++,y++) );

#define LOOP_BOTTOM( fn, check, lbl ) \
  LOOP( (y=r.b, x=r.r-1), x>=r.l, NUM_ASSIGN( re, NUM_SUB( re, rstep ) ), \
        fn, check, lbl, (pointPtr++,x--) );

#define LOOP_LEFT( fn, check, lbl ) \
  LOOP( (x=r.l, y=r.b-1), y>r.t,  NUM_ASSIGN( im, NUM_SUB( im, istep ) ), \
        fn, check, lbl, (pointPtr++,y--) );

#define LOOP_TOP_CHECK( fn, lbl ) \
  LOOP_TOP( fn, if (pointPtr->c != firstColor) goto lbl;, ; );

#define LOOP_RIGHT_CHECK( fn, lbl  ) \
  LOOP_RIGHT( fn, if (pointPtr->c != firstColor) goto lbl;, ; );

#define LOOP_BOTTOM_CHECK( fn, lbl  ) \
  LOOP_BOTTOM( fn, if (pointPtr->c != firstColor) goto lbl;, ; );

#define LOOP_LEFT_CHECK( fn, lbl  ) \
  LOOP_LEFT( fn, if (pointPtr->c != firstColor) goto lbl;, ; );

#define LOOP_TOP_NOCHECK( fn, lbl  ) \
  LOOP_TOP( fn, ; , lbl: );

#define LOOP_RIGHT_NOCHECK( fn, lbl  ) \
  LOOP_RIGHT( fn, ; , lbl: );

#define LOOP_BOTTOM_NOCHECK( fn, lbl  ) \
  LOOP_BOTTOM( fn, ; , lbl: );

#define LOOP_LEFT_NOCHECK( fn, lbl  ) \
  LOOP_LEFT( fn, ; , lbl: );

#define LOOP_FN( fn, lbl1, lbl2, lbl3, lbl4 ) \
  if (r.b-r.t>1 && r.r-r.l>1) { \
    /* if there's a chance to subdivide, */ \
    LOOP_TOP_CHECK( fn, lbl1 ); \
    LOOP_RIGHT_CHECK( fn, lbl2 ); \
    LOOP_BOTTOM_CHECK( fn, lbl3 ); \
    LOOP_LEFT_CHECK( fn, lbl4 ); \
    *isContinuous = 1; \
    return 1;   /* if we made it to this point, it's continuous */ \
    LOOP_TOP_NOCHECK( fn, lbl1 ); \
    LOOP_RIGHT_NOCHECK( fn, lbl2 ); \
    LOOP_BOTTOM_NOCHECK( fn, lbl3 ); \
    LOOP_LEFT_NOCHECK( fn, lbl4 ); \
    *isContinuous = 0; \
    return 0;   /* it ain't continuous */ \
  } else { /* if there's no chance to subdivide, don't insert the checks */ \
    LOOP_TOP( fn, ; , ; ); \
    LOOP_RIGHT( fn, ; , ; ); \
    if (r.r-r.l && r.b-r.t) { \
      /* only do the opposite sides if >1 row and >1 column */ \
      LOOP_BOTTOM( fn, ; , ; ); \
      LOOP_LEFT( fn, ; , ; ); \
    } \
    *isContinuous = 0; \
    return 0;  /* it may or may not be continuous, doesn't matter */ \
  }



int ComputeBorder( winspecs, flags, rectPtr, pointData, maxnpoints,
		   npoints, isContinuous )
Winspecs *winspecs;
Flags *flags;
rect *rectPtr;
MPE_Point *pointData;
int maxnpoints, *npoints, *isContinuous;
{
  register NUM re, im, rstep, istep;
  register int x, y;
  register MPE_Point *pointPtr;
  register MPE_Color firstColor;
  rect r;

  r = *rectPtr;
  /* xsplit, ysplit - where to split the rectangle */

    /* set the complex points */
  NUM_ASSIGN( re, COORD2CMPLX( flags->rmin, flags->rmax, 0,
			       winspecs->width-1,  r.l) );
  NUM_ASSIGN( im, COORD2CMPLX( flags->imax, flags->imin, 0,
			       winspecs->height-1, r.t) );
  NUM_ASSIGN( rstep,  NUM_DIV( NUM_SUB( flags->rmax, flags->rmin ),
			       INT2NUM( winspecs->width-1 ) ) );
  NUM_ASSIGN( istep,  NUM_DIV( NUM_SUB( flags->imin, flags->imax ),
			       INT2NUM( winspecs->height-1 ) ) );

  pointPtr = pointData+1;
  pointData->x = r.l;
  pointData->y = r.t;
  pointData->c = firstColor = Iter2Color( flags,
		 (flags->fractal == MBROT) ? MbrotCalcIter( re, im ) :
		 (flags->fractal == JULIA) ? JuliaCalcIter( re, im ) :
		                             MbrotCalcIter( re, im ) );
#if DEBUG>2
  fprintf( debug_file, "computed (%d %d) %d\n",
	   pointData->x, pointData->y, pointData->c );
#endif

  *npoints = r.length;
    /* calculate first point */

  
  switch( flags->fractal ) {
  case MBROT:
    LOOP_FN( MbrotCalcIter, m1, m2, m3, m4 );
  case JULIA:
    LOOP_FN( JuliaCalcIter, j1, j2, j3, j4 );
  case NEWTON:
    LOOP_FN( MbrotCalcIter, n1, n2, n3, n4 );
  }
  return 0;
}

void
DrawBorder( graph, colorData, r )
MPE_XGraph graph;
int *colorData;
rect r;
{
  int x, y;

  for (y=r.t, x=r.l; x<=r.r; x++) {
#if DEBUG_POINTS
    fprintf( debug_file, "draw %d at %d %d\n", *colorData, x, y );
    fflush( debug_file );
#endif
    MPE_Draw_point( graph, x, y, *colorData );
    colorData++;
  }
  for (x=r.r, y=r.t+1; y<=r.b; y++) {
#if DEBUG_POINTS
    fprintf( debug_file, "draw %d at %d %d\n", *colorData, x, y );
    fflush( debug_file );
#endif
    MPE_Draw_point( graph, x, y, *colorData );
    colorData++;
  }
  if (r.r-r.l && r.b-r.t) {
    for (y=r.b, x=r.r-1;x>=r.l; x--) {
#if DEBUG_POINTS
      fprintf( debug_file, "draw %d at %d %d\n", *colorData, x, y );
      fflush( debug_file );
#endif
      MPE_Draw_point( graph, x, y, *colorData );
      colorData++;
    }
    for (x=r.l, y=r.b-1; y>r.t; y--) {
#if DEBUG_POINTS
      fprintf( debug_file, "draw %d at %d %d\n", *colorData, x, y );
      fflush( debug_file );
#endif
      MPE_Draw_point( graph, x, y, *colorData );
      colorData++;
    }
  }
  MPE_Update( graph );
}

void
DrawBlock( graph, pointData, r )
MPE_XGraph graph;
MPE_Point *pointData;
rect *r;
{
#if DEBUG>2
  int x, y, i;

  i = 0;
  for (y=r->t; y<=r->b; y++) {
    for (x=r->l; x<=r->r; x++) {
      fprintf( debug_file, "drawing (%d %d) %d\n", x, y, pointData->c );
      i++;
    }
  }
  fflush( debug_file );
#endif

  MPE_Fill_rectangle( graph, r->l, r->t, r->r - r->l + 1, r->b - r->t + 1,
		      pointData->c );
  
  MPE_Update( graph );
}