Parallel Integration Master 2 Some PVM Examples

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <pvm3.h>
#include "func.h"

/*
* Find the area to the tolerance.
*/
static double find(double x1, double y1, double x2, double y2, double tol)
{
/* Compute the midpoint from the funcion. */
double midx = (x1 + x2) / 2;
double midy = f(midx);

/* Estimate the midpoint from the y value. */
double midest = (y1 + y2) / 2;

/* See if we're getting close. */
if(fabs(midy - midest) <= tol)
/* Will do.  Compute the area using the midy, since we
found it.  Two trapazoids algebraically simplified. */
return 0.25*(x2-x1)*(y1 + y2 + 2*midy);
else
/* Subdivide and try again. */
return find(x1, y1, midx, midy, tol) +
find(midx, midy, x2, y2, tol);
}

#define INITMAX 20

int main(int argc, char **argv)
{
int cc, tid;

/* Fine argument whine. */
if(argc < 5) {
printf("Usage: %s startx endx tol nreg funcargs*\n",
argv[0]);
exit(2);
}

/* Get the args. */
char *pname = argv[0];
double start = atof(argv[1]);
double end = atof(argv[2]);
double tol = atof(argv[3]);
int nreg = atoi(argv[4]);

argc -= 5; argv += 5;

if(argc > INITMAX) {
printf("Function init limited to %d args.\n", INITMAX);
exit(4);
}

/* Sanity. */
if(tol < 0.0000000001) {
printf("Tolerance to too small or negative.\n");
exit(3);
}
if(nreg < 1) {
printf("Number of regions is nonpositive.\n");
exit(4);
}
if(end < start) {
double t = start;
start = end;
end = t;
}

/* Spawn a worker for each processor other than ourselves. */
int nhost, narch;
struct pvmhostinfo *hostp;
pvm_config( &nhost, &narch, &hostp );
if(nhost > nreg) nhost = nreg;
int tids[nhost - 1];
if(nhost > 1) {
char buf[100];
strcat(strcpy(buf, pname), "_slave");
cc = pvm_spawn(buf, 0, 0, "", nhost - 1, tids);
if(cc <= 0) {
/* Nothing was spawned.  Whine about it. */
pvm_perror("Spawn failed");
pvm_exit();
exit(5);
}

if(cc != nhost - 1) {
/* At least one spawn failed.  Reduce the number
of regions to what we could get. */
nhost = cc + 1;
printf("Unable to spawn all workers.  Reducing "
"to %d.\n", nhost);
}

/* Send out the function init information. */
int n;
for(n = 0; n < argc; n++) {
int len = strlen(argv[n]);
pvm_pkint(&len, 1, 1);
pvm_pkstr(argv[n]);
}
pvm_mcast(tids, nhost - 1, 1);
}

/* Initialize the function. */
finit(argc, argv);

/* Divide into to nreg regions and send 'em out. */
double x = start;
double inc = (end - start) / nreg;
int i;
for(i = nreg; i--;) {
double newx = i ? x + inc : end;
pvm_packf("%+ %lf %lf %lf ",
int nx = pvm_putinfo("work", pvm_getsbuf(),
PvmMboxMultiInstance|PvmMboxOverWritable);
//printf("Index %d: %g %g\n", nx, x, newx);
x = newx;
}

/* Execute regions until all have been taken care of. */
double tot = 0.0;
while(1) {
int bid = pvm_recvinfo
//printf("bid = %d\n", bid);
if(bid < 0) break;
double startx, endx, tol;
pvm_unpackf("%lf %lf %lf ", &startx, &endx, &tol);
tot += find(startx, f(startx), endx, f(endx), tol);
}

/* Collect the others. */
for(i = 0; i < nhost - 1; ++i) {
int rn = pvm_recv(-1, 3);
double portion;
pvm_upkdouble(&portion, 1, 1);
tot += portion;
}

printf("Integral from %g to %g = %g (tol %g)\n",
start, end, tot, tol);

pvm_exit();
exit(0);
}