Chapter 3: Code Optimization and

Code Version Control

Code Optimization
 Why
 Reduce programmers’ burden
 Allow programmers to concentrate on high level concept
 Without worrying about performance issues
 Target
 Reduce execution time
 Reduce space
 Sometimes, these are tradeoffs
 Types
 Intermediate code level
 We are looking at this part now
 Machine code level
 Instruction selection, register allocation, etc.
Code Optimization
 Scope
 Peephole analysis
 Within one or a few instructions
 Local analysis
 Within a basic block
 Global analysis
 Entire procedure or within a certain scope
 Inter-procedural analysis
 Beyond a procedure, consider the entire program
Code Optimization
 Techniques
 Constant propagation
 Constant folding
 Algebraic simplification, strength reduction
 Copy propagation
 Common subexpression elimination
 Unreachable code elimination
 Dead code elimination
 Loop Optimization
 Function related
 Function inlining, function cloning
Code Optimization Techniques
 Constant propagation
 If the value of a variable is a constant, then replace the variable by
the constant
 It is not the constant definition, but a variable is assigned to a constant
 The variable may not always be a constant
 E.g.
N := 10; C := 2;
for (i:=0; i<N; i++) { s := s + i*C; }
 for (i:=0; i<10; i++) { s := s + i*2; }
If (C) go to …  go to …
 The other branch, if any, can be eliminated by other optimizations
 Requirement:
 After a constant assignment to the variable
 Until next assignment of the variable
 Perform data flow analysis to determine the propagation
Code Optimization Techniques
 Constant folding
 In a statement x := y op z or x := op y
 If y and z are constants
 Then the value can be computed at compilation time
 Example
#define M 10
x := 2 * M  x := 20
If (M < 0) goto L  can be eliminated
y := 10 * 5  y := 50
 Difference: constant propagation and folding
 Propagation: only substitute a variable by its assigned constant
 Folding: Consider variables whose values can be computed at
compilation time and controls whose decision can be determined at
compilation time
Code Optimization Techniques
 Algebraic simplification
 More general form of constant folding, e.g.,
 x+0x x–0x
 x*1x x/1x
 x*00
 Repeatedly apply the rules
 (y * 1 + 0) / 1  y

 Strength reduction
 Replace expensive operations
 E.g., x := x * 8  x := x << 3
Code Optimization Techniques
 Copy propagation
 Extension of constant propagation
 After y is assigned to x, use y to replace x till x is assigned again
 Example
x := y;  s := y * f(y)
s := x * f(x)
 Reduce the copying
 If y is reassigned in between, then this action cannot be performed
Code Optimization Techniques
 Common subexpression elimination
 Example:
a := b + c a := b + c
c := b + c  c := a
d := b + c d := b + c
Code Optimization Techniques
 Unreacheable code elimination
 Construct the control flow graph
 Unreachable code block will not have an incoming edge
 After constant propagation/folding, unreachable branches can be
eliminated
 Dead code elimination
 Ineffective statements
 x := y + 1 (immediately redefined, eliminate!)
 y := 5  y := 5
 x := 2 * z x := 2 * z
 A variable is dead if it is never used after last definition
 Eliminate assignments to dead variables
 Need to do data flow analysis to find dead variables
Code Optimization Techniques
 Function inlining
 Replace a function call with the body of the function
 Save a lot of copying of the parameters, return address, etc.
 Function cloning
 Create specialized code for a function for different calling
parameters
Code Optimization Techniques
 Loop optimization
 Consumes 90% of the execution time
 a larger payoff to optimize the code within a loop
 Techniques
 Loop invariant detection and code motion
 Strength reduction in loops
 Loop unrolling
 Loop peeling
Code Optimization Techniques
 Loop invariant detection and code motion
 If the result of a statement or expression does not change within a
loop, and it has no external side-effect
 Computation can be moved to outside of the loop
 Example
for (i=0; i<n; i++) a[i] := a[i] + x/y;
 Three address code
for (i=0; i<n; i++) { c := x/y; a[i] := a[i] + c; }
 c := x/y;
for (i=0; i<n; i++) a[i] := a[i] + c;
Code Optimization Techniques
 Strength reduction in loops
 Example
s := 0; for (i=0; i<n; i++) { v := 4 * i; s := s + v; )
 s := 0; for (i=0; i<n; i++) { v := v + 4; s := s + v; )
Code Optimization Techniques
 Loop unrolling
The goal of loop unwinding is to increase a program's speed by
reducing or eliminating instructions that control the loop, such as
pointer arithmetic and "end of loop" tests on each iteration; reducing
branch penalties; as well as hiding latencies including the delay in
reading data from memory.
 Execute loop body multiple times at each iteration
 Get rid of the conditional branches, if possible
 Space time tradeoff: Increase in code size, reduce some instructions

 Loop peeling
 Loop peeling is a special case of loop splitting which splits any
problematic first (or last) few iterations from the loop and performs
them outside of the loop body.
Version Control
Why version control?
 Scenario 1:
 Your program is working
 You change “just one thing”
 Your program breaks
 You change it back
 Your program is still broken--why?

 Has this ever happened to you?

Why version control? (part 2)
 Your program worked well enough yesterday
 You made a lot of improvements last night...
 ...but you haven't gotten them to work yet
 You need to turn in your program now

 Has this ever happened to you?

18
Version control for teams
 Scenario:
 You change one part of a program--it works
 Your co-worker changes another part--it works
 You put them together--it doesn’t work
 Some change in one part must have broken something in the other
part
 What were all the changes?

19
 Teams (part 2)
 Scenario:
 You make a number of improvements to a class
 Your co-worker makes a number of different improvements to the same
class
 How can you merge these changes?

20
Version control systems
 A version control system (often called a source code
control system) does these things:
 Keeps multiple (older and newer) versions of everything (not just
source code)
 Requests comments regarding every change
 Allows “check in” and “check out” of files so you know which
files someone else is working on
 Displays differences between versions

21
Control the process automatically
Manage these things using a version control system (VCS)
A version control system is a system which allows for the
management of a code base.

22
Details of the process
Files are kept in a repository
Repositories can be local or remote to the user
The user edits a copy called the working copy
Changes are committed to the repository when
the user is finished making changes
Other people can then access the repository to get the
new code
Can also be used to manage files when working across
multiple computers

23
24
 Centralised Version Control

 A single server holds the code base

 Clients access the server by means of check-in/check-outs
 Examples include CVS, Subversion, Visual Source Safe.
Advantages: Easier to maintain a single server.
Disadvantages: Single point of failure.

25
26
Distributed Version Control
 Each client (essentially) holds a complete copy of the code
base.
 Code is shared between clients by push/pulls
 Advantages: Many operations cheaper. No single point of failure
 Disadvantages: A bit more complicated!

27
28
What is Git

29
What is Git
 https://www.youtube.com/watch?v=9GKpbI1siow

 https://www.youtube.com/watch?v=DqtZUvmPmo4

30