Scribd
Upload
8 views8 pages

Code Optimization

Code optimization enhances code performance by eliminating unnecessary lines and rearranging statements. It offers advantages such as faster execution speed and efficient memory usage, employing techniques like compile time evaluation, common subexpression elimination, and dead code elimination. These methods focus on reducing redundancy, moving code out of loops, and replacing costly operations with simpler ones.

Uploaded by

nityaabhanushali04
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
8 views8 pages

Code Optimization

Code optimization enhances code performance by eliminating unnecessary lines and rearranging statements. It offers advantages such as faster execution speed and efficient memory usage, employing techniques like compile time evaluation, common subexpression elimination, and dead code elimination. These methods focus on reducing redundancy, moving code out of loops, and replacing costly operations with simpler ones.

Uploaded by

nityaabhanushali04
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Code Optimization

-​ Shilpa Kalantri
Code Optimization-

Code Optimization is an approach to enhance the performance of the code.

The process of code optimization involves-


●​ Eliminating the unwanted code lines
●​ Rearranging the statements of the code

Advantages-

The optimized code has the following advantages-


●​ Optimized code has faster execution speed.
●​ Optimized code utilizes the memory efficiently.
●​ Optimized code gives better performance.

Code Optimization Techniques-


Important code optimization techniques are-
1.​ Compile Time Evaluation
2.​ Common subexpression elimination
3.​ Dead Code Elimination
4.​ Code Movement
5.​ Strength Reduction

1. Compile Time Evaluation-

Two techniques falls under compile time evaluation -

A) Constant Folding-

In this technique,
●​ As the name suggests, it involves folding the constants.
●​ The expressions that contain the operands having constant values at compile time are
evaluated.
●​ Those expressions are then replaced with their respective results.

Example-

Circumference of Circle = (22/7) x Diameter

Here,
●​ This technique evaluates the expression 22/7 at compile time.
●​ The expression is then replaced with its result 3.14.
●​ This saves time at run time.

B) Constant Propagation-

In this technique,
●​ If some variable has been assigned some constant value, then it replaces that variable with its
constant value in the further program during compilation.
●​ The condition is that the value of the variable must not get altered in between.
Example-

pi = 3.14
radius = 10
Area of circle = pi x radius x radius
Here,
●​ This technique substitutes the value of variables ‘pi’ and ‘radius’ at compile time.
●​ It then evaluates the expression 3.14 x 10 x 10.
●​ The expression is then replaced with its result 314.
●​ This saves time at run time.

Example-
Before optimization
N = 10; C = 2;
for ( i = 0; i < N; i++ )
{
s = s + i*C;
}
After optimization
for ( i = 0; i < 10; i++ )
{
s = s + i*2;
}

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.
2. Common Subexpression Elimination-

The expression that has been already computed before and appears again in the code for
computation is called as Common Sub-Expression.

In this technique,
●​ It involves eliminating the common sub expressions.
●​ The redundant expressions are eliminated to avoid their re-computation.
●​ The already computed result is used in the further program when required.

Example-

Code Before Optimization Code After Optimization

S1 = i + j S1 = i+j
S2 = p+q S2 = p+q

S3 = i+j+p+q S3 = S1+S2

S4=i+j // Redundant Expression

3. Code Movement-
In this technique,
●​ As the name suggests, it involves movement of the code.
●​ The code present inside the loop is moved out if it does not matter whether it is present inside
or outside.
●​ Such a code unnecessarily gets executed again and again with each iteration of the loop.
●​ This leads to the wastage of time at run time.

Example-
Code Before Optimization Code After Optimization

for ( int j = 0 ; j < n ; j ++) x=y+z;


{ for ( int j = 0 ; j < n ; j ++)

x=y+z; {

a[j] = 6 x j; a[j] = 6 x j;

} }

Example-
do
{
item = 10;
value1 = value + item;
} while(value<100);

//This code can be further optimized as

item = 10;
do
{
value1 = value + item;
} while(value<100);
4. Dead Code Elimination-
In this technique,
●​ It involves eliminating the dead code.
●​ The statements of the code which either never executes or are unreachable or their output is
never used are eliminated.

Example-

Code Before Optimization Code After Optimization

i=0;
if (i == 1)
{ i=0;
a=x+5;
}

Before optimization
int add(int x, int y)
{
int i=0, z;
if( i==1)
{
z = x+i;
}
z=x+y;
return z;
printf(“%d”, z);
}

After optimization
int add(int x, int y)
{
int z;
z=x+y;
return z;

}
5. Strength Reduction-

In this technique,
●​ It involves reducing the strength of expressions.
●​ This technique replaces the expensive and costly operators with the simple and cheaper ones.

Example-

Code Before Optimization Code After Optimization

B=Ax2 B=A+A

Here,
●​ The expression “A x 2” is replaced with the expression “A + A”.
●​ This is because the cost of the multiplication operator is higher than that of the addition
operator.

You might also like