Outline of Class 26: Efficiency

Miscellaneous

• For today's class, you should have read columns 5, 8, and 9 of Bentley's Programming Pearls.
• For the next class, you should read column 1 of Bentley's More Programming Pearls.
• For the next class, you should learn all that you can about Java's profiling facilities (it does have some).
• Much of today's class will be kept unavailable until after some in-class discussion.
• We may have in-class visitors today (prospective students and/or other faculty). Faculty may also visit later this week.
• Just a reminder that I'm accepting applications for
  • Two student programmers (3 hpw) to work on web tools.
  • Up to five or so students interested in doing an independent study developing multimedia exercises for 103, 151, 152, and 153. More information on the independent study can be found at http://www.math.grin.edu/~rebelsky/Courses/397/98S/
• Since some of you asked ... no, I don't intend to give any more long assignments this term, and will give at most a few short (one hour or less) assignments.
• For next class, write an efficient (O(log_2(n))) tail-recursive exponentiation algorithm. Don't worry if you can't do it, but at least try.

Efficiency

• There are a number of things that make programs "good".
• Programs must be correct (or, more precisely, the output from a program must be correct). There is no use in running a program whose results you don't trust.
  • Note that approximately correct answers are only useful if the specification says "an approximate answer is acceptable" (and then it is arguable that the answer is correct).
  • We've looked at some techniques for making programs correct, such as assertions, preconditions, postconditions, and loop invariants.
• Programs must be usable. If you can't figure out how to use a program and how to interpret its results, the program is useless.
• Programs must be maintainable. Often, programs must be updated to incorporate new knowledge, new features, or even to correct bugs.
• Most modern languages focus on these and related issues.
• However, there is another issue we might consider: efficiency. A correct, usable, and maintainable program is still useless if it can't give you an answer quickly enough.
  • Should I invest in Microsoft today? If the answer comes tomorrow, it's no longer valid.
  • Is it reasonable to give radiation treatment at the current settings?. If it takes too long to answer this question, it becomes cost-prohibitive to use radiation treatment machines.
  • Please load the following page ... Most of us get sick of waiting before fifteen seconds have elapsed.
  • How much thrust and in what direction to correct my current course? We've seen what happens when this fails or takes too long.
• How do you make a program more efficient? Bentley suggests a number of techniques. As we saw in class last week, many improviements can build on previous improvements.

Techniques

• Understand your problem and specifications. Inefficient solutions are often due to over- or under-specified problems. We've seen many of these types of errors throughout bentley. By revisiting your specifications, you may find that you can approach the problem in a different way.
• Consider your algorithms and data structures. It is frequently worth the time to do a quick literature search for the more efficient solutions to your type of problem. You may also want to test and time variant solutions. For example, if you're trying to choose a sorting routine, you might first want to gather sample data that you're sorting and see which routine works best for that data.
  • You can use time and /bin/time to time your programs.
  • You can use some profilers to time your programs.
  • You can write your own timing routines.
  • ...
• Use the cheapest reasonable data type. This can apply to primitive types or to more structured types. A good understanding of your problem will help you make this decision.
• Pick an appropriate platform. Different languages and machines are appropriate for different kinds of tasks. Some languages are wonderful for development, user interfaces, and maintenance, but execute slowly.
  • As an experiment, I looked at a trace of the standard "Hello World" program in Java.
  • There were 146,000 virtual machine statements (plus "Entering x" and "Leaving x" notes) executed before the main was invoked.
  • Another 2,000 covered the Hello World and cleanup.
  • About 6000 total "Entering" and "Leaving" mesages were included.
• Use and understand your platform's optimizer. Many compilers (and even interpreters) provide a variety of optimizations, not all of which are appropriate for all programs. However, good optimizers can do a surprisingly good job with most code.
• Understand the costs of operations on your platform. You can easily implement a series of programs that tell you how long various operations take. For example, what is the overhead in going from floats to doubles, or from integers to floats? What is the difference in execution speed of add, multiply, and array references?
• Profile your program. It is said that 3% of the program often accounts for 50% of the running time. Find that 3% and fine-tune it.
• Segment your program into smaller parts. Often, this helps you better understand which portions are bottlenecks and makes it simpler to do some optimizations since you have fewer interrelationships between pieces of your programs.

Examples

A Simple Program

• Consider the following program

  public static void main(String args[]) {
    double d = 0.0;
    for (double n = 0.0; n < 1001.0; n = n + 1.0) {
      d += n;
    }
  } // main
  

• How might we improve the program?
  • We might convert our operations from doubles to longs, as we aren't taking advantage of integer operations.
  • We might start our loop at n=1 instead of n=0.
  • We might figure out what is being computed and use a formula for that instead.
  • ...
  • We might observe that since this program has no input and no output, it is effectively the null program and replace it with the null program.

Computing the Present Value of an Investment

• Suppose you were given the task of computing the present value of an investment, I, invested for Y years at a rate of R, compounded annually. How might you do it?
• You might take advantage of those amazing spreadsheet interfaces, start with something like

     |   A   |   B   |   C   |  D
   
  01   Year    Value     R    
   
  02     0       I
   
  03   =A1+1   =B2*(1+$C$1)
  

  and then "fill down"
• You might use the pv function in your spreadsheet or calculator.
• You might implement it in your programming language of choice. Here's a naive Java implementation.

  public static float
  presentValue(float investment, float rate, int years) {
    float interest;
    for (int i = 0; i < years; ++i) {
      // Compute this year's interest
      interest = investment*rate;
      // Update the investment
      investment = investment + interest;
    } // for
    return investment;
  } // presentValue
  

Improvements

• Here are some of my suggestions for improving our present-value program.
• Observe that we're simply computing I*(1+R)^Y. This allows us to eliminate an addition each time.
• Use a separate exponent() function. This compartmentalizes the program, and lets us think about future improvments.
• Use the O(log_2(n)) exponentiation function. If you haven't seen it before, it looks like

   /**
    * Compute x^n for double x and integer n
    * pre: n >= 0
    * pre: x > 0
    * pre: x^n < maxdouble (can't really check this, but ...)
    * post: returns x^n
    */
   public double exp(double x, int n) {
     double tmp;        // Used for intermediate calculations
     if (n == 0) {
       // x^0 = 1 for x != 0
       return 1.0;
     } // n is 0
     else if (even(n)) {
       // x^(2k) = x^k * x^k
       tmp = exp(x, n/2);
       return tmp*tmp;
     } // n is even
     else { // n is odd
       // x^(k+1) = x * x^k
       tmp = exp(x, n-1);
       return x*tmp;
     } // n is odd
   } // exp
  

• Make that function tail-recursive. That may not make much of a difference in Java, but it can in other languages, and it will help in our next step.
• Turn the recursive method into an interative method.
• Since we only need limited precision, use integers instead of doubles and divide by 100 when appropriate.
• Use a table (thanks to Jamal and others)