The objectives of this assignment are

• to assemble and apply all our knowledge of parallel computation with MPI.
• to apply it to a problem that is not "embarassingly parallel" and poses a challenge because of the mix of serial steps and parallel steps.
• to do so for fun in a "contest" environment, with a prize to win for the best ultimate performance achieved by any combination of means for optimizing your code.
• to do so on a problem of great practical importance, a key step in virtually every approach to equation solving, namely triangular linear system solution.
• to do a design that defines and uses well specified subroutines whose implementation is the responsibility of individual programmers.

• to produce a better product through combination of knowledge, skills, ideas, effort of two or more people.
• to produce it in the little time remaining in the semester! Software development is done by teams in the "real world".

Solve the linear system of equations Ax = b, where A is an n by n lower triangular matrix, b is an n-vector, and x is the n-vector to be found. To say a matrix is lower triangular means that the A_(i,j) is zero whenever i < j. Here A_(i,j) denotes Entry(A, i, j).

The system can be expanded out as

A_(0,0)*x_0 = b_0,
A_(1,0)*x_0 + A_(1,1)*x_1 = b_1,
A_(2,0)*x_0 + A_(2,1)*x_1 + A_(2,2)*x_2 = b_2,
A_(3,0)*x_0 + A_(3,1)*x_1 + A_(3,2)*x_2 +A_(3,3)*x_3 = b_3,
A_(4,0)*x_0 + A_(4,1)*x_1 + A_(4,2)*x_2 +A_(4,3)*x_3 +A_(4,4)*x_4 = b_4,
...
A_(n-1,0)*x_0 + A_(n-1,1)*x_1 + ... + A_(n-1,n-1)*x_(n-1) = b_(n-1),

x_0 = ( b_0 )/ A_(0,0), 
x_1 = ( b_1 - A_(1,0)*x_0 )/ A_(1,1),
x_2 = ( b_2 - A_(2,0)*x_0 - A_(2, 1)*x_1 )/ A_(2,2),
x_3 = ( b_3 - A_(3,0)*x_0 - A_(3, 1)*x_1 - A_(3, 2)*x_2 )/ A_(3,3),
x_4 = ( b_4 - A_(4,0)*x_0 - A_(4, 1)*x_1 - A_(4, 2)*x_2 - A_(4, 3)*x_3 )/ A_(4,4),
...
x_(n-1) = ( b_(n-1) - A_(n-1,0)*x_0 - A_(n-1,1)*x_1 - ... - A_(n-1,n-2)*x_(n-2) 

Specifically, your team writes the function ltsolve() specified in triangular.c Your function will be separately compiled and linked with a main function similar to triangular.c for the contest measurement.

1. Deliverable 0. Due now. Group formation: Individually let me know if you would like to do this project with a different grouping than for the research project.
2. Individual project deliverable (Nov 30): The group must define some subroutines needed to complete the project. Define the subroutine and precisely specify the syntax of the call (the signature of the procedure) and the semantics (what is required of the inputs, what is promised of the outputs). Each team member is assigned one or more of these subroutines to do. The individual project consists of implementing the subroutine and a supporting test caller to test out that subroutine in the absence of the rest of the project. The deliverable is to submit your subroutine, it's test driver, and sample runs giving evidence of correctness. If the design calls for each individual to do several simpler subroutines, that is well and good. Submit several subroutines and their tests.
3. Group deliverable 1 (Dec 5). Submit your code as plain ascii email (not an attachment) prior to class Wednesday, Dec 5. We will run the contest timings on that day. For this project no writeup or further analysis is required, however well documented code which is good stylistically (easy to read) is expected. You may find it helpful to run your code through the program "indent". "Well documented" means that there is a header comment explaining your implementation of ltsolve(). This includes restating the input/outputs specification of the function and also an explanation of your parallel strategy and other optimization efforts. Also place a concise helpful comment at the beginning of each major section of the code.
4. Optional Group deliverable 2 (Dec 12). Anticipating that there may be some glitches in the contest, we plan to allow some revision and resubmission. Any revised results that ensue from that will be reported at the beginning of the final exam.