The University of North Carolina at Chapel Hill

COMP 144 Programming Language Concepts

Spring 2002

Lecture 34:
Code Optimization

Felix Hernandez-Campos
April 17

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
1
 Optimization

• We will discuss code optimization from the point of

view of the compiler and the programmer
• Code improvement is an important phase in
production compilers
– Generate code that runs fast (CPU-oriented)
» In some case, optimize for memory requirements or network
performance

• Optimization is an important task when developing

resource-intensive application
– E.g. Games, Large-scale services

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
2
 Optimization

• Two lectures on optimization

• References
– Scott’s Chapter 13
– Doug Bell, Make Java fast: Optimize!
» http://www.javaworld.com/javaworld/jw-04-1997/jw-04-optimize
_p.html
– HyperProf- Java profile browser
» http://www.physics.orst.edu/~bulatov/HyperProf/
– Python Performance Tips
» http://manatee.mojam.com/~skip/python/fastpython.html
– Python Patterns - An Optimization Anecdote
» http://www.python.org/doc/essays/list2str.html
COMP 144 Programming Language Concepts
Felix Hernandez-Campos
3
 The Golden Rules of Optimization
Premature Optimization is Evil
• Donald Knuth, premature optimization is the root of
all evil
– Optimization can introduce new, subtle bugs
– Optimization usually makes code harder to understand and
maintain
• Get your code right first, then, if really needed,
optimize it
– Document optimizations carefully
– Keep the non-optimized version handy, or even as a
comment in your code

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
4
 The Golden Rules of Optimization
The 80/20 Rule
• In general, 80% percent of a program’s execution
time is spent executing 20% of the code
• 90%/10% for performance-hungry programs
• Spend your time optimizing the important 10/20% of
your program
• Optimize the common case even at the cost of
making the uncommon case slower

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
5
 The Golden Rules of Optimization
Good Algorithms Rule
• The best and most important way of optimizing a
program is using good algorithms
– E.g. O(n*log) rather than O(n2)
• However, we still need lower level optimization to
get more of our programs
• In addition, asymthotic complexity is not always an
appropriate metric of efficiency
– Hidden constant may be misleading
– E.g. a linear time algorithm than runs in 100*n+100 time
is slower than a cubic time algorithm than runs in n3+10
time if the problem size is small
COMP 144 Programming Language Concepts
Felix Hernandez-Campos
6
 Asymptotic Complexity
Hidden Constants

Hidden Contants

3000

2500
Execution Time

2000
100*n+100
1500
n*n*n+10
1000

500

0
0 5 10 15
Problem Size

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
7
 General Optimization Techniques

• Strength reduction
– Use the fastest version of an operation
– E.g.
x >> 2 instead of x / 4
x << 1 instead of x * 2

• Common sub expression elimination

– Eliminate redundant calculations
– E.g.
double x = d * (lim / max) * sx;
double y = d * (lim / max) * sy;

double depth = d * (lim / max);

double x = depth * sx;
double y = depth * sy;
COMP 144 Programming Language Concepts
Felix Hernandez-Campos
8
 General Optimization Techniques

• Code motion
– Invariant expressions should be executed only once
– E.g.
for (int i = 0; i < x.length; i++)
x[i] *= Math.PI * Math.cos(y);

double picosy = Math.PI * Math.cos(y);

for (int i = 0; i < x.length; i++)
x[i] *= picosy;

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
9
 General Optimization Techniques

• Loop unrolling
– The overhead of the loop control code can be reduced by
executing more than one iteration in the body of the loop
– E.g.
double picosy = Math.PI * Math.cos(y);
for (int i = 0; i < x.length; i++)
x[i] *= picosy;

double picosy = Math.PI * Math.cos(y);

for (int i = 0; i < x.length; i += 2) {
x[i] *= picosy;
x[i+1] *= picosy; A efficient “+1” in array
indexing is required
}
COMP 144 Programming Language Concepts
Felix Hernandez-Campos
10
 Compiler Optimizations

• Compilers try to generate good code

– I.e. Fast
• Code improvement is challenging
– Many problems are NP-hard
• Code improvement may slow down the compilation
process
– In some domains, such as just-in-time compilation,
compilation speed is critical

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
11
Phases of Compilation

• The first three

phases are
language-
dependent
• The last two
are machine-
dependent
• The middle
two
dependent on
neither the
language nor
COMP 144 Programming Language Concepts
the machine
Felix Hernandez-Campos
12
 Phases

• Generating
highly
optimized is a
complicated
process
• We will
concentrate
on execution
speed
optimization

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
13
Phases

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
14
 Example
Control Flow Graph

• Basic blocks are

maximal-length set
of sequential
operations
– Operations on a set
of virtual registers
» Unlimited
» A new one for each
computed value

• Arcs represent
interblock control
flow
COMP 144 Programming Language Concepts
Felix Hernandez-Campos
15
 Peephole Optimization

• Simple compiler do not perform machine-

independent code improvement
– They generates naïve code
• It is possible to take the target hole and optimize it
– Sub-optimal sequences of instructions that match an
optimization pattern are transformed into optimal
sequences of instructions
– This technique is known as peephole optimization
– Peephole optimization usually works by sliding a window
of several instructions (a peephole)

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
16
Peephole Optimization
Common Techniques

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
17
Peephole Optimization
Common Techniques

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
18
Peephole Optimization
Common Techniques

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
19
Peephole Optimization
Common Techniques

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
20
 Peephole Optimization

• Peephole optimization is very fast

– Small overhead per instruction since they use a small,
fixed-size window
• It is often easier to generate naïve code and run
peephole optimization than generating good code!

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
21
 Reading Assignment

• Read Scott
– Ch. 13 intro
– Sect. 13.1
– Sect. 13.2
• Doug Bell, Make Java fast: Optimize!
– http://www.javaworld.com/javaworld/jw-04-1997/jw
-04-optimize_p.html

COMP 144 Programming Language Concepts

Felix Hernandez-Campos
22