pm_genproc_cleanedup.c

mpi程序

typedef char *__gnuc_va_list;



























extern struct _iobuf {
  int _cnt;
  unsigned char *_ptr;
  unsigned char *_base;
  int _bufsiz;
  short _flag;
  char _file;
} _iob[];































extern struct _iobuf *fopen(const char *, const char *);
extern struct _iobuf *fdopen(int, const char *);
extern struct _iobuf *freopen(const char *, const char *, struct _iobuf *);
extern struct _iobuf *popen(const char *, const char *);
extern struct _iobuf *tmpfile();
extern long ftell(struct _iobuf *);
extern char *fgets(char *, int, struct _iobuf *);
extern char *gets(char *);
extern char *sprintf(char *, const char *,...);
extern char *ctermid(char *);
extern char *cuserid(char *);
extern char *tempnam(const char *, const char *);
extern char *tmpnam(char *);










typedef enum _Fractal_type {
  MBROT, JULIA, NEWTON
} Fractal_type;








































void Mbrot_Settings(double boundary, int maxiter);
int MbrotCalcIter(double re, double im);
void Julia_Settings(double boundary, int maxiter, double real, double
		     imag);
int JuliaCalcIter(double re, double im);
void Mbrotrep_Settings(double boundary, int maxiter, int miniter,
		        int longestCycle, double fudgeFactor);
int MbrotrepCalcIter(double re, double im);

void CalcField(Fractal_type, int *iterField,
	        int xstart, int xend, int ystart, int yend);

void Copysub2DArray(int *mainArray, int *subArray, int mainWidth,
		     int mainHeight, int subWidth, int subHeight,
		     int xpos, int ypos);

typedef struct Mbrot_settings_ {
  double boundary_sq;

  int maxiter;
} Mbrot_settings;

typedef struct Julia_settings_ {
  double boundary_sq;
  int maxiter;
  double r, i;
} Julia_settings;

typedef struct Newton_settings_ {
  double epsilon;

  int *coeff;
  int nterms;
  int maxiter;

} Newton_settings;









extern MPI_Datatype winspecs_type, flags_type, NUM_type, rect_type;
extern struct _iobuf *debug_file;

typedef enum _Algorithms {
  alg_block,
  alg_separate_rect,
  alg_solid_rect
} Alogrithms;

typedef struct _Winspecs {
  int height, width;
  int bw;
  int xpos, ypos;
  int numColors;
  MPE_Color *colorArray;
} Winspecs;

typedef struct _Flags {
  char *logfile;
  char *inf;
  char *outf;
  Winspecs *winspecs;
  int breakout;
  int randomize;
  int colReduceFactor;

  int loop;
  int zoom;
  int askNeighbor;

  int sendMasterComplexity;


  int drawBlockRegion;


  int fractal;
  int maxiter;
  double boundary_sq;
  double epsilon;
  double rmin, rmax, imin, imax;
  double julia_r, julia_i;
} Flags;




















































typedef struct {
  int l, r, t, b, length;

} rect;

typedef struct {
  int head, tail, size, randomPt, randomize;
  rect *r;
} rect_queue;











































DefineMPITypes()
{
  Winspecs winspecs;
  Flags flags;
  rect rectangle;

  int len[3], disp[3];
  MPI_Datatype types[3];

  NUM_type = MPI_DOUBLE;

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

  len[0] = 10;
  len[1] = 2;
  len[2] = 6;
  disp[0] = (int) ((char *) (&(flags.breakout)) - (char *) (&(flags)));
  disp[1] = (int) ((char *) (&(flags.boundary_sq)) - (char *) (&(flags)));
  disp[2] = (int) ((char *) (&(flags.rmin)) - (char *) (&(flags)));
  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;
  disp[0] = (int) ((char *) (&(rectangle.l)) - (char *) (&(rectangle)));
  types[0] = MPI_INT;
  MPI_Type_struct(1, len, disp, types, &rect_type);
  MPI_Type_commit(&rect_type);

  return 0;
}


GetDefaultWinspecs(winspecs)
Winspecs *winspecs;
{
  winspecs->height = 500;
  winspecs->width = 500;
  winspecs->bw = 0;
  winspecs->xpos = -1;
  winspecs->ypos = -1;
  winspecs->numColors = 16;

  return 0;
}
GetDefaultFlags(winspecs, flags)
Winspecs *winspecs;
Flags *flags;
{
  flags->logfile = 0;
  flags->inf = 0;
  flags->outf = 0;
  flags->winspecs = winspecs;
  flags->breakout = 12;
  flags->randomize = 1;
  flags->colReduceFactor = 4;
  flags->loop = 0;
  flags->zoom = 1;
  flags->askNeighbor = 1;
  flags->sendMasterComplexity = 0;
  flags->drawBlockRegion = 1;
  flags->fractal = MBROT;
  flags->maxiter = 1000;
  flags->boundary_sq = 2.0 * 2.0;
  flags->epsilon = .01;
  {
    (flags->rmin) = (-2.0);
  };
  {
    (flags->rmax) = (2.0);
  };
  {
    (flags->imin) = (-2.0);
  };
  {
    (flags->imax) = (2.0);
  };
  {
    (flags->julia_r) = (.331);
  };
  {
    (flags->julia_i) = (-.4);
  };

  return 0;
}
GetWinspecs(argc, argv, winspecs)
int *argc;
char **argv;
Winspecs *winspecs;
{
  int myid;

  MPI_Comm_rank(MPI_COMM_WORLD, &myid);

  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));
  }
  MPI_Bcast(winspecs, 1, winspecs_type, 0, MPI_COMM_WORLD);



  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) {
    GetStringArg(argc, argv, "-l", &(flags->logfile));
    GetStringArg(argc, argv, "-i", &(flags->inf));
    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->zoom = 1;
    }
    flags->askNeighbor = IsArgPresent(argc, argv, "-neighbor");
    flags->sendMasterComplexity = IsArgPresent(argc, argv, "-complexity");
    flags->drawBlockRegion = IsArgPresent(argc, argv, "-delaydraw");

    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)) {
      {
	(flags->rmin) = ((x));
      };
    }
    if (GetDoubleArg(argc, argv, "-rmax", &x)) {
      {
	(flags->rmax) = ((x));
      };
    }
    if (GetDoubleArg(argc, argv, "-imin", &x)) {
      {
	(flags->imin) = ((x));
      };
    }
    if (GetDoubleArg(argc, argv, "-imax", &x)) {
      {
	(flags->imax) = ((x));
      };
    }
    if (GetDoubleArg(argc, argv, "-radius", &x)) {
      if (GetDoubleArg(argc, argv, "-rcenter", &y)) {
	{
	  (flags->rmin) = ((y - x));
	};
	{
	  (flags->rmax) = ((y + x));
	};
      }
      if (GetDoubleArg(argc, argv, "-icenter", &y)) {
	{
	  (flags->imin) = ((y - x));
	};
	{
	  (flags->imax) = ((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;
  }
  MPI_Bcast(flags, 1, flags_type, 0, MPI_COMM_WORLD);

  MPI_Bcast(strLens, 3, MPI_INT, 0, MPI_COMM_WORLD);
  if (myid != 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 (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);


  return 0;
}



Pixel2Complex(flags, x, y, nx, ny)
Flags *flags;
int x, y;
double *nx, *ny;
{
  {
    *(
      nx) = (
	     ((
	       ((
		 ((double) x / flags->winspecs->width)) * (
				      ((flags->rmax) - (flags->rmin))))) + (
							       flags->rmin))
       );
  };

  {
    *(
      ny) = (
	     ((
	       ((
		 ((double) y / flags->winspecs->height)) * (
				      ((flags->imin) - (flags->imax))))) + (
							       flags->imax))
       );
  };









  return 0;
}


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





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



void Q_Checksize(q)
rect_queue *q;
{
  if (q->head == q->tail + 1 ||
      !q->head && q->tail == q->size - 1) {

    q->r = (rect *) realloc(q->r, sizeof(rect) * q->size * 2);

    if (q->tail < q->head) {
      memcpy(q->r + q->size, q->r, q->tail * sizeof(rect));

      q->tail += q->size;
    }
    if (q->randomize && q->randomPt < q->head) {
      q->randomPt += q->size;
    }
    q->size *= 2;
  }
}


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;
  }
}


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);
    }
    if (++i == q->size)
      i = 0;
  }
  return 0;
}