sCode optimization

• Optimization is the process of transforming a piece of code to make more efficient
(either in terms of time or space) without changing its output or side-effects. The only
difference visible to the code’s user should be that it runs faster and/or consumes less
memory. It is really a misnomer that the name implies you are finding an "optimal"
solution— in truth, optimization aims to improve, not perfect, the result. Optimization is
the field where most compiler research is done today. The tasks of the front-end
(scanning, parsing, semantic analysis) are well understood and unoptimized code
generation is relatively straightforward.
• Optimization, on the other hand, still retains a sizable measure of mysticism. High-quality
optimization is more of an art than a science. Compilers for mature languages aren’t
judged by how well they parse or analyze the code—you just expect it to do it right with
a minimum of hassle—but instead by the quality of the object code they produce. Many
optimization problems are NP-complete and thus most optimization algorithms rely on
heuristics and approximations. It may be possible to come up with a case where a
particular algorithm fails to produce better code or perhaps even makes it worse.
• However, the algorithms tend to do rather well overall. It’s worth reiterating here that
efficient code starts with intelligent decisions by the programmer. No one expects a
compiler to replace BubbleSort with Quicksort. If a programmer uses a lousy algorithm,
no amount of optimization can make it snappy. In terms of big-O, a compiler can only
make improvements to constant factors. But, all else being equal, you want an algorithm
with low constant factors.

When and Where To Optimize
• There are a variety of tactics for attacking optimization. Some techniques
are applied to the intermediate code, to streamline, rearrange, compress,
etc. in an effort to reduce the size of the abstract syntax tree or shrink the
number of TAC instructions. Others are applied as part of final code
generation—choosing which instructions to emit, how to allocate registers
and when/what to spill, and the like. And still other optimizations may
occur after final code generation, attempting to re-work the assembly code
itself into something more efficient.
• Optimization can be very complex and time-consuming; it often involves
multiple subphases, some of which are applied more than once. Most
compilers allow optimization to be turned off to speed up compilation (gcc
even has specific flags to turn on and off individual optimizations.)

Constant Folding
• Constant folding refers to the evaluation at compile-time of
expressions whose
• operands are known to be constant. In its simplest form, it involves
determining that all of the operands in an expression are constant-valued,
performing the evaluation of the expression at compile-time,
and then replacing the expression by its value. If an expression such
as 10 + 2 * 3 is encountered, the compiler can compute the result at
compile-time (16) and emit code as if the input contained the result
rather than the original expression. Similarly, constant conditions,
such as a conditional branch if a < b goto L1 else goto L2 where a and
b are constant can be replaced by a Goto L1 or Goto L2 depending on
the truth of the expression evaluated at compile-time.

Copy Propagation
• This optimization is similar to constant propagation, but generalized
to non-constant values. If we have an assignment a = b in our
instruction stream, we can replace later occurrences of a with b
(assuming there are no changes to either variable in-between). Given
the way we generate TAC code, this is a particularly valuable
optimization sinceit is able to eliminate a large number of instructions
that only serve to copy values from one variable to another.

Common Subexpression Elimination
• Two operations are common if they produce the same result. In such
a case, it is likely more efficient to compute the result once and
reference it the second time rather than re-evaluate it. An expression
is alive if the operands used to compute the expression have not been
changed. An expression that is no longer alive is dead.

PROGRAM FOR CONSTANT FOLDING
• #include<stdio.h>
• #include<conio.h>
• int fib(int base)
• {int result,tmp0,tmp1,tmp2,temp[12],f0,f1,i;
• temp[0]=1;
• temp[4]=0;
• temp[1]=base < temp[0];
• temp[2]=base==temp[0];
• temp[3]=temp[1]||temp[2];

• if(temp[3]==temp[4])
• goto L0;
• result=base;
• goto L1;
• L0:
• temp[4]=0;
• f0=temp[4];
• tmp0=f0;
• temp[5]=1;
• f1=temp[5];
• tmp1=f1;
• printf("%d %d ",f0,f1);

• temp[6]=2;
• i=temp[6];
• tmp2=i;
• L2:
• temp[7]=i<base;
• temp[8]=i==base;
• temp[9]=temp[7]||temp[8];
• if(temp[4]==temp[9])
• goto L3;

• temp[10]=tmp0+tmp1;
• result=temp[10];
• printf("%d ",result);
• tmp0=tmp1;
• tmp1=result;
• temp[11]=1;
• temp[12]=tmp2+temp[11];
• tmp2=temp[12];
• goto L2;
• L3:
• L1:
• return result;
• }
• void main()
• {
• int n;
• clrscr();
• printf("nEnter a number:");
• scanf("%d",&n) ;
• printf("nnfibonacci is %d",fib(n));
• getch();
• }

PROGRAM FOR COPY PROPOGATION
• int fib(int base)
• {
• int result,tmp0,tmp1,tmp2;
• if (base <= 1)
• {
• result = base;
• }
• else
• {

• int i;
• int f0;
• int f1;
• f0 = 0;
• tmp0=f0;
• f1 = 1;
• tmp1=f1;
• i = 2;
• tmp2=i;
• printf("nn%dt%d",tmp0,tmp1);
• while (tmp2 <= base)
• {
• result = tmp0 + tmp1;
• printf("t%d",result);
• tmp0 = tmp1;
• tmp1 = result;
• tmp2 = tmp2 + 1;
• }
• }
• return result;
• }

• void main()
• {
• int n;
• clrscr();
• printf("nnEnter number:");
• scanf("%d",&n);
• printf("nnFibonacci is: %dn",fib(n));
• getch();
• }

PROGRAM FOR COMMON SUBEXPRESSION
ELIMINATION
• void main()
• {
• int a,b,c,d,e,f;
• clrscr();
• printf("n Enter the values of a,b,c");
• scanf("n %d %d %d",&a,&b,&c);
• d=a+b;
• e=d*b;

• f=e+d+a;
• printf("n D=%d",d);
• printf("n E=%d",e);
• printf("n F=%d",f);
• getch();
• }

sCode optimization

Recommended

More Related Content

What's hot (20)

Viewers also liked (12)

Similar to sCode optimization (20)

More from Satyamevjayte Haxor (9)

Recently uploaded (20)

sCode optimization