## Description

Tasks:

Write the following programs:

1) make-matrix -n 100 -l 0 -u 100 -o output_file

This program writes to output_file a binary file with an n by n (square) matrix or a size n vector if

the –v flag is included.

These represent one of the matrix or vedctor to be multiplied, where the value of each element of

the matrix or vector is randomly generated based on a uniform random variable on the interval ‘l’

to ‘u’. Data is 64-bit double precision floating point and the number n is stored as the first word

of the file (this is an integer). Should be stored in row major order.

2) print-matrix input_file

Reads a matrix file created with 1) and prints in ascii. Should work with both matrix and vector

files.

3) mv-serial input_matrix1 input_vector2 output_vector3

Reads 2 input matrix/vector files and computes the product of the matrix in input_matrix1 with

the vector in input_vector2 and then writes resulting product into the output_vector3. This should

be easy to get working – then you can use it to check your parallel code.

3) mpirun -np __ mv-parallel input_matrix1 input_vector2 output_vector3

Reads 2 input files and computes the product of the matrix in input_matrix1 with the vector in

input_vector2, and then writes the resulting product into the output_vector3. This method will

implement the checkerboard decomposition. You may require the number of rows and columns of

the matrix to be evenly divided by the square of the number of processors (which should be

square). You must use an MPI topology to manage communication between tasks. Your matrix

should be represented in memory as presented in class and in the book with an array of doubles

and an array of pointers to double. You should test your code using 9, 16, 25, and 36 tasks.

Your program will need to use a problem size large enough to keep your program running for

somewhere between 30sec and 3min. The larger the better. Since nodes are updated frequently, I

honestly don’t know the best problem size. It could be 1000, 5000, or 10000. You can run the

program with difference values and look at the run time until it seems reasonable. Once someone

has this information it can be shared with other classmates (would not be cheating). You need at

least 3 different problem sizes for computing speedups.

Use your sequential program to generate results that you can compare with your parallel results

for correctness and to compute speedup. With your parallel program, use MPI_WTime to

calculate the run time and output this to standard along with the number of MPI tasks and

problem size (n, size of vector). This is going to require at least 12 runs of your program (each

number of tasks with each problem size). Once you have gathered this data gather the data with

the same problem size and compute speedups

All your source files should be in a single directory. The name of that directory should be

firstname_lastname_MV. Inside that directory, you can have the files called what you want,

along with all of the source and a Makefile . Also, all of your source files (mains, source, and

headers) should have a comment block at the top that has your information and identify the file.

Also, all programs must be documented well with copious comments. This directory should be

zip (or .tar.gz) with the same name as the underlying directory. Upload on Canvas by the

specified time.