Measuring Where CPU Time Goes Profiling Code Measuring Where CPU Time Goes

My Code Is Too Slow – Why? Look at code  what O() is it? Loading: O(N) unavoidable and OK O(N2)  not good if N can get big Look-ups If you’ll do something N times, try to keep it O(1) or O(log N)

My Code is Complex! Can’t figure out O() Or O() looks OK, but still not fast enough Profile! Measure where the time goes

Simple Profiling: Manual Random Sampling Run the debugger Stop it with Debug  Pause Look at the subroutine and line where you paused Examine the call stack to see how you got there Continue execution with Debug  Continue More time in a routine  higher probability of stopping there Usually stop in same routine  found the problem

Detailed Profiling: gprof Tool Randomly samples the function your program is in ~ every 1 ms Also records how it got there (call stack / call graph) Then summarizes the output for you How is this random sampling done? Program asks to be interrupted ~1000x / second by operating system Each interrupt  record function you are in

gprof Tool: How to Use Compile your program with the right options Select profile configuration or make CONF=profile Adds –pg option to compiler  instruments exe Turns off function inlining  all function calls exist  easier to interpret

gprof Tool: How to Use Run program normally ./mapper Collects statistics, stores in big file (gmon.out) Program runs only a little slower (~30%) Run gprof to summarize / interpret output gprof mapper > outfile.txt Reads gmon.out, generates readable outfile.txt Even better: can visualize (graphics) gprof mapper gmon.out | gprof2dot . py -s | xdot - ECE 297 Profiling Quick Start Guide

Example: Extract Negatives #include <vector> using namespace std; vector<int> extract_negatives (vector<int>& numbers) { vector<int> negatives; int i = 0; while(i < numbers.size()) { if(numbers[i] < 0) { negatives.push_back(numbers[i]); numbers.erase(numbers.begin() + i); } else { i++; //Next element } return negatives; Takes 30 s when given an 800,000 element vector. Too slow  why?

Visualized Call Graph Extract negatives called once by main Takes 71% of time Type equation here. push_back() Estimated 37% of time This is an over-estimate: sample-based profiling isn’t perfect Erase called over 640,000 times Takes 53% of time  biggest problem

Milestone 4: Courier Company

Problem Definition C B D C A D A B Given N deliveries (pick up, drop off) N = 4 here, all intersections and Given M courier truck depots M = 3 here, all intersections Return: low travel time path Starting and ending at some depot And reaching all 2N delivery intersections And always picking up a package before delivering it

No  dropping off packages before they’re picked up! Possible Solution? C B D C A D A B No  dropping off packages before they’re picked up!

Output: vector of street segment ids Legal Solution C B D C A D A B Output: vector of street segment ids

Simple Solution: Re-use m3 path-finder // Go from first depot to first package pick up path = find_path (depot[0], delivery[0].pickUp); // Complete deliveries, in order for (i = 0; i < N-1; i++) { path += find_path (delivery[i].pickUp, delivery[i].dropOff); path += find_path (delivery[i].dropOff, delivery[i+1].pickUp); } // Drop off last package path += find_path (delivery[N-1].pickUp, delivery[N-1].dropOff); // Go back to the first depot to drop off the truck path += find_path (delivery[N-1].dropOff, depot[0]);

Possible Solution C B D C A D 2 A B 1 Lots of wasted travel!

Need to optimize delivery order! More Logical Solution C B D C A D A B Need to optimize delivery order!

Exhaustive Algorithm? Try all possible delivery orders Pick the one with lowest travel time How many combinations? M truck depots N deliveries  2N pick-up + drop-off intersections Pick one of M starting locations Then pick one of 2N pick-up/drop-off intersections Then one of 2N-1 for the second intersection … (repeat until last delivery) Then M places to drop off truck M * 2N * (2N-1) * (2N-2) * … * 1 * M = M2 (2N)! Some of these are illegal orders  say algorithm checks legality after generating the solution

Exhaustive Algorithm? Say M = 10, N = 100 102 * (2N)!  10377 Invoke find_path () 2N+1 times to get path between each intersection Say find_path takes 0.1 s (very good!) 10377 * 201 * 0.1 s = 1.6 x 10378 s 5 x 10370 years! Lifetime of universe: ~14 x 109 years!

Traveling Salesman Problem We are solving a variation of the traveling salesman problem Computationally hard problem For N deliveries, no guaranteed optimal (lowest travel time solution) in polynomial time i.e. > O(Nk), for any k Means at least O(2N) Need to use heuristics to solve Most research problems are computationally hard Integrated circuit design, drug design, transportation network design, …

Stephen Cook: Pioneer of Complexity Theory U of T professor in Computer Science NP-complete problems No polynomial time solution known on conventional computers Proved: If a method to solve any of these problems in polynomial time found, Then all these problems can be solved in polynomial time P vs. NP: most famous open problem in computer science 1970: denied tenure at UC Berkeley 1971: published most famous paper 1982: won Turing award

Not guaranteed to find best answer, but run in a reasonable time Heuristic Algorithms Not guaranteed to find best answer, but run in a reasonable time

Heuristic 1 Ideas? Overall: O(M*N) + O(N*N) + O(M) = O(M*N + N2) Go from any depot to nearest pickup, p while (packages to deliver) drop off package at delivery[p].dropOff p = nearest remaining pickup } Go to nearest depot O(M*N) N iterations O(N) O(M) Overall: O(M*N) + O(N*N) + O(M) = O(M*N + N2)