Slideshare uses cookies to improve functionality and performance, and to provide you with relevant advertising. If you continue browsing the site, you agree to the use of cookies on this website. See our User Agreement and Privacy Policy.

Slideshare uses cookies to improve functionality and performance, and to provide you with relevant advertising. If you continue browsing the site, you agree to the use of cookies on this website. See our Privacy Policy and User Agreement for details.

Like this presentation? Why not share!

No Downloads

Total views

706

On SlideShare

0

From Embeds

0

Number of Embeds

6

Shares

0

Downloads

3

Comments

0

Likes

1

No embeds

No notes for slide

- 1. Analysis of Algorithms ‣ estimating running time ‣ mathematical analysis ‣ order-of-growth hypotheses ‣ input models ‣ measuring spaceReference: Algorithms in Java, Chapter 2 Intro to Programming in Java, Section 4.1 Except as otherwise noted, the content of this presentation http://www.cs.princeton.edu/algs4 is licensed under the Creative Commons Attribution 2.5 License. Algorithms in Java, 4th Edition · Robert Sedgewick and Kevin Wayne · Copyright © 2008 · May 2, 2008 10:35:54 AM
- 2. Running time “ As soon as an Analytic Engine exists, it will necessarily guide the future course of the science. Whenever any result is sought by its aid, the question how many times do you have to turn the crank? Charles Babbage (1864) Analytic Engine 2
- 3. Reasons to analyze algorithmsPredict performance. this course (COS 226)Compare algorithms.Provide guarantees.Understand theoretical basis. theory of algorithms (COS 423) client gets poor performance because programmer did not understand performance characteristicsPrimary practical reason: avoid performance bugs. 3
- 4. Some algorithmic successesDiscrete Fourier transform.• Break down waveform of N samples into periodic components.• Applications: DVD, JPEG, MRI, astrophysics, ….• Brute force: N2 steps. Freidrich Gauss• FFT algorithm: N log N steps, enables new technology. 1805 time quadratic 64T 32T 16T linearithmic 8T linear size 1K 2K 4K 8K Linear, linearithmic, and quadratic 4
- 5. Some algorithmic successesN-body Simulation.• Simulate gravitational interactions among N bodies.• Brute force: N2 steps.• Barnes-Hut: N log N steps, enables new research. Andrew Appel PU 81 time quadratic 64T 32T 16T linearithmic 8T linear size 1K 2K 4K 8K Linear, linearithmic, and quadratic 5
- 6. ‣ estimating running time‣ mathematical analysis‣ order-of-growth hypotheses‣ input models‣ measuring space 6
- 7. Scientific analysis of algorithmsA framework for predicting performance and comparing algorithms.Scientific method.• Observe some feature of the universe.• Hypothesize a model that is consistent with observation.• Predict events using the hypothesis.• Verify the predictions by making further observations.• Validate by repeating until the hypothesis and observations agree.Principles.• Experiments must be reproducible.• Hypotheses must be falsifiable.Universe = computer itself. 7
- 8. Experimental algorithmicsEvery time you run a program you are doing an experiment! Why is my program so slow ?First step. Debug your program!Second step. Choose input model for experiments.Third step. Run and time the program for problems of increasing size. 8
- 9. Example: 3-sum3-sum. Given N integers, find all triples that sum to exactly zero.Application. Deeply related to problems in computational geometry. % more 8ints.txt 30 -30 -20 -10 40 0 10 5 % java ThreeSum < 8ints.txt 4 30 -30 0 30 -20 -10 -30 -10 40 -10 0 10 9
- 10. 3-sum: brute-force algorithm public class ThreeSum { public static int count(long[] a) { int N = a.length; int cnt = 0; for (int i = 0; i < N; i++) for (int j = i+1; j < N; j++) for (int k = j+1; k < N; k++) check each triple if (a[i] + a[j] + a[k] == 0) cnt++; return cnt; } public static void main(String[] args) { int[] a = StdArrayIO.readLong1D(); StdOut.println(count(a)); } } 10
- 11. Measuring the running timeQ. How to time a program?A. Manual. 11
- 12. Measuring the running timeQ. How to time a program?A. Automatic. Stopwatch stopwatch = new Stopwatch(); ThreeSum.count(a); double time = stopwatch.elapsedTime(); StdOut.println("Running time: " + time + " seconds"); client code public class Stopwatch { private final long start = System.currentTimeMillis(); public double elapsedTime() { long now = System.currentTimeMillis(); return (now - start) / 1000.0; } } implementation 12
- 13. 3-sum: initial observationsData analysis. Observe and plot running time as a function of input size N. N time (seconds) † 1024 0.26 2048 2.16 4096 17.18 8192 137.76 † Running Linux on Sun-Fire-X4100 13
- 14. Empirical analysisLog-log plot. Plot running time vs. input size N on log-log scale. slope = 3 power lawRegression. Fit straight line through data points: c N a. slopeHypothesis. Running time grows cubically with input size: c N 3. 14
- 15. Prediction and verificationHypothesis. 2.5 × 10 –10 × N 3 seconds for input of size N.Prediction. 17.18 seconds for N = 4,096.Observations. N time (seconds) 4096 17.18 4096 17.15 agrees 4096 17.17Prediction. 1100 seconds for N = 16,384.Observation. N time (seconds) agrees 16384 1118.86 15
- 16. Doubling hypothesisQ. What is effect on the running time of doubling the size of the input? N time (seconds) † ratio 512 0.03 - 1024 0.26 7.88 2048 2.16 8.43 4096 17.18 7.96 8192 137.76 7.96 numbers increases running time increases by a factor of 2 by a factor of 8 lg of ratio is exponent in power law (lg 7.96 ≈ 3)Bottom line. Quick way to formulate a power law hypothesis. 16
- 17. Experimental algorithmicsMany obvious factors affect running time:• Machine.• Compiler.• Algorithm.• Input data.More factors (not so obvious):• Caching.• Garbage collection.• Just-in-time compilation.• CPU use by other applications.Bad news. It is often difficult to get precise measurements.Good news. Easier than other sciences. e.g., can run huge number of experiments 17
- 18. ‣ estimating running time‣ mathematical analysis‣ order-of-growth hypotheses‣ input models‣ measuring space 18
- 19. Mathematical models for running timeTotal running time: sum of cost × frequency for all operations.• Need to analyze program to determine set of operations.• Cost depends on machine, compiler.• Frequency depends on algorithm, input data. Donald Knuth 1974 Turing AwardIn principle, accurate mathematical models are available. 19
- 20. Cost of basic operations operation example nanoseconds † integer add a + b 2.1 integer multiply a * b 2.4 integer divide a / b 5.4 floating point add a + b 4.6 floating point multiply a * b 4.2 floating point divide a / b 13.5 sine Math.sin(theta) 91.3 arctangent Math.atan2(y, x) 129.0 ... ... ... † Running OS X on Macbook Pro 2.2GHz with 2GB RAM 20
- 21. Cost of basic operations operation example nanoseconds † variable declaration int a c1 assignment statement a = b c2 integer compare a < b c3 array element access a[i] c4 array length a.length c5 1D array allocation new int[N] c6 N 2D array allocation new int[N][N] c7 N 2 string length s.length() c8 substring extraction s.substring(N/2, N) c9 string concatenation s + t c10 NNovice mistake. Abusive string concatenation. 21
- 22. Example: 1-sumQ. How many instructions as a function of N? int count = 0; for (int i = 0; i < N; i++) if (a[i] == 0) count++; operation frequency variable declaration 2 assignment statement 2 less than comparison N+1 equal to comparison N between N (no zeros) and 2N (all zeros) array access N increment ≤ 2N 22
- 23. Example: 2-sumQ. How many instructions as a function of N? int count = 0; for (int i = 0; i < N; i++) for (int j = i+1; j < N; j++) if (a[i] + a[j] == 0) count++; 1 0 + 1 + 2 + . . . + (N − 1) = N (N − 1) operation frequency 2 N = 2 variable declaration N+2 assignment statement N+2 less than comparison 1/2 (N + 1) (N + 2) equal to comparison 1/2 N (N − 1) tedious to count exactly array access N (N − 1) increment ≤ N2 23
- 24. Tilde notation• Estimate running time (or memory) as a function of input size N.• Ignore lower order terms. - when N is large, terms are negligible - when N is small, we dont careEx 1. 6 N 3 + 20 N + 16 ~ 6N3Ex 2. 6 N 3 + 100 N 4/3 + 56 ~ 6N3Ex 3. 6 N 3 + 17 N 2 lg N + 7 N ~ 6N3 discard lower-order terms (e.g., N = 1000 6 trillion vs. 169 million) f (N) Technical definition. f(N) ~ g(N) means lim = 1 N→ ∞ g(N) € 24
- 25. Example: 2-sumQ. How long will it take as a function of N? int count = 0; for (int i = 0; i < N; i++) for (int j = i+1; j < N; j++) if (a[i] + a[j] == 0) count++; "inner loop" operation frequency cost total cost variable declaration ~ N c1 ~ c1 N assignment statement ~ N c2 ~ c2 N less than comparison ~ 1/2 N 2 c3 ~ c3 N 2 equal to comparison ~ 1/2 N 2 array access ~ N2 c4 ~ c4 N 2 increment ≤ N2 c5 ≤ c5 N 2 total ~ cN2 25
- 26. Example: 3-sum 478 Algorithms and Data StruQ. How many instructions as a function of N? public class ThreeSum { the leading term of mathemati public static int count(int[] a) { pressions by using a mathem int N = a.length; device known as the tilde no int cnt = 0; 1 We write f (N) to represe for (int i = 0; i < N; i++) quantity that, when divided b for (int j = i+1; j < N; j++) N inner for (int k = j+1; k < N; k++) ~N / 2 2 approaches 1 as N grows. W loop if (a[i] + a[j] + a[k] == 0) ~N / 6 3 write N g (N)N (Nf − 1)(N −to indicat = (N) 2) 3 3! cnt++; g (N) f (N)1approaches 1 as N ∼ N3 6 return cnt; depends on input data With this notation, we can } complicated parts of an exp public static void main(String[] args) that represent small values. F { int[] a = StdArrayIO.readInt1D(); ample, the if statement in Thr int cnt = count(a); is executed N 3/6 times b StdOut.println(cnt); } N (N 1)(N 2)/6 N 3/6 N }Remark. Focus on instructions in inner loop; ignore everything else!N/3, which certainly, when div Anatomy of a program’s statement execution frequencies N 3/6, approaches 1 as N grow notation is useful when the ter ter the leading term are relativ 26 signiﬁcant (for example, when N = 1000, this assumption amounts to sayi 2
- 27. Mathematical models for running timeIn principle, accurate mathematical models are available.In practice,• Formulas can be complicated.• Advanced mathematics might be required.• Exact models best left for experts. costs (depend on machine, compiler) TN = c1 A + c2 B + c3 C + c4 D + c5 E A = variable declarations B = assignment statements frequencies C = compare (depend on algorithm, input) D = array access E = incrementBottom line. We use approximate models in this course: TN ~ c N3. 27
- 28. ‣ estimating running time‣ mathematical analysis‣ order-of-growth hypotheses‣ input models‣ measuring space 28
- 29. Common order-of-growth hypothesesTo determine order-of-growth:• Assume a power law TN ~ c N a.• Estimate exponent a with doubling hypothesis.• Validate with mathematical analysis. N time (seconds) †Ex. ThreeSumDeluxe.java 1,000 0.43Food for thought. How is it implemented? 2,000 0.53 4,000 1.01 8,000 2.87 16,000 11.00 32,000 44.64 64,000 177.48 observationsCaveat. Cant identify logarithmic factors with doubling hypothesis. 29
- 30. 482 Algorithms and Data StructuresCommon order-of-growth hypotheses Linearithmic. We use the term linearithmic to describe programs whose running time for a problem of size N has order of growth N log N. Again, the base of theGood news. the smallrelevant. For example, CouponCollector (PROGRAM 1.4.2) is lin- logarithm is not set of functions earithmic.N, prototypical example 2, mergesort (see PROGRAM 4.2.6). Several im- 1, log The N, N log N, N is N3, and 2N portant problems have natural solutions that are quadratic but clever algorithmssuffices to describe order-of-growth of typical algorithms. impor- that are linearithmic. Such algorithms (including mergesort) are critically tant in practice because they enable us to address problem sizes far larger than could be addressed with quadratic solutions. In the next section, we consider a general design technique for developing time growth rate linearithmic algorithms. name T(2N) / T(N) 1024T Quadratic. A 1 constant 1 exponential typical program whose c tic cubi lin mic dra 512T h running time has order of growth N 2 r rit ea log N logarithmic ~1 qua ea lin has two nested for loops, used for some calculation involving all pairs linear ele- N of N 2 64T ments. The force update double loop in NBody (PROGRAM 3.4.2) is a linearithmicof N log N prototype ~2 the programs in this classiﬁcation, as is the elementaryN2 quadratic sorting algorithm Inser- 4 8T tion (PROGRAM 4.2.4). 4T N 3 cubic 8 2T Cubic. Our example for this section, logarithmic N 2 exponential T(N) ThreeSum, is cubic (its running time has T constant order of growth N 3) because it has three size 1K 2K 4K 8K 1024K nested for loops, to process all triples of N elements. The running time of matrix factor for Orders of growth (log-log plot) multiplication, as implemented in SEC- doubling hypothesis TION 1.4 has order of growth M 3 to mul- tiply two M-by-M matrices, so the basic matrix multiplication algorithm is often considered to be cubic. However, the size of the input (the number of entries in the 30 matrices) is proportional to N = M 2, so the algorithm is best classiﬁed as N 3/2, not cubic.
- 31. Common order-of-growth hypothesesgrowth name typical code framework description example rate 1 constant a = b + c; statement add two numbers while (N > 1) log N logarithmic { N = N / 2; ... } divide in half binary search for (int i = 0; i < N; i++) N linear { ... } loop find the maximum divideN log N linearithmic [see lecture 5] mergesort and conquer for (int i = 0; i < N; i++) N2 quadratic for (int j = 0; j < N; j++) double loop check all pairs { ... } for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) N3 cubic for (int k = 0; k < N; k++) triple loop check all triples { ... } exhaustive check all 2N exponential [see lecture 24] search possibilities 31
- 32. Practical implications of order-of-growthQ. How long to process millions of inputs?Ex. Population of NYC was "millions" in 1970s; still is. seconds equivalent 1 1 secondQ. How many inputs can be processed in minutes? 10 10 secondsEx. Customers lost patience waiting "minutes" in 1970s; 102 1.7 minutesthey still do. 103 17 minutes 104 2.8 hours 105 1.1 daysFor back-of-envelope calculations, assume: 106 1.6 weeks 107 3.8 months processor instructions decade speed per second 108 3.1 years 1970s 1 MHz 106 109 3.1 decades 1980s 10 MHz 107 1010 3.1 centuries 1990s 100 MHz 108 … forever 2000s 1 GHz 109 1017 age of universe 32
- 33. Practical implications of order-of-growth problem size solvable in minutes time to process millions of inputsgrowth rate 1970s 1980s 1990s 2000s 1970s 1980s 1990s 2000s 1 any any any any instant instant instant instant log N any any any any instant instant instant instant tens of hundreds of N millions billions minutes seconds second instant millions millions hundreds of hundreds of tens ofN log N millions millions hour minutes seconds thousands millions seconds tens of N2 hundreds thousand thousands decades years months weeks thousands N3 hundred hundreds thousand thousands never never never millennia 33
- 34. Practical implications of order-of-growth effect on a program that runs for a few secondsgrowth name description rate time for 100x size for 100x more data faster computer 1 constant independent of input size - - log N logarithmic nearly independent of input size - - N linear optimal for N inputs a few minutes 100xN log N linearithmic nearly optimal for N inputs a few minutes 100x N2 quadratic not practical for large problems several hours 10x N3 cubic not practical for medium problems several weeks 4-5x 2N exponential useful only for tiny problems forever 1x 34
- 35. ‣ estimating running time‣ mathematical analysis‣ order-of-growth hypotheses‣ input models‣ measuring space 35
- 36. Types of analysesBest case. Running time determined by easiest inputs.Ex. N-1 compares to insertion sort N elements in ascending order.Worst case. Running time guarantee for all inputs.Ex. No more than ½N2 compares to insertion sort any N elements.Average case. Expected running time for "random" input.Ex. ~ ¼ N2 compares on average to insertion sort N random elements. 36
- 37. Commonly-used notations notation provides example shorthand for used to 10 N 2 provide Tilde leading term ~ 10 N 2 10 N 2 + 22 N log N approximate model 10 N 2 + 2 N +37 N2 asymptotic classifyBig Theta Θ(N 2) 9000 N 2 growth rate algorithms 5 N 2 + 22 N log N + 3N N2 develop Big Oh Θ(N 2) and smaller O(N 2) 100 N upper bounds 22 N log N + 3 N 9000 N 2 developBig Omega Θ(N 2) and larger Ω(N 2) N5 lower bounds N 3 + 22 N log N + 3 N 37
- 38. Commonly-used notationsEx 1. Our brute-force 3-sum algorithm takes Θ(N 3) time.Ex 2. Conjecture: worst-case running time for any 3-sum algorithm is Ω(N 2).Ex 3. Insertion sort uses O(N 2) compares to sort any array of N elements;it uses ~ N compares in best case (already sorted) and ~ ½N 2 compares in theworst case (reverse sorted).Ex 4. The worst-case height of a tree created with union find with pathcompression is Θ(N).Ex 5. The height of a tree created with weighted quick union is O(log N). base of logarithm absorbed by big-Oh 1 loga N = logb N logb a 38
- 39. Predictions and guaranteesTheory of algorithms. Worst-case running time of an algorithm is O(f(N)).Advantages• describes guaranteed performance. time/memory• O-notation absorbs input model. f(N)Challenges values represented• by O(f(N)) Cannot use to predict performance.• Cannot use to compare algorithms. input size 39
- 40. Predictions and guaranteesExperimental algorithmics. Given input model,average-caserunning time is ~ c f(N).Advantages. time/memory• Can use to predict performance.• Can use to compare algorithms. c f(N) values representedChallenges. by ~ c f(N)• Need to develop accurate input model.• May not provide guarantees. input size 40
- 41. ‣ estimating running time‣ mathematical analysis‣ order-of-growth hypotheses‣ input models‣ measuring space 41
- 42. Typical memory requirements for primitive types in JavaBit. 0 or 1.Byte. 8 bits.Megabyte (MB). 210 bytes ~ 1 million bytes.Gigabyte (GB). 220 bytes ~ 1 billion bytes. type bytes boolean 1 byte 1 char 2 int 4 float 4 long 8 double 8 42
- 43. Typical memory requirements for arrays in JavaArray overhead. 16 bytes on a typical machine. type bytes type bytes char[] 2N + 16 char[][] 2N2 + 20N + 16 int[] 4N + 16 int[][] 4N2 + 20N + 16 double[] 8N + 16 double[][] 8N2 + 20N + 16 one-dimensional arrays two-dimensional arraysQ. Whats the biggest double[] array you can store on your computer? typical computer in 2008 has about 1GB memory 43
- 44. M 3.2.1) object uses 32ee double instance vari- Typical memory requirements for objects in Java ny programs create mil- the information needed Object overhead. 8 bytes on a typical machine.or transparency). A refer- Reference. 4 bytes on a typical machine.n a data type contains a 4 bytes for theEach Complex object consumes 24 bytes of memory. Ex 1. referencey needed for the object’s (Program 3.2.1) public class Complex 32 bytes 8 bytes overhead for objectclass Charge { object private double re; 8 bytes overheadate double rx; private double im; 8 bytesate double ry; rx ... doubleate double q; ry } values 24 bytes qct (Program 3.2.6) 24 bytesclass Complex object overheadate double re;ate double im; re double im valuesJava library) 12 bytes 44class Color object overheadate byte r;
- 45. ... values q }omplex object (Program 3.2.6) 24 bytes public class Typical memory requirements for objects in Java Complex { object overhead private double re; private double im; re double ... Object overhead. im bytes on a 8 values typical machine. } Reference. 4 bytes on a typical machine.olor object (Java library) 12 bytes public class Color { Ex 2. A String of length object overhead N consumes 2N + 40 bytes. private byte r; private byte g; r g b a private byte b; private byte a; ... public class String byte 8 bytes overhead for object } values { private int offset; 4 bytesocument object (Program 3.3.4) 16 bytes + string + vector private int count; 4 bytes public class Document { private int hash; object 4 bytes overhead private String id;private char[] value; 4 bytes for reference private Vector profile; id ... references (plus 2N + 16 bytes for array) ... profile } } 2N + 40 bytesring object (Java library) 24 bytes + char array public class String { object overhead private char[] val; private int offset; value reference private int count; offset private int hash; int count values ... } hash 45 Typical object memory requirements
- 46. Example 1Q. How much memory does this program use as a function of N ? public class RandomWalk { public static void main(String[] args) { int N = Integer.parseInt(args[0]); int[][] count = new int[N][N]; int x = N/2; int y = N/2; for (int i = 0; i < N; i++) { // no new variable declared in loop ... count[x][y]++; } } } 46
- 47. Example 2Q. How much memory does this code fragment use as a function of N ? ... int N = Integer.parseInt(args[0]); for (int i = 0; i < N; i++) { int[] a = new int[N]; ... }Remark. Java automatically reclaims memory when it is no longer in use. 47
- 48. Out of memoryQ. What if I run out of memory? % java RandomWalk 10000 Exception in thread "main" java.lang.OutOfMemoryError: Java heap space % java -Xmx 500m RandomWalk 10000 ... % java RandomWalk 30000 Exception in thread "main" java.lang.OutOfMemoryError: Java heap space % java -Xmx 4500m RandomWalk 30000 Invalid maximum heap size: -Xmx4500m The specified size exceeds the maximum representable size. Could not create the Java virtual machine. 48
- 49. Turning the crank: summaryIn principle, accurate mathematical models are available.In practice, approximate mathematical models are easily achieved.Timing may be flawed?• Limits on experiments insignificant compared to other sciences.• Mathematics might be difficult?• Only a few functions seem to turn up.• Doubling hypothesis cancels complicated constants.Actual data might not match input model?• Need to understand input to effectively process it.• Approach 1: design for the worst case.• Approach 2: randomize, depend on probabilistic guarantee. 49

No public clipboards found for this slide

×
### Save the most important slides with Clipping

Clipping is a handy way to collect and organize the most important slides from a presentation. You can keep your great finds in clipboards organized around topics.

Be the first to comment