How to Get Credit
Announced on July 12th.
Experience a parallel programming and write a report. Specifications:
- Deadline: July 30th. However, since the
announcement was made very late, I will try to give you as much time
as possible. CONTACT ME AS SOON AS POSSIBLE if you consider working on
- Select one from the following programming models/libraries and
write a parallel program using the library.
- If you have a problem you want to solve in parallel, you are
encouraged to work on that problem. If the problem is too complex to
solve directly in a short amount of effort, feel free to make a
simplified version of the problem. Otherwise, you are advised to
find one related to your field.
Since GXP is a simple tool for running many commands in parallel
rather than a general programming model, the amount of work for
parallel problem solving will be smaller compared to other
solutions. Thus, if you take GXP, the problem you solve needs to have
some real significance as an application and you should get a real
speedup. You also should work with a not-small number of processes
(e.g., > 100).
- Alternatively, if you do not have a particular problem you want
to solve with a number of processors, you may conduct an in-depth
performance/scalability evaluation of one or several of the above
models. If you choose this option, put your emphasis on scalability
(what happens when a large number of nodes are involved). And you
should analyze the source of scalability bottlenecks if you find
one. For benchmarking, include many kinds of simultaneous
communication (broadcast, reductin, scatter, gather, all-to-all,
- Run your problem on a network of workstations using more than 30
processors. If you do not have an account on such a machine, I will
create one for you. If you choose the second option above, use as much
- Your report should include
The problem description should describe both the abstract model of the
problem, and its connection to the actual application.
- the problem description,
- high level description of the algorithm,
- the programming model you chose,
- the basics of the programming model,
- how you translated your algorithm into the actual code in the programming model chosen,
- an estimated resource consumption (time, memory, disk, etc.), and
- exeperimental results.
- Experimental results should include
If the speedup does not seem inadequate, analyze what is going on. You
may find a particular programming environment has an inherent
- machine specs (CPU, network, memory, etc.),
- where data (file) are stored and how they are accessed, if they are significant to your problem,
- single processor runtime if available,
- runtime on various numbers of processors up to the maximum
number of processors on which it worked (the larger the better). Draw a ``speed up curve''
(x-axis : number of processors, y-axis : speedup = single processor runtime /
runtime on that number of processors).