CSCI 3366 (Introduction to Parallel and Distributed Processing), Fall 2015:
Homework 1
- Credit:
- 40 points.
First a general comment:
For this assignment, please do not discuss
the problem or possible solutions with each other or anyone else.
I want you to discover any potential pitfalls yourselves!
Also, don't worry too much at this point if your code doesn't
perform very well.
The objective is to get something working;
there will be a follow-up assignment that focuses on addressing
problems with performance and/or accuracy.
In class we briefly discussed approximating the value of 
by ``throwing darts'' at a square of side 2 enclosing a circle of
radius 1, counting how many darts fall within the circle, and
then dividing that by the total number of darts to get the ratio
between the area of the circle (
) and the area of the
square (4).
For this assignment, your mission is to write, for different
programming environments (OpenMP, MPI, and Java)
a parallel program that performs this calculation.
(Notice that you will not be writing an OpenCL program for
this assignment, but in the next assignment you'll be revising
the programs you write for this assignment and adding one for OpenCL.)
To get you started, I have written sequential programs in C and
Java that perform the desired calculation and print appropriate
results:
Start by downloading this code, compiling it,
and running it a few times to get a sense of what inputs
you need to get a good approximation of
.
(Notice that you may need the flag -std=c99 or -std=c11
to compile the C code.)
The programs you write
should accept the same command-line input and
produce the same output as my sequential program, except that:
- The OpenMP program should get the number of threads to use
from environment variable OMP_NUM_THREADS.
- The Java program should get the number of threads to use
from environment variable NUM_THREADS.
(Commented-out code in the sequential Java program shows
how to do this.)
- Rather than printing ``sequential C/Java program results'',
- the OpenMP program should print
``parallel OpenMP program results with N threads''
(where N is replaced with the number of threads);
- the MPI program should print
``parallel MPI program results with N processes''
(where N is replaced with the number of processes);
and
- the Java program should print
``parallel Java program results with N threads''
(where N is replaced with the number of threads).
(You can make other changes to the output format if you
really want to, but be sure your code prints the same information
mine does.)
You can also make any changes you like to how the programs
work internally.
It's up to you how you choose to parallelize the sequential
code, but notice that in many respects the calculation here
strongly resembles the one in the numerical integration example,
so the approaches we used for that example might work well here too.
The only thing that's tricky is deciding what to do about the
random numbers (should all the processes/threads generate the
same sequence of random numbers? should they generate different
ones? if so, how?). For this assignment, I want you to make
your best guess about what would be reasonable, implement that,
and see how it works. After everyone has turned something in,
we'll discuss in class your results and possible improvements.
In addition to turning in your source code, briefly answer
the following questions about each of your programs:
- Does the program seem to generally give better results
as the number of samples increases? Can you say anything
interesting or useful about how the seed affects the
quality of the results?
- For the same number of samples and seed, does the program
give the same results no matter how many processes or
threads you use? If not, why do you think it doesn't?
- Does parallelism seem to help the program's performance?
You will probably need a fairly large number of samples
to observe any benefit, but up to a point more processes
or threads should give faster execution. Is this true
for your program? Support this with some observations
(output of your program showing number of samples,
number of processes/threads, etc., plus the name(s) of
the machine(s) used). If it's not true, what do you
think is going wrong?
Keep in mind that this assignment is a first pass at producing
good programs for this problem. Your programs should compile and
produce output that's more or less reasonable, but you will have
another chance (in Homework 2) to produce something that really
works well, so it's okay this time if the output seems slightly off,
or the performance is disappointing.
- Feel free to borrow code
from any of the sample programs linked from the
course sample programs page.
This page also contains links to my writeups about
compiling and running programs on the lab machines.
The
course ``useful links'' page
has pointers to documentation on OpenMP, MPI, and Java.
- You can develop your programs on any system that provides the
needed functionality, but I will test them on the department's
Linux classroom/lab machines, so you should probably make sure
they work in that environment before turning them in.
Submit source code and other files by sending mail to
bmassing@cs.trinity.edu,
with each file as an attachment.
Please use a subject line that mentions the course number and
the assignment (e.g., ``csci 3366 homework 1'').
If there's any question of which file(s) correspond to
which problems, explain in the body of the mail message.
Berna Massingill
2015-12-17