Optimization in Programming languages

CODE OPTIMIZATION

IN

PROGRAMMING LANGUAGE

Ankit Pandey

Code Optimization

Why To derive the best possible performance from the given

resources .

To balance Speed and Memory Tradeoffs according to requirements.

More emphasis is on writing efficient code (Smart code) Faster execution

Efficient memory usages

Yielding better performance

What Optimization is the process of transforming a piece of code

to make it more efficient.

It does not change the meaning of program.

Code Optimization

Code Optimization Techniques

Constant propagation

Constant folding

Algebraic simplification, strength reduction

Copy propagation

Code Optimization

Techniques for Speed optimization

Constant propagation

Constant folding

Algebraic simplification, strength reduction

Copy propagation

Common subexpression elimination

Unreacheable code elimination

Dead code elimination

Loop Optimization

Function related

Code Optimization

Techniques for Memory optimization

Reduce Padding

Local Vs Global Variables


Constant Propagation If the value of a variable is a constant, then replace the

variable by the 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; }

Constant Folding Simplifying constant expressions as much as possible

E.g.static final int a = 2; int b = 30 * a;

// folding would create

int b = 60;


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 Motion (Out of loops)

A modification that decreases the amount of code in a loop.

Invariant expressions should be executed only once.

E.g.

for (int i = 0; i < x.length; i++)

x[i] *= Math.PI * Math.cos(y);

Code motion will result in the equivalent of

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

for (int i = 0; i < x.length; i++)

x[i] *= picosy;


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


Common sub expression elimination

Searches for instances of identical expression, replacing them with a single variable holding the computed value (if possible)

Example:a := b + c a := b + c

c := b + c c := a

d := b + c d := b + c

Example in array index calculations c[i+1] := a[i+1] + b[i+1]

During address computation, i+1 should be reused

Not visible in high level code, but in intermediate code


Unreacheable code elimination

Construct the control flow graph

Unreachable code block will not have an incoming edge

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


Function inlining

Replace a function call with the body of the function.

Program will spend less time in the function call and return parts, etc.

It has also some disadvantages – Increase program size and break

encapsulation.

Function cloning

Create specialized code for a function for different calling parameters


Loop optimization Is the process of the increasing execution speed and

reducing the overheads associated of loops.

Consumes 90% of the execution time

a larger payoff to optimize the code within a loop

Techniques Loop invariant detection and code motion

Induction variable elimination

Strength reduction in loops

Loop unrolling

Loop peeling

Loop fusion


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 the outside of the loop

Examplefor (i=0; i<n; i++) a[i] := a[i] + x/y;

for (i=0; i<n; i++) { c := x/y; a[i] := a[i] + c; } // three address code

c := x/y; for (i=0; i<n; i++) a[i] := a[i] + c;

Induction variable elimination

If there are multiple induction variables in a loop, can eliminate the ones which are used only in the test condition

Examples := 0; for (i=0; i<n; i++) { s := s + 4; }

s := 0; while (s < 4*n) { s := s + 4; }


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; )

Loop Termination The loop termination condition can cause significant

overhead if written without caution.

Should always write count-down-to-zero loops and use simple termination conditions.

Exampleint fact1_func (int n) { int i, fact = 1; for (i = 1; i <= n; i++)

int fact1_func (int n) { int i, fact = 1; for (i = 1; i <= n; i++)


Loop unrolling Execute loop body multiple times at each iteration

Get rid of the conditional branches, if possible

Allow optimization to cross multiple iterations of the loop Especially for parallel instruction execution

Space time tradeoff Increase in code size, reduce some instruction

Example

for(i=0; i<3; i++) { something(i); }

After loop unrolling –

for(i=0; i<3; i++){

something(0); something(1); something(2);}

Loop peeling Similar to unrolling

But unroll the first and/or last iterations


Loop fusion

Some adjacent loops can be fused into one loop to reduce loop overhead and improve run-time performance.

Examplefor i=1 to N do

A[i] = B[i] + 1

endfor

for i=1 to N do

C[i] = A[i] / 2

endfor

for i=1 to N do

D[i] = 1 / C[i+1]

endforBefore Loop Fusion

for i=1 to N do

A[i] = B[i] + 1

C[i] = A[i] / 2

D[i] = 1 / C[i+1]

endfor


Memory based Optimization

Reduce Padding

Declare local variables based on their size. Prefer to declare larger to smaller data type variables.

E.g.

struct

{ char x;

int y; }

Here size of struct is 4 bytes !!!!!

Points to be remember while using Register variable –


Let us discuss one more example –/* sizeof = 64 bytes */ /*sizeof = 48 bytes */

struct foo sturct foo

{ float a; { double b;

double b; double d;

float c; long f;

double d; long h;

short e; float c;

long f; float a;

short g; int j;

long h; int l;

char i; short e;

int j; short g;

char k; char k;

int l; }; char I;};


Local Vs Global Variables

Local variables are stored in registers.

Keep the number of local variables low to allow them to be fit in the

available registers and avoid stack usage.

Global Variables are stored in RAM.

Manipulating and accessing local variables is less costly

as it uses registers compared to accessing from memory.

Avoid referring to global or static variables inside the

tightest loops, instead use local variables.

Declare local variables in the inner most scope.


Locality of Reference

Local variables are stored in registers.

Keep the number of local variables low to allow them to be fit in the

available registers and avoid stack usage.

Global Variables are stored in RAM.

Manipulating and accessing local variables is less costly

as it uses registers compared to accessing from memory.

Avoid referring to global or static variables inside the

tightest loops, instead use local variables.

Declare local variables in the inner most scope.

Code Optimization tricks in „C‟

Language Usages of Register Variables

Use Register variables whenever possible.

Accessed from register rather from memory, so accessing

is faster.

E.g.

register float val;

register double dval;

register int ival;

Points to be remember while using Register variable -

Only declare those variables as register which are heavily used

We can not take the address of register variable , so never try this.

&ival would fail.


Language

String Operations Most of the C library str* functions operate in time

proportional to the length(s) of the string(s) they are given.

Avoid calling strlen( ) during a loop involving the string itself.

strcat( ) will scan the full (current) length of the string on each call. If you've been keeping track of the length anyway , you can index directly to the end of the string and strcpy to there.

Try to avoid stecmp( ) as much as possible. If is not then try to use it smartly!!!

Try to avoid empty string test using strlen() function.

Avoid strlen(s) == 0 use *s == „\0‟

Avoid strcpy(s, “ ”) use *s = „\0‟


Language Aliasing – It do optimization , try it!!!!

Consider the following:

void func1( int *data ) {

int i;

for(i=0; i<10; i++)

{ somefunc2( *data, i); }

}

Optimized code after aliasing :

void func1( int *data ) {

int i; int localdata;

localdata = *data;

for(i=0; i<10; i++) {

somefunc2( localdata, i); } }


Language

Miscellaneous

Use unsigned int instead of int if we know the value will never be negative.

Avoid unnecessary division.

For eg - (a / b) > c can be rewritten as a > (c * b)

Use shift operations >> and << instead of integer multiplication and division, where possible.

Try to use Switch in place of nested if…elseif…elseif…else

Prefer Integer comparison.

Avoid calculations in loop and try to use simplify expression.

Try to minimize usages of global variables. They are never allocated to registers.

use the prefix operator (++obj) instead of the postfix operator (obj++).


Language

Miscellaneous Continue…..

Use unsigned int instead of int if we know the value will

never be negative.

Avoid unnecessary division.

Software

Optimization in Programming languages