* The row slices are determined by the pj.schedule property specified * on the command line; the default is to divide the rows evenly among the * worker processes (i.e. no load balancing). For further information about the * pj.schedule property, see class {@linkplain edu.rit.pj.PJProperties * PJProperties}. *
* Within each row slice, the rows are partitioned among the threads of the * worker process using the parallel loop schedule specified by the last command * line argument. If this argument is missing, the default is to divide the rows * evenly among the threads (i.e. no load balancing). For further information, * see the parse() method in class {@linkplain * edu.rit.pj.IntegerSchedule IntegerSchedule}. *
* Usage: java -Dpj.np=Kp -Dpj.nt=Kt [
* -Dpj.schedule=procschedule ] edu.rit.hyb.fractal.MandelbrotSetHyb2
* width height xcenter ycenter resolution
* maxiter gamma filename [ thrschedule ]
*
Kp = Number of parallel processes
*
Kt = Number of parallel threads per process
*
procschedule = Load balancing schedule for processes
*
width = Image width (pixels)
*
height = Image height (pixels)
*
xcenter = X coordinate of center point
*
ycenter = Y coordinate of center point
*
resolution = Pixels per unit
*
maxiter = Maximum number of iterations
*
gamma = Used to calculate pixel hues
*
filename = PJG image file name
*
thrschedule = Load balancing schedule for threads
*
* If filename is specified as, for example, "image.pjg", then * the per-worker image files are named "image_0.pjg", * "image_1.pjg", and so on through Kp-1. *
* The program considers a rectangular region of the complex plane centered at * (xcenter,ycenter) of width pixels by height pixels, * where the distance between adjacent pixels is 1/resolution. The * program takes each pixel's location as a complex number c and performs * the following iteration: *
* z0 = 0
*
zi+1 = zi2 + c
*
* until zi's magnitude becomes greater than or equal * to 2, or i reaches a limit of maxiter. The complex numbers * c where i reaches a limit of maxiter are considered to * be in the Mandelbrot Set. (Actually, a number is in the Mandelbrot Set only * if the iteration would continue forever without zi * becoming infinite; the foregoing is just an approximation.) The program * creates an image with the pixels corresponding to the complex numbers * c and the pixels' colors corresponding to the value of i * achieved by the iteration. Following the traditional practice, points in the * Mandelbrot set are black, and the other points are brightly colored in a * range of colors depending on i. The exact hue of each pixel is * (i/maxiter)gamma. The image is stored in a * Parallel Java Graphics (PJG) file specified on the command line. *
* The computation is performed in parallel in multiple processors. The program
* measures the computation's running time, including the time to write the
* image file.
*
* @author Alan Kaminsky
* @version 14-Mar-2012
*/
public class MandelbrotSetHyb2
{
// Prevent construction.
private MandelbrotSetHyb2()
{
}
// Program shared variables.
// Communicator.
static Comm world;
static int rank;
// Command line arguments.
static int width;
static int height;
static double xcenter;
static double ycenter;
static double resolution;
static int maxiter;
static double gamma;
static File filename;
static IntegerSchedule thrschedule;
// Initial pixel offsets from center.
static int xoffset;
static int yoffset;
// Image matrix.
static int[][] matrix;
static PJGColorImage image;
static PJGImage.Writer writer;
// Storage for matrix row slice.
static int[][] slice;
// Table of hues.
static int[] huetable;
// Parallel thread team per process.
static ParallelTeam team;
// Main program.
/**
* Mandelbrot Set main program.
*/
public static void main
(String[] args)
throws Exception
{
// Start timing.
long t1 = System.currentTimeMillis();
// Initialize middleware.
Comm.init (args);
world = Comm.world();
rank = world.rank();
// Validate command line arguments.
if (args.length < 8 || args.length > 9) usage();
width = Integer.parseInt (args[0]);
height = Integer.parseInt (args[1]);
xcenter = Double.parseDouble (args[2]);
ycenter = Double.parseDouble (args[3]);
resolution = Double.parseDouble (args[4]);
maxiter = Integer.parseInt (args[5]);
gamma = Double.parseDouble (args[6]);
filename = new File (args[7]);
thrschedule =
args.length == 9 ?
IntegerSchedule.parse (args[8]) :
IntegerSchedule.fixed();
// Initial pixel offsets from center.
xoffset = -(width - 1) / 2;
yoffset = (height - 1) / 2;
// Allocate storage for pixel matrix row references only.
matrix = new int [height] [];
// Prepare to write image row slices to per-worker PJG image file.
image = new PJGColorImage (height, width, matrix);
writer =
image.prepareToWrite
(new BufferedOutputStream
(new FileOutputStream
(Files.fileForRank (filename, rank))));
// Create table of hues for different iteration counts.
huetable = new int [maxiter+1];
for (int i = 0; i < maxiter; ++ i)
{
huetable[i] = HSB.pack
(/*hue*/ (float) Math.pow (((double)i)/((double)maxiter),gamma),
/*sat*/ 1.0f,
/*bri*/ 1.0f);
}
huetable[maxiter] = HSB.pack (1.0f, 1.0f, 0.0f);
// Create parallel thread team per process.
team = new ParallelTeam();
long t2 = System.currentTimeMillis();
// First level partitioning: divide pixel rows among the processes. Load
// balancing schedule controlled by -Dpj.schedule property.
new WorkerTeam().execute (new WorkerRegion()
{
public void run() throws Exception
{
execute (0, height - 1, new WorkerIntegerForLoop()
{
public void run (final int lb, final int ub)
throws Exception
{
// Allocate storage for matrix row slice if necessary.
Range range = new Range (lb, ub);
int len = range.length();
if (slice == null || slice.length < len)
{
slice = new int [len] [width];
}
// Second level scheduling: divide pixel rows among the
// threads per process.
team.execute (new ParallelRegion()
{
public void run() throws Exception
{
execute (lb, ub, new IntegerForLoop()
{
// Load balancing schedule controlled by
// final command line argument.
public IntegerSchedule schedule()
{
return thrschedule;
}
// Compute all rows and columns in slice.
public void run (int first, int last)
{
for (int r = first; r <= last; ++ r)
{
int[] slice_r = slice[r-lb];
double y =
ycenter + (yoffset - r) /
resolution;
for (int c = 0; c < width; ++ c)
{
double x =
xcenter + (xoffset + c) /
resolution;
// Iterate until convergence.
int i = 0;
double aold = 0.0;
double bold = 0.0;
double a = 0.0;
double b = 0.0;
double zmagsqr = 0.0;
while (i < maxiter &&
zmagsqr <= 4.0)
{
++ i;
a = aold*aold-bold*bold+x;
b = 2.0*aold*bold + y;
zmagsqr = a*a + b*b;
aold = a;
bold = b;
}
// Record number of iterations
// for pixel.
slice_r[c] = huetable[i];
}
}
}
});
}
});
// Set full pixel matrix rows to refer to slice rows.
System.arraycopy (slice, 0, matrix, lb, len);
// Write row slice of full pixel matrix to image file.
writer.writeRowSlice (range);
}
});
}
});
long t3 = System.currentTimeMillis();
// Close image file.
writer.close();
// Stop timing.
long t4 = System.currentTimeMillis();
System.out.println ((t2-t1) + " msec pre " + rank);
System.out.println ((t3-t2) + " msec calc " + rank);
System.out.println ((t4-t3) + " msec post " + rank);
System.out.println ((t4-t1) + " msec total " + rank);
}
// Hidden operations.
/**
* Print a usage message and exit.
*/
private static void usage()
{
System.err.println ("Usage: java -Dpj.np=