Lab 4 2D Steady State Heat Conduct

ECE 4122/6122 Lab 4 (100 pts)
2D Steady State Heat Conduction in a Thin Plate
For this lab you will be writing a CUDA program to determine the steady state heat distribution
in a thin metal plate using synchronous iteration on a GPU. You will be solving Laplace's
equation using the finite difference method which has wide application in science and
engineering.
Consider a thin plate is perfectly insulated on the top and bottom which has known
temperatures along each of its edges. The objective is to find the steady state temperature
distribution inside the plate. The temperature of the interior will depend upon the
temperatures around it. We can find the temperature distribution by dividing the area into a
fine mesh of points, hi,j. The temperature at an inside point can be taken to be the average of
the temperatures of the four neighboring points, as illustrated below.
For this calculation, it is convenient to describe the edges by points adjacent to the interior
points. The interior points of hi,j are where 0 < i < n, 0 < j < n [(n -1) x (n - 1) interior points]. The
edge points are when i = 0, i = n, j = 0, or j = n, and have fixed values corresponding to the fixed
temperatures of the edges. Hence, the full range of hi,j is 0 ≤ 𝑖𝑖 ≤ 𝑛𝑛, 0 ≤ 𝑗𝑗 ≤ 𝑛𝑛, and there are
2
(n + 1) x (n + 1) points. We can compute the temperature of each point by iterating the
equation:
(0 ≤ 𝑖𝑖 ≤ 𝑛𝑛, 0 ≤ 𝑗𝑗 ≤ 𝑛𝑛) for a fixed number of iterations or until the difference between
iterations of a point is less than some very small prescribed amount. This iteration equation
occurs in several other similar problems; for example, with pressure and voltage. More complex
versions appear for solving important problems in science and engineering. In fact, we are
solving a system of linear equations. The method is known as the finite difference method. It
can be extended into three dimensions by taking the average of six neighboring points, two in
each dimension. We are also solving Laplace’sequation.
Suppose the temperature of each point is held in an array h[i][j] and the boundary points
h[0][x], h[x][0], h[n][x], and h[x][n] (0 ≤ x ≤ n) have been initialized to the edge temperatures.
The calculation as sequential code could be
using a fixed number of iterations. Notice that a second array g[][] is used to hold the newly
computed values of the points from the old values. The array h[][] is updated with the new
values held in g[][]. This is known as Jacobi iteration. Multiplying by 0.25 is done for computing
the new value of the point rather than dividing by 4 because multiplication is usually more
efficient than division. Normal methods to improve efficiency in sequential code carry over to
GPU code and should be done where possible in all instances. (Of course, a good optimizing
compiler would make such changes.)
3
Setup:
A perfectly insulted thin plate with the sides held at 20 °C and a short segment on one side is
held at 100 °C is shown below:
You need to write a C\C++ program using CUDA to solve the steady state temperature
distribution in the thin plate shown above. Your program needs to take the following command
line arguments:
1. -n 255 - the number of interior points.
2. -I 10000 – the number of iterations
Both command line arguments need to be defined and make sure your code check for invalid
command line arguments
Uses type double for your arrays.
Your code needs to output to the console the number of milliseconds it took to calculate the
solution using CUDA events.
Example:
Thin plate calculation took 123.456 milliseconds.
4
Your code needs to write out to a text file the final temperature values using a comma to
separate the values in the file “finalTemperatures.csv”. Each row of temperature values should
be on a separate line.
Turn-In Instructions:
Place all the files (*.h, *.cpp, *.cu) used in your solution into a zip file called Lab4.zip and upload to the Canvas
assignment.
Notes:
You can write, debug and test your code locally on your personal computer. However, the code you
submit must compile and run correctly on the PACE-ICE server.
 Execution Time is important for this lab.
Grading Rubric
AUTOMATIC GRADING POINT DEDUCTIONS PER PROBLEM:
Element Percentage Deduction Details
Does Not Compile 40% Code does not compile on PACE-ICE!
Execution Time Up to 8% 0 pts deducted < 10x shortest time
pts deducted = (2/10) (your time/shortest time) - 2
(rounded up to whole point value)
Does Not Match Output 10%-90% The code compiles but does not produce correct outputs.
Clear Self-Documenting
Coding Styles
10%-25% This can include incorrect indentation, using unclear
variable names, or unclear/missing comments. (See
Appendix A)
LATE POLICY
Element Percentage
Deduction
Details
Late Deduction Function score – 0.5*H H = number of hours (ceiling function) passed deadline
***You are free to post solution times on pizza so that other students can gauge their run times.
5
Appendix A: Coding Standards
Indentation:
When using if/for/while statements, make sure you indent 4 spaces for the content inside those. Also
make sure that you use spaces to make the code more readable.
For example:
for (int i; i < 10; i++)
{
 j = j + i;
}
If you have nested statements, you should use multiple indentions. Each { should be on its own line (like
the for loop) If you have else or else if statements after your if statement, they should be on their own
line.
for (int i; i < 10; i++)
{
 if (i < 5)
 {
 counter++;
 k -= i;
 }
 else
 {
 k +=1;
 }
 j += i;
}
Camel Case:
This naming convention has the first letter of the variable be lower case, and the first letter in each new
word be capitalized (e.g. firstSecondThird). This applies for functions and member functions as well! The
main exception to this is class names, where the first letter should also be capitalized.
Variable and Function Names:
Your variable and function names should be clear about what that variable or function is. Do not use one
letter variables, but use abbreviations when it is appropriate (for example: “imag" instead of
“imaginary”). The more descriptive your variable and function names are, the more readable your code
will be. This is the idea behind self-documenting code.
6
File Headers:
Every file should have the following header at the top
/*
Author: <your name>
Class: ECE4122 or ECE6122
Last Date Modified: <date>
Description:
What is the purpose of this file?
*/
Code Comments:
1. Every function must have a comment section describing the purpose of the function, the input
and output parameters, the return value (if any).
2. Every class must have a comment section to describe the purpose of the class.
3. Comments need to be placed inside of functions/loops to assist in the understanding of the flow
of the code.
Reference:
https://webpages.uncc.edu/abw/coit-grid01.uncc.edu/ITCS4145F12/Assignments/assign5F12.pdf