Lab 2: Performance Measurement Date: 12 June 2009 Number of Problems: 4

Transcription

1 Lab 2: Performance Measurement Date: 12 June 2009 Number of Problems: 4 Performance Measurement In the classroom, we learn how to measure and compare algorithm based on theoretical point of view using asymptotic notation. However, there are cases when you need to actually test your algorithm in real world and observe its behavior in practice. This lab concentrates on measuring performance of algorithm using experimental data. You will learn how to measure instruction count and real clock time that the algorithm uses. Moreover, you will learn how to interpret the empirical result and use it to improve theoretical analysis of the algorithm. In this lab, you will learn the following subject Writing output to file Measure real clock running time Measure instruction count Using GNUPlot to graphically analyze the data of the experiment Starting Code This lab involves several problem, each need several lines of code. Instead of having you going through the pain of writing everything again, a starting code for each problem is provided. You can download the starting code at a. Scoring Sheet At the end of this document, you will find the scoring sheet. This sheet lists the problem that you have to do plus some additional questions you need to answer. Try your best to answer the question. The grading of each problem is also done in this paper. Instructors and TAs will check your work and give his/her signature on this paper one your solution is correct. Remember that you can submit your solution as many times as you like. At the end of the lab, you must present this paper to TA.

2 Problem 0: Writing output to file Input: nothing Output: the file output.txt containing first 45 Fibonacci Numbers Objective The student can write an output to a file Introduction In the previous lab, we have learned how to display a text on a screen. For this lab, we are going to display the output to a text file. In C language, writing something to a text file can be done by the function int fprintf(file *stream, const char *format,...); which works similar to the printf we used in the previous lab. However, the function fprintf requires additional argument before the text to display. The required argument is a file pointer which is a variable that indicates the file to be written into. This problem asks you to write a program that display the first 46 Fibonacci numbers to a text file named output.txt. However, you need not to rewrite another Fibonacci number code. A starting code for this problem can be found in Folder named Lab2 Prob0. *** TASK1: Your task is to write a program that displays the first 45 Fibonacci numbers to the file output.txt *** File Pointer C interacts with file through a file pointer. A file pointer is declared as a type FILE*. It is link to the actual file on the disk by the function fopen which requires the file name and mode of operation of the file. Once a file pointer is created, it can be used to read and write data to the file in the same way as reading data from a keyboard or writing data to a screen. One additional requirement is that once the reading or writing is done, we need to release the file using the function fclose. The following code snippet shows how to write a text Hello, CP to a file. int main(int argc, char *argv[]) { FILE *fp; fp = fopen("output.txt","w"); fprintf(fp,"hello, CP!\n"); // declar a file pointer called fp // link fp to a file called "output.txt" // using "w" mode (writing mode) // write something to the file linked by fp } fclose(fp); return 0; // close the file, after this line, // fp cannot be used in fprintf

3 Starting Code The starting code can be found in folder Lab2 Prob0. The main file is main.c. It contains two functions: the main() function and the Fibo() function. The Fibo() function provide you the computation of Fibonacci number. You need not to modify it. You need to modify the main function such that the Fibonacci number is stored in the required text file.

4 Problem 1: GNUPlot and Hailstone Sequence Input: nothing Output: A file hailstone.txt containing the step used to compute the hailstone sequence of the starting value from 1 to 9999 Objective The student can measure number of operation used in a computation. The student can plot a graph using GNUPlot. The student can write simple while loop structure. Introduction There are several interesting sequences in Mathematics. Fibonacci number which was introduced in Lab 1 is one of them. For this lab, we will introduce another sequence known as Hailstone sequence. First, let us look at the following operation on an integer X. If X is even, divide it by 2 If X is odd, multiply it by 3 and add 1 Formally speaking, the operation is defined by this function /2 3 1 For example, if X is 5, this operation produces5 x The interesting thing is that if we repeat this operation over and over again, eventually, the number will become 1. For example, the previous example shows that 5 becomes 16, we then apply the operation on 16 which yield 8, we then apply it again yielding 4, then 2, then 1. The progress of this operation starting at X = 5 is the following sequence. 5, 16, 8, 4, 2, 1 Another example is when we start with X = 21, the resulting sequence is as follow. 21, 64, 32, 16, 8, 4, 2, 1 The sequence resulting from the operation is called a Hailstone sequence*. We define the length of the sequence as a number of operations performed to bring the starting value to 1. For example, the length of the Hailstone sequence of the starting number 5 is 5, the length of the Hailstone sequence of the starting number 21 is 7. Another interesting property of the sequence is that the length of sequence of each starting number is in irregular patter. For example, the length of the number 26 is 10 while the length of the number 27 is 111, taking the value up to around 9,000. In this problem, you are required to display the relation between the Hailstone starting number and the length of the sequence.

5 *** TASK2: This problem asks you to write a function to count the length of a Hailstone sequence of any positive integer. *** *** TASK3: This problem also asks you to draw a graph representing the relation between the starting number and the length of the associated Hailstone sequence. *** As in the Problem 0, you are not required to write everything. Your can open the project in the folder Lab2 Prob1 to find the starting code. In the code, you need to modify the Hailstone function to return the length of the given starting number. The given code computes the length of the starting number from 1 to 9,999 and save the starting number and the length into a file called Hailstone.txt. In the next section, you will learn how to use a tool called GNUPlot to display a graph using the data in Hailstone.txt. Starting Code The starting code can be found in folder Lab2 Prob1. You need to modify function int Hailstone(long x). The function should return the number of step that brings the starting number x to the number 1. The variable step in the function is declared to store the length of the sequence. No need is required for the other part. The main code already uses the function Hailstone() to record the number of step into the file Hailstone.txt. Using GNUPlot The result of this problem is a file named Hailstone.txt where each line contain a number X and L x where L x is the length of the Hailstone sequence starting at X. The first few lines of the file should be like this To have a better look at the meaning of this number, our next task is to draw a graph where the x axis is the starting number while the y axis is the length of the associated Hailstone sequence. This can be easily done by a tool called GNUPlot. 1. Download the GNUPlot for win32 from a and save it on Drive Z:\ 2. Extract the file gp425win32.zip on Z:\ which should give a folder called Z:\gnuplot

6 Figure 1: Extracting GNUPlot 3. Launch GNUPlot by opening the program Z:\gnuplot\bin\wgnuplot.exe Figure 2: Launching GNUPlot 4. The main interface of GNUPlot is shown as in Fig. 3. In most case, it will be unreadable. This could be fixed by changing the default font. This could be done by right click on the white area of the windows.

7 Figure 3: The main interface of GNUPlot 5. The font dialog should appear as in Fig. 4. Set the font to be Courier New and the size to be 10 and then click OK. Now, GNUPlot is ready to be used. Figure 4: Font Selection. 6. The next step is to tell GNUPlot that we would like to plot something from a file in our folder. Click on ChDir button to change the directory to this problem. That should be Z:\AlgoLab\Lab2 Prob1

8 Figure 5: Change the directory to our problem. 7. Tell GNUPlot to plot the data in file Hailstone.txt by typing plot hailstone.txt in the main interface of GNUPlot and press enter. Figure 6: Plot the file. 8. GNUPlot should produce a graph similar to Fig. 7. Call your TA to check up your answer.

9 Figure 7: Graph showing relation between the starting number and the length of the associated Hailstone sequence. Supplementary Explanation Collatz Conjecture Lothar Collatz, a German mathematician, conjectured in 1937 that, any positive integer can be used as a starting number in a Hailstone sequence, i.e., any positive number would eventually leads to 1 by the operation. However, no prove is found for his conjecture. It has been shown by computer program that positive integers from 1 up to around 5 trillion produce Hailstone sequence. No counter example is found until now. GNUPlot GNUPlot is a graphical data plotter. It can plot 2D and 3D graph as well as surface and function. You could try several commands in GNUPlot to experiment with it. For example, let us try the following commands: plot sin(x) plot sin(x) linewidth 2, cos(x) linewidth 2 plot 10 * x, x**2 splot sin(y) * cos(x) The official homepage of GNUPlot is at

10 Problem 2: Fibonacci by recursive and wall clock time Input: nothing Output: A file fibo.txt containing the time used to compute each Fibonacci Numbers using recursive method from 1 st to 40 th Fibonacci number. Objective The student can measure time used by an algorithm The student can empirically compare running time of several algorithms Introduction The Fibonacci sequences introduced in the previous lab can be computed by several approaches. The code given in the first lab and in the first problem of this lab using an approach called Dynamic Programming which will be covered later in the course. This method is very fast comparing to other approaches. In this problem, we will introduce another approach for Fibonacci Numbers. The Fibonacci number is defined recursively, thus, it is natural to compute the Fibonacci number using recursive method. This method, while it follows naturally from the definition of the sequence, is not a good approach. It takes much longer time than the Dynamic Programming approach. We would like to know the rate of growth of both approaches. The simplest way to do so is by experiment. This problem will set up an experiment to compare the time used by both approaches. Again, you are not required to write everything. You can open the project in the folder Lab2 Prob2 to find the starting code. The given code already has two functions implementing Fibonacci sequences in both approaches. What you need to do is to measure the time used by both method for each Fibonacci number. The time used by both approaches should be written to a file named fibo.txt. Each line of the file must contain three numbers; the first number is the index of the Fibonacci number, the second number and the third number are times, in seconds, used to compute the Fibonacci number using Dynamic Programming approach and Recursive approach, respectively. The example of the first few lines is as follows *** TASK4: Modify the code to record the time used to compute each Fibonacci number from both approach to a file named fibo.txt *** *** TASK5: Draw a graph representing the time used by both approaches for each Fibonacci number. The x axis represents the index of Fibonacci while y axis represents the time used, in seconds. ***

11 Starting Code The starting code can be found in Folder Lab2 Prob2. Two Fibonacci calculation functions are already provided. Fibo() computes Fibonacci numbers using Dynamic Programming Approach while Fibo2() does the same thing using recursive approach. Notice that the code already prepares the file pointer for you but you have to write the result to the file yourself. Supplementary Explanation Time Measurement Real world running time of an algorithm can be done easily. Basically, one must measure the current time before the algorithm start and measure the current time again after the algorithm stop. The difference between the two measured timestamp is the time used by the algorithm. Windows provides a very simple method to measure the time. A Win32 API function GetTickCount() return a long integer containing the time, in millisecond, since the machine start. This function can be used easily to measure the time. The following code snippet shows how to compute the time used by function Algo1(). #include <windows.h> int main(int argc, char *argv[]) { long starttime; long stoptime; starttime1 = GetTickCount(); Algo1(); stoptime1 = GetTickCount(); // the starting time // the starting time // measure the time before Algo1() // call the algorithm // measure the time after Algo1() } // display the measured time frintf( used time = %f seconds, double(stoptime starttime) / ); return 0; Plotting Two Graphs in the Same Screen GNUPlot is capable of plotting several graphs at the same time. For example, a command plot sin(x), cos(x) produces two graph showing a sinusoidal and cosine function. To plot a data from a file but using data from different columns in each line, one can use the following command. plot fibo.txt using 1:2, fibo.txt using 1:3 The first part of the plot command ( fibo.txt using 1:2) tells GNUPlot that we want to plot the data in the file fibo.txt where the X value is taken from the 1 st column and the Y value is taken from the 2 nd column. This is indicated by the keyword using. Similarly, the second part of the

12 plot command ( fibo.txt using 1:3) tells GNUPlot that the X value and the Y value are taken from the 1 st column and the 3 rd column. GNUPlot can also change the type and style of displaying graph. For example, the above example plots the graph using a dot. To plot the just the second graph using a thicker line and different color, the following code can be used. plot "fibo.txt" using 1:3 with line linecolor 7 linewidth 4 Win32 API Windows comes with several functions allowing us to interact with the system. GetTickCount() is one of them. They are collectively called as Win32 API, the functions ranges from snooping system information such as CPU speed, the size of physical ram, getting the current time, name of attached printer, the MAC address, to manipulating the windows such that creating a process, changing security policy, deleting a file and much more. A reference to the available function can be found at us/library/aa383749(vs.85).aspx

13 Problem 3: FindMax Input: nothing Output: A file maxcount.txt containing the average number that the maximum value is changed in the problem of finding maximum value in a random array Objective The student can measure average performance of algorithm on several instances of problem The student can empirically compare running time of several algorithms Introduction In the previous two problems, we measure the resource used for each instant of the problem, i.e., we count the time used for each possible input of the problem. In most case, the problem consists of several input size where each input size also has several problem instances. Each instances of the same size might have different running time. In this problem, we interest in measuring average performance of the algorithm for each size of input. The problem we will consider is Find Max. Find Max is a simple problem of identifying the maximum value in the array. It can be done using the following simple code. typedef int* intarray; // define array of integer type /** * Finding the max value in the array * Input: * data : the array containing integer * count : the size of data * return: * the largest element in data */ int findmax(intarray data,int count) { //find the max value in the array int i; int max = INT_MIN; // iterator // variable holding the current maximum value, // initially set to the minimal value of int } // check from the first member to the last member // keep track of current max value in "max" variable for (i = 0;i < count;i++) { if (data[i] > max) { max = data[i]; } } return max;

14 The process is straightforward. The array is scanned from the first to the last element and we keep track of the largest value up to the point of scanning. At i th iteration, the variable max contains the maximum value from datat[0] to data[i 1]. Every time that data[i] is larger than max, max is updated to contain data[i]. Now, it is clear that we have to scan the entire length of the array. The time complexity of this algorithm is clearly θ(n). However, let us assume that the process of updating max variable is very time consuming. We wish to know how many times the variable max is updated. Obviously, this depends on the value of data. For example if data is sorted,.e.g., data ={1,2,3,4,5,6}, max is updated every time. In the other hand, if data is sorted backward, e.g., data = {6,5,4,3,2,1}, max is updated only once. The starting code of this problem is given in the Folder Lab2 Prob3. This code randomly generates several arrays ranging from size 100 to 10,000. For each specific size, 100 arrays are generated. We wish to count the averaged number that max is updated for each size. Additionally, we also wish to understand the relation between the size of input and the number that max is updated. You are also required to plot the graph showing that relation. Notice that the starting code already has the opened file pointer for you. *** TASK6: Modify the code to record the number that the variable max is updated. The code must compute the average number that max is updated per each size of input. The result should be stored in maxcount.txt *** *** TASK7: Draw a graph representing the relation between the number that max is updated and the size of the array. The x axis represents the size of input while y axis represents the average number that max is updated. *** Starting Code The starting code can be found in Folder Lab2 Prob3. The code already has all algorithms implemented. What you need to do is to count the time that the variable max is updated for each input size. You might need to create more variable somewhere to count that value and you also need to average it over several runs. Notice again that the code already prepare a file pointer for you. There are three functions in the main file. The randomdata(intarray *data,int count) function generates random data for the given size. No need is required for this function. The function int findmax(intarray data,int count) finds the maximum value in the array. This is where you should do the counting. You also need to modify the main() function to store the result into the file as well. The average of the data should be done here.

15 Grading Sheet Name:. Date:. ID: Section:. Time:. Lab 2 : Performance Measurement Task Grading Task Description Grader Signature Remark 1 Making output.txt 2 Creating Hailstone.txt 3 Plot the hailstone sequence 4 Creating fibo.txt 5 Plotting a graph comparing two approaches 6 Creating maxcount.txt 7 Plotting a graph for maxcount.txt Question 1. What should best describe the relation between the size of input in Find Max problem and the number that max is updated? Is it linear or quadratic or logarithmic or something else? 2. Write down the Hailstone sequence starting from number Which starting number of Hailstone sequences from 1 to 9,999 that resulting in longest sequence? How long is that sequence?