代写COMP528、代做c/c++，Python程序语言

University of Liverpool Assignment 2 Resit COMP528
In this assignment, you are asked to implement a numerical method for solving a partial
differential equation. This document explains the operation in detail, so you do not have to
have studied calculus. You are encouraged to begin work on this as soon as possible to avoid
the queue times on Barkla closer to the deadline. We would be happy to clarify anything
you do not understand in this report.
1 Laplace solver
Modelling heat transfer in a room can be done by using the Laplace equation, a second-order
partial differential equation. This can be approximated using a iterative stencil method.
Consider this two-dimensional array which represents a 25m2
room.
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 10 100
10 10 10 10 10 10 10 10 10 100
10 10 10 10 10 10 10 10 10 100
10 10 10 10 10 10 10 10 10 100
10 10 10 10 10 10 10 10 10 100
10 10 10 10 10 10 10 10 10 100
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 10 10
Figure 1: An example of the room
This two-dimensional array represents the space in the room, where the dimensions are NxN.
Each element in this array represents the temperature of that point within the room. The
boundaries of the array represent the walls. The points equal to 100, represent a radiator
within the room. The radiator always occupies 60% of the right wall and is centred. That is
the radiator starts at t [N−1][ffoor((N−1)∗0.3)], and ends at t [N−1][ceil((N−1)∗0.7)]
assuming 0 based indexing. Note that the room will always be 25m2
. That means the number
of the points only changes the resolution of the points in the room, not the actual size of the
room.
To model how the heat from the radiator moves throughout the room, we use the following
calculation for each point.
curr t[ i ][ j]=AVERAGE(prev t[i][j+1]+prev t[i][j−1]+prev t[i+1][j]+prev t[i−1][j])
Figure 2: The iterative calculation to ffnd the temperature moving through the room
2023-2024 1University of Liverpool Assignment 2 Resit COMP528
That is, each point is equal to the average of the surrounding points. When applying this to
Figure 1, we have these new temperatures. Figure 3 is after the ffrst iteration, and Figure
4 is after the second iteration.
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 32.5 100
10 10 10 10 10 10 10 10 32.5 100
10 10 10 10 10 10 10 10 32.5 100
10 10 10 10 10 10 10 10 32.5 100
10 10 10 10 10 10 10 10 32.5 100
10 10 10 10 10 10 10 10 32.5 100
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 10 10
Figure 3: An example of the room after one iteration
10 10 10 10 10 10 10 10 10 10
10 10 10 10 10 10 10 10 15.625 10
10 10 10 10 10 10 10 15.625 38.125 100
10 10 10 10 10 10 10 15.625 43.75 100
10 10 10 10 10 10 10 15.625 43.75 100
10 10 10 10 10 10 10 15.625 43.75 100
10 10 10 10 10 10 10 15.625 43.75 100
10 10 10 10 10 10 10 15.625 38.125 100
10 10 10 10 10 10 10 10 15.625 10
10 10 10 10 10 10 10 10 10 10
Figure 4: An example of the room after two iterations
We can observe that we do not update the boundary elements, in order to avoid any access
to memory that does not exist. To update the array, only the elements within the range of
indices from the second row to the second-to-last row (rows 1 to N-2) and from the second
column to the second-to-last column (columns 1 to N-2) should be modiffed.
2023-2024 2University of Liverpool Assignment 2 Resit COMP528
1.1 OpenMP laplace solver
You are asked to implement this operation in a C function with the following signature. This
function should be saved in a ffle called heat.c
double g e t fi n a l t e m p e r a t u r e s ( int N, int maxIter , double radTemp){
// . . . your code here
int pointx = f l o o r ((N−1 ) ∗ 0 . 5 );
int pointy = f l o o r ((N−1 ) ∗ 0 . 5 );
double r e s u lt = c u rr t [ pointx ] [ pointy ] ;
return r e s u lt ;
}
N is the number of points along one axis of the room matrix and maxIter is the number of
iterations to be performed in one run. Both pointX and pointY are the coordinates for the
centre of the room and therefore curr t[pointx][pointy] is the temperature at the centre of
the room. radTemp is the value for the radiator to be set to. Therefore the function returns
the temperature of the centre of the room for a given radiator temperature after maxIter
iterations have been performed.
1.2 Serial Implementation
You are asked to implement a sequential main C ffle which can do the following.
• Read a string of radiator temperatures from an input ffle and store them in a onedimensional
array.
• Call the ‘get ffnal temperature()‘ function for each temperature.
• Store the results in a one-dimensional array.
• Write the results to an output ffle.
Once compiled, the sequential program should be called like so:
$ ./

Where is the executable, is the size of N (deffnes the number of points
in the room), is the number of iterations to be performed for each radiator
temperature, and

is the name of the output ffle.
2023-2024 3University of Liverpool Assignment 2 Resit COMP528
1.3 Distributed implementation
This time, you are asked to implement a distributed main c ffle which can perform the same
functionality of the serial implementation, but distribute the radiator temperatures that are
read from the input ffle between MPI ranks.
Once compiled, the distributed program should be called like so:
$ mpirun −np ./

Where is the number of MPI processes. The other arguments given here
are the same as those explained for the serial version.
1.4 Data ffle format
The ffrst line of the input ffle has an integer. This integer deffnes the number of temperatures
in the ffle. The second line of the data ffle is a space-separated list of all the radiator temperature
values. The output ffle will follow the same format. The input ffles’ names follows:
input K.dat where K is the number of values.
The output ffles’ names provided follow: output K N maxIter where K is number of values,
and N and maxIter are the arguments explained above.
1.5 Provided code
You are provided with the code ffle-reader.c which contains the following functions.
• read num of temps: Which takes an input ffle’s name as an argument, and returns
the ffrst line of ffle (the number of radiator temperatures)
• read temps: Which takes the input ffle’s name and the numOfTemps as arguments,
and returns a one-dimensional array of temperatures.
• write to output ffle: Which takes the output ffle’s name, the array of room
temperatures found and the numOfTemps as arguments, and writes to an output
ffle.
2023-2024 4University of Liverpool Assignment 2 Resit COMP528
2 Instructions
• Implement a multi-threaded laplace solver using OpenMP. Save it in a ffle called heat.c.
• Modify the main-serial.c ffle so that it reads from the input data ffle, calls your OpenMP
stencil function, and writes to the output data ffle. Use the output to make sure your
implementation is correct. Ensure your code is saved as main-serial.c.
• Modify the main-mpi.c ffle so that it performs the same functionality as main-serial.c
but distributes the radiator temperatures over multiple MPI processes. Ensure it is
saved as main-mpi.c.
• Write a Makeffle that includes instructions to compile your programs. Your MakeFile
should work like so:
– make gccserial - compiles ‘main-serial.c‘, ‘heat.c‘ and ‘ffle-reader.c‘ into
‘heat-omp-gcc‘ with the GNU compiler (gcc)
– make gcccomplete - compiles ‘main-mpi.c‘, ‘heat.c‘ and ‘ffle-reader.c‘ into
‘heat-complete-gcc‘ with the GNU mpi compiler (mpicc)
– make iccserial - compiles ‘main-serial.c‘, ‘heat.c‘ and ‘ffle-reader.c‘ into
‘heat-omp-icc‘ with the Intel compiler (icc)
– make icccomplete - compiles ‘main-mpi.c‘, ‘heat.c‘ and ‘ffle-reader.c‘ into
‘heat-complete-icc‘ with the Intel mpi compiler (mpiicc)
• Try running your program for 1, 2, 4, 8, 16 and 32 OpenMP threads, measuring the
time taken in each instance. Use this to plot a speedup plot with speedup on the y-axis
and the number of threads on the x-axis.
• Test the fastest running instance (up to 8 threads) over 1, 2, 4, 8, 16 and 32 ranks i.e.
if you found that 4 OpenMP threads was the fastest, test this with 1, 2, 4, 8, 16, 32
ranks. Use this to draw a strong-scaling plot with time on the y-axis and the number
of ranks on the x-axis.
– The maximum number of nodes you will need for 8 OpenMP threads and 32 MPI
ranks is 8 nodes.
– You will potentially have to wait hours/potentially a few days if you submit to
multiple nodes. If there is little time until the deadline, test with 1 OpenMP
thread up to 32 ranks on the course node.
• When testing your program on Barkla to get your results for the speedup
and strong-scaling plot, ensure you test with N = 256 maxIter = 4096 with
the large input ffle input 1024.dat
2023-2024 5University of Liverpool Assignment 2 Resit COMP528
• Using up to one page for each code you produced (not including images), write a report
that describes:
– your implementation and parallel strategy for heat.c, and its speedup plot
– your implementation for main-serial.c
– your implementation and parallel strategy for main-mpi.c, and its strong-scaling
plot
– for each plot, how you measured and calculated it, including a table with your
times and why your program achieved a linear speedup/reduction in time or not
Include a screenshot of compiling and running your program, making sure your username
is visible.
• Your final submission should include:
1. heat.c - the parallel implementation using OpenMP.
2. main-serial.c - a main function that calls the function defined in heat.c to perform
the operations described above
3. main-mpi.c - the complete implementation using OpenMP and MPI.
4. Makefile - a MakeFile that can compile 4 different programs. The instructions
for this are given above.
5. Report.pdf - a pdf file containing the plots, descriptions, and screenshots.
6. The slurm script you used to run your code on Barkla.
• This assignment should be uploaded on Codegrade, following the instructions
present there.
• Failure to follow any of the above instructions is likely to lead to reduction in scores.
2023-2024 6University of Liverpool Assignment 2 Resit COMP528
3 Hints
If you get any segmentation faults when running your program, use a tool called gdb to help
debug. Read its manual to understand how to use it.
Make sure to test your code with small as well as big matrices.
Ensure that you are not printing the room temperatures when doing the large test. This will
greatly affect your runtime, especially for the large files.
The memory movement of copying curr t into prev t at the end of every iteration can have
big consequences on the time it takes for the program to run. It would be more efficient if
you had a 3-D array t[2][N][N]. You could switch between t[0][N][N] and t[1][N][N] depending
which is the current or previous iteration.
If your sequential run for N = 256 maxIter = 4096 with input 1024.dat is taking longer than
10 minutes, reconsider your strategy.
3.1 MakeFile
You are instructed to use a MakeFile to compile the code in any way you like. An example
of how to use a MakeFile can be used here:
{make command } : { t a r g e t f i l e s }
{compile command}
g c c s e r i a l : hea t . c main−s e r i a l . c f i l e −r e a d e r . c
gcc −fopenmp hea t . c main−s e r i a l . c f i l e −r e a d e r . c −o
heat−omp−gcc −lm
Now, on the command line, if you type ‘make gccserial‘, the compile command is automatically
executed. It is worth noting, the compile command must be indented. The target files
are the files that must be present for the make command to execute.
This command may work for you and it may not. The point is to allow you to compile
however you like. If you want to declare the iterator in a for loop, you would have to add the
compiler flag −std=c99. −fopenmp is for the GNU compiler and −qopenmp is for the
Intel Compiler. If you find that the MakeFile is not working, please get in contact as soon
as possible.
Contact: h.j.forbes@liverpool.ac.uk
2023-2024 7University of Liverpool Assignment 2 Resit COMP528
4 Marking scheme
1 Code that compiles without errors or warnings 5%
2 Same numerical results for test cases (tested on CodeGrade) 30%
3 Speedup plot (clean plot, correct axes and explained) 10%
4 Strong scaling plot (clean plot, correct axes and explained) 10%
5 Scaling efficiency up to 32 threads (tests on Barkla yields good scaling
efficiency for 1 Rank with 1, 2, 4, 8, 16, 32 OMP threads)
10%
6 Scaling efficiency up to 32 ranks (tests on Barkla yields good scaling
efficiency for 1, 2, 4, 8, 16, 32 ranks with 1 OMP thread)
10%
7 Clean code and comments (clean, well structured readable cde) 10%
8 Report (explained parallel strategy and implementation for each code
produced, i.e. why certain decisions were made to gain performance such
as why certain OMP directives/MPI calls used)
15%
Table 1: Marking scheme
The purpose of this assessment is to develop your skills in analysing numerical programs
and developing parallel programs using OpenMP and MPI. This assessment accounts for
35% of your final mark, however as it is a resit you will be capped at 50% unless otherwise
stated by the Student Experience Team. Your work will be submitted to automatic
plagiarism/collusion detection systems, and those exceeding a threshold will be reported to
the Academic Integrity Officer for investigation regarding adhesion to the university’s policy
https://www.liverpool.ac.uk/media/livacuk/tqsd/code-of-practice-on-assessmen
t/appendix_L_cop_assess.pdf.
5 Deadline
The deadline is 23:59 GMT Friday the 2nd of August 2024. https://www.liverp
ool.ac.uk/aqsd/academic-codes-of-practice/code-of-practice-on-assessment/
2023-2024 8