C++ Optimization Activity

Transcription

1 C++ Optimization Activity BEFORE ANY MEASUREMENT RUN FORCE A REBUILD. ADD A SPACE AND RECOMPILE. SUCCESSIVE RUNS WILL GIVE BETTER TIMES DUE TO PROGRAM BEING CACHED. 1. Start with the Optimization project from the classroom files link (or BitBucket). Open the project in QT Creator, and switch to a release build: If you want to build/run from the command prompt, use the -O2 ( oh 2 ) flag to turn on level 2 optimizations. Do not use the g (debug info) flag. Actual compiler call would look like: g++ -O2 -std=c++11 main.cpp o program.exe 2. Build and run it will read in SIZE (currently one Meg) number of integers into an array and then calculate the number of digits in each number, storing those into the array digitcounts. It also totals them and returns them from main, mostly so the compiler won't optimize away our hard work. It repeats all this work RUNS times to produce more accurate numbers (limited granularity of timer). Tune the const RUNS so that the program takes ~5 seconds (don't worry about being exact, anywhere from 4-10 is fine). Record this time as 5a) in your assignment 3. The code currently reads from a text file. Modify it to read the same values from a binary file. Change the file open line to: infile.open("data.dat", ios::binary); Then change the line that reads in values to the binary IO equivalent that reads 4 bytes into the address of the current element: infile.read(reinterpret_cast<char*>(&numbers[i]), 4); Time this version. 4. Doing small bits of IO (even in binary mode) is generally much less efficient than fewer large blocks. Remove the for loop that is reading in values and replace it with the instruction to read in the bytes for the entire array in one pass: infile.read(reinterpret_cast<char*>(numbers), SIZE * 4); Record this time as 5b) in your assignment 5. We now want to focus on non IO code. Take the lines that do the file IO (open the file, read and close it) and move them before the first call to clock() (right after the total = 0 line). You can rebuild/run to test how much the IO was now contributing to the overall run time. Retune the RUNS parameter so that you are back to ~5 seconds total run time. Record this time as 5c) in your assignment - this will be the baseline for future attempts to optimize the code

2 6. Instead of using two separate arrays of ints (numbers and digitcounts), try using one array that consists of a struct that stores the number and its number of digits together. A struct called numdata is already defined, as is an array of them. Original version is going through two separate arrays: numbers0 numbers1 numbers2 numbers3 numbers4 digitcounts0 digitcounts1 digitcounts2 digitcounts3 digitcounts4 New version will go through an array of structs that pack a number next to its digit count: combined[0].number combined[0].digitcount combined[1].number combined[1].digitcount Add code to copy the data that is read in from the file to the array of structs. These lines of code should go after the input file is closed but before the clock starts: for(int i = 0; i < SIZE; i++) { combined[i].number = numbers[i]; (Reading into the array then copying it is of course not terribly efficient, but we aren't timing this part and are just trying to keep life simple.) Now comment out the work loop (where we call numdigits) and add this code instead to do the same work using the array of structs instead of 2 arrays: for(int i = 0; i < SIZE;i++) { combined[i].digitcount = numberofdigits(combined[i].number); total += combined[i].digitcount; Build/run this version. Record this time as 5d) in your assignment. In this case, does packing the data into an array of structs help or hurt our use of the cache? Revert back to the original work loop - the code you had before step 6. (Since we are not timing it anyway, you can leave in the code that copies numbers into the struct or get rid of it).

3 7. Unroll the work loop make it count by 4 and do four calculations per iteration. Comment out the existing work loop and replace it with: for(int i = 0; i < SIZE; i += 4) { digitcounts[i] = numberofdigits(numbers[i]); total += digitcounts[i]; digitcounts[i+1] = numberofdigits(numbers[i+1]); total += digitcounts[i+1]; digitcounts[i+2] = numberofdigits(numbers[i+2]); total += digitcounts[i+2]; digitcounts[i+3] = numberofdigits(numbers[i+3]); total += digitcounts[i+3]; Optional - unroll to do 8 steps per iteration. Record this time as 5e) in your assignment. How much of a speedup over 5c is it? Comment out/remove the modified version and restore the original. 8. Doubles are supposed to be slower than ints let's see by what factor. Comment out the existing numberofdigits function and replace it with the following: int numberofdigits(float x) { while(x > 10) { digits++; x /= 10; If anything, this version should do a little less work than the int version but it does it with floating points. Run and record slowdown vs no-io base. Record this time as 5f) in your assignment. (For fun you can try double instead of float or "long long" to force it to use 64 bit integers when we are compiling it to run in 32bit-mode (assuming you are on windows). Either of these changes should make things worse.). 9. Multiplication is generally significantly faster than division. Replace the function with a version that uses multiplication: int sizer = 10; while(x > sizer) { digits++; sizer *= 10; Build/run. Record this time as 5g) in your assignment. What is the speedup over 5c?

4 10. Time for a strength reduction inside the numberofdigits function. Replace it with this code: while(x > 0) { if(x < 10) return digits ; if(x < 100) return (digits + 1) ; if(x < 1000) return (digits + 2); x /= 1000; digits += 3; It reduces the number of divides, trading them for a lot of extra comparison instructions. Build and run. Record this time as 5h) in your assignment. What is the speedup over 5c? 11. We can cut down on the average number of comparisons we do per iteration by adding yet another comparison. Replace numberofdigits with this: while(x > 0) { if(x >= 1000) { x /= 1000; digits += 3; else { if(x < 10) return digits ; if(x < 100) return (digits + 1) ; if(x < 1000) return (digits + 2); Build and run. You don't need to record this one. 12. Sometimes brute force is best try this no math version of digit count: int numberofdigits(int v) { return (v < 10 )? 1 : (v < 100)? 2 : (v < 1000)? 3 : (v < )? 4 : (v < 10000)? 5 : (v < )? 6 : (v < )? 7 : (v < )? 8 : 9; Record this time as 5i) in your assignment. What is the speedup over 5c?

5 13. The inline keyword tells the compiler to try to eliminate doing a function call by copying the code from the function to the calling location. The compiler may do so without the keyword, but the keyword encourages the process, especially for longer functions. Put the keyword inline in front of the int numberof Digits: inline int numberofdigits Build and run. Did it speed things up? Inline doesn't always help the longer/more complicated the function the less likely inline is to help; in lining too many things (and too many copies of things) can make code that uses fewer branches but takes up more memory and doesn't fit into cache as well. 14. Challenge: Combine any of the above techniques (and anything else you can think of) to try to minimize the run time. You still have to do all the same basic work calculate the number of decimal digits in each number, store that in the array and add it to the total. See how far below the no-io base time you can get it.