• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Code optimisation presnted
 

Code optimisation presnted

on

  • 337 views

code optimisation

code optimisation

Statistics

Views

Total Views
337
Views on SlideShare
337
Embed Views
0

Actions

Likes
0
Downloads
4
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Code optimisation presnted Code optimisation presnted Presentation Transcript

    • CH10.2 CSE 4100 OverviewOverview  Code Level OptimizationCode Level Optimization  Common Sub-expression elimination  Copy Propagation  Dead-code elimination  Peephole optimizationPeephole optimization  Load/Store elimination  Unreachable code  Flow of Control Optimization  Algebraic simplification  Strength Reduction
    • CH10.4 CSE 4100 Where can Optimation Occur?Where can Optimation Occur?  Software Engineer can:Software Engineer can:  Profile Program  Change Algorithm Data  Transform/Improve Loops Front End LA, Parse, Int. Code Code Generator Int. Code Target Program Source Program  Compiler Can:Compiler Can:  Improve Loops/Proc Calls  Calculate Addresses  Use Registers  Selected Instructions  Perform Peephole Opt.  All are OptimizationsAll are Optimizations  1st is User Controlled and Defined  At Intermediate Code Level by Compiler  At Assembly Level for Target Architecture (to take advantage of different machine features)
    • CH10.6 CSE 4100 First Look at OptimizationFirst Look at Optimization  Optimization Applied to 3 Address Coding (3AC)Optimization Applied to 3 Address Coding (3AC) Version of Source Program - Examples:Version of Source Program - Examples:
    • CH10.7 CSE 4100 First Look at OptimizationFirst Look at Optimization  Identify each Basic Block which Represents a set of Three Address Statements where Execution Enters at Top and Leaves at Bottom No Branches within Code  Represent the Control Flow Dependencies Among and Between Basic Blocks Defines what is Termed a “Flow Graph”
    • CH10.8 CSE 4100 First Look at OptimizationFirst Look at Optimization  Steps 1 to 12 from two Slides Back Represented as:Steps 1 to 12 from two Slides Back Represented as:  Optimization Works with Basic Blocks and FlowOptimization Works with Basic Blocks and Flow Graph to Perform Transformations that:Graph to Perform Transformations that:
    • CH10.9 CSE 4100 First Look at OptimizationFirst Look at Optimization  Optimization will PerformOptimization will Perform Transformations on BasicTransformations on Basic Blocks/Flow GraphBlocks/Flow Graph  Resulting Graph(s) PassedResulting Graph(s) Passed Through to Final Code GenerationThrough to Final Code Generation to Obtain More Optimal Codeto Obtain More Optimal Code  Two Fold Goal of OptimizationTwo Fold Goal of Optimization Reduce Time Reduce Space
    • CH10.10 CSE 4100 First Look at OptimizationFirst Look at Optimization  Two Types of TransformationsTwo Types of Transformations  Structure Preserving Inherent Structure and Implicit Functionality of Basic Blocks is Unchanged  Algebraic Elimination of Useless Expressions x = x + 0 or y = y * 1 Replace Expensive Operators Change x = y ** 2 to x = y * y
    • CH10.11 CSE 4100 Structure Preserving TransformationsStructure Preserving Transformations  Common Sub-Expression EliminationCommon Sub-Expression Elimination  How can Following Code be Improved? a = b + c b = a – d c = b + c d = a – d  What Must Make Sure Doesn’t happen?  Dead-Code EliminationDead-Code Elimination  If x is not Used in Block, Can it be Removed? x = y + z d = b
    • CH10.12 CSE 4100 Structure Preserving TransformationsStructure Preserving Transformations  Renaming Temporary VariablesRenaming Temporary Variables  Consider the code t = b + c  Can be Changed to u = b + c  May Reduce the Number of temporaries  Make Change from all t’s to all u’s  Interchange of StatementsInterchange of Statements  Consider and Change to: t1 = b + c t2 = x + y t2 = x + y t1 = b + c  This can Occur as Long as:  x and y not t1  b and c not t2
    • CH10.13 CSE 4100 Requirements for OptimizationRequirements for Optimization
    • CH10.14 CSE 4100 The Overall Optimization ProcessThe Overall Optimization Process  AdvantagesAdvantages  Intermediate Code has Explicit Operations and Their Identification Promotes Optimization  Intermediate Code is Relatively Machine Independent  Therefore, Optimization Doesn’t Impact Final Code Generation
    • CH10.15 CSE 4100 Example Source CodeExample Source Code
    • CH10.16 CSE 4100 Generated Three Address CodingGenerated Three Address Coding
    • CH10.17 CSE 4100 Flow Graph of Basic BlocksFlow Graph of Basic Blocks
    • CH10.18 CSE 4100 Indepth Examination of OptimizationIndepth Examination of Optimization  Code-Transformation Techniques:Code-Transformation Techniques:  Local – within a “Basic Block”  Global – between “Basic Blocks”  Data Flow Dependencies Determined byData Flow Dependencies Determined by InspectionInspection what do i, a, and v refer to?what do i, a, and v refer to?  Dependent in Another Basic BlockDependent in Another Basic Block  Scoping is Very CriticalScoping is Very Critical
    • CH10.19 CSE 4100 Indepth Examination of OptimizationIndepth Examination of Optimization  Function Preserving TransformationsFunction Preserving Transformations  Common Subexpressions  Copy Propagation  Deal Code Elimination  Constant Folding  Loop OptimizationsLoop Optimizations  Code Motion  Induction Variables  Strength Reduction
    • CH10.20 CSE 4100 Common Sub-ExpressionsCommon Sub-Expressions  E is a Common Sub-Expression ifE is a Common Sub-Expression if  E as Previously Computed  Value of E Unchanged since Previous Coamputation  What Can be Saved in B5?What Can be Saved in B5?  t6 and t7 same computation  t8 and t10 same computation  Save:  Remove 2 temp variables  Remove 2 multiplications  Remove 4 variable accesses  Remove 2 assignments t6 := 4 * i x := a[t6] t7 := 4 * i t8 := 4 * j t9 := a[t8] a[t7] := t9 t10 := 4 * j a[t10]:= x Goto B2
    • CH10.21 CSE 4100 Common Sub-ExpressionsCommon Sub-Expressions  What about B6?What about B6?  t11 and t12  t13 and t15  Similar Savings as in B5Similar Savings as in B5 t11 := 4 * i x := a[t11] t12 := 4 * i t13 := 4 * n t14 := a[t13] a[t12]:= t14 t15 := 4 * n a[t15]:= x t11 := 4 * i x := a[t11] t13 := 4 * n t14 := a[t13] a[t11]:= t14 a[t13]:= x
    • CH10.22 CSE 4100 Common Sub-ExpressionsCommon Sub-Expressions  What else Can be Accomplished?What else Can be Accomplished?  Where is Variable j Determined?Where is Variable j Determined?  In B3 – and when drop through B3 to B4 and into B5, no change occurs to j!  What Does B5 Become?What Does B5 Become?  t9 same as t5!t9 same as t5!  Again savings in access,Again savings in access, variables, operations, etc.variables, operations, etc. t6 := 4 * i x := a[t6] t8 := 4 * j t9 := a[t8] a[t6] := t9 a[t8]:= x Goto B2 j := j - 1 t4 := 4 * j t5 := a[t4] if t5>4 goto B3 B4 t6 := 4 * i x := a[t6] t9 := a[t4] a[t6] := t9 a[t4]:= x Goto B2 t6 := 4 * i x := a[t6] a[t6] := t5 a[t4]:= x Goto B2
    • CH10.24 CSE 4100 Common Sub-ExpressionsCommon Sub-Expressions  B6 is Similarly Changed ….B6 is Similarly Changed …. t11 := 4 * i x := a[t11] t13 := 4 * n t14 := a[t13] a[t11]:= t14 a[t13]:= x x := t3 t14 := a[t1] a[t2]:= t14 a[t1]:= x
    • CH10.25 CSE 4100 Resulting Flow DiagramResulting Flow Diagram
    • CH10.26 CSE 4100 Copy PropagationCopy Propagation  Introduce a Common Copy Statement toIntroduce a Common Copy Statement to Replace an Arithmetic Calculation withReplace an Arithmetic Calculation with AssignmentAssignment  Regardless of the Path Chosen, the use ofRegardless of the Path Chosen, the use of an Assignment Saves Time and Spacean Assignment Saves Time and Space a:= d + e a:= t a:= d + e b:= d + e c:= d + e b:= d + e a:= t c:= t
    • CH10.27 CSE 4100 Copy PropagationCopy Propagation  In our Example for B5 and B6 Below:In our Example for B5 and B6 Below:  Since x is t3, we can replace the use of x on right handSince x is t3, we can replace the use of x on right hand side as below:side as below: x := t3 t14 := a[t1] a[t2]:= t14 a[t1]:= x x := t3 a[t2] := t5 a[t4]:= x Goto B2 x := t3 t14 := a[t1] a[t2] := t14 a[t1] := t3 x := t3 a[t2] := t5 a[t4] := t3 Goto B2
    • CH10.28 CSE 4100 Dead Code EliminationDead Code Elimination  Variable is “Dead” if its Value will never be UtilizedVariable is “Dead” if its Value will never be Utilized Again SubsequentlyAgain Subsequently  Otherwise, Variable is “Live”Otherwise, Variable is “Live”  What’s True about B5 and B6?What’s True about B5 and B6?  Can Any Statements be Eliminated? Which Ones?Can Any Statements be Eliminated? Which Ones? Why?Why?  B5 and B6 are Now Optimized withB5 and B6 are Now Optimized with  B5 has 9 Statements Reduced to 3  B56 has 8 Statements Reduced to 3 x := t3 t14 := a[t1] a[t2] := t14 a[t1] := t3 x := t3 a[t2] := t5 a[t4] := t3 Goto B2
    • CH10.29 CSE 4100 Loop OptimizationsLoop Optimizations  Three Types: Code Motion, Induction Variables, andThree Types: Code Motion, Induction Variables, and Strength ReductionStrength Reduction  Code MotionCode Motion  Remove Invariant Operations from Loop while (limit * 2 > i) do  Replaced by: t = limit * 2 while (t > i) do  Induction VariablesInduction Variables  Identify Which Variables are Interdependent or in Step j = j – 1 t4 = 4 * j  Replaced by below with an initialization of t4 t4 = t4 - 4
    • CH10.30 CSE 4100 Loop OptimizationsLoop Optimizations  Strength ReductionStrength Reduction  Replace an Expensive Operation (Such as Multiply) with a Cheaper Operation (Such as Add)  In B4, I and j can be replaced with t2 and t4  This Eliminates the need for Variables i and j
    • CH10.31 CSE 4100 Final Optimized Flow GraphFinal Optimized Flow Graph
    • CH10.43 CSE 4100 Peephole OptimizationPeephole Optimization  Simple IdeaSimple Idea  Slide a window over the code  Optimize code in the window only.  Optimizations areOptimizations are  Local  Semantic preserving  Cheap to implement  UsuallyUsually  One can repeat the peephole several times!  Each pass can create new opportunities for more
    • CH10.44 CSE 4100 Peephole OptimizerPeephole Optimizer block_3: mov [esp-4],ebp mov ebp,esp mov [ebp-8],esp sub esp,28 mov eax,[ebp+8] cmp eax,0 mov eax,0 sete ah cmp eax,0 jz block_5 block_4: mov eax,1 jmp block_6 block_5: mov eax,[ebp+8] sub eax,1 push eax mov eax,[ebp+4] push eax mov eax,[eax] mov eax,[eax] call eax add esp,8 mov ebx,[ebp+8] imul ebx,eax block_3: mov [esp-4],ebp mov ebp,esp mov [ebp-8],esp sub esp,28 mov eax,[ebp+8] cmp eax,0 mov eax,0 sete ah cmp eax,0 jz block_5 block_4: mov eax,1 jmp block_6 block_5: mov eax,[ebp+8] sub eax,1 push eax mov eax,[ebp+4] push eax mov eax,[eax] mov eax,[eax] call eax add esp,8 mov ebx,[ebp+8] imul ebx,eax
    • CH10.45 CSE 4100 Peephole OptimizationsPeephole Optimizations  Load/Store elimination  Get rid of redundant operations  Unreachable code  Get rid of code guaranteed to never execute  Flow of Control Optimization  Simply jump sequences.  Algebraic simplification  Use rules of algebra to rewrite some basic operation  Strength Reduction  Replace expensive instructions by equivalent ones (yet cheaper)  Machine Idioms  Replace expensive instructions by equivalent ones (for a given machine)
    • CH10.46 CSE 4100 Load / Store SequencesLoad / Store Sequences  Imagine the following sequenceImagine the following sequence  “a” is a label for a memory location mov a,eax mov eax,a mov a,eax mov eax,a
    • CH10.47 CSE 4100 Unreachable CodeUnreachable Code  ExampleExample #define debug 0 .... if (debug) { printf(“This is a trace messagen”); } .... #define debug 0 .... if (debug) { printf(“This is a trace messagen”); } ....
    • CH10.48 CSE 4100 ExampleExample  The Generated code looks like....The Generated code looks like....  If we know that...If we know that...  debug == 0  Then .... if (debug == 0) goto L2 printf(“This is a trace messagen”); L2: .... .... if (debug == 0) goto L2 printf(“This is a trace messagen”); L2: .... .... if (0 == 0) goto L2 printf(“This is a trace messagen”); L2: .... .... if (0 == 0) goto L2 printf(“This is a trace messagen”); L2: .... 1
    • CH10.49 CSE 4100 ExampleExample  Final transformationFinal transformation  Given this codeGiven this code  There is no way to branch “into” the blue block  The last instruction (goto L2) jumps over the blue block  The blue block is never used. Get rid of it! .... goto L2 printf(“This is a trace messagen”); L2: .... .... goto L2 printf(“This is a trace messagen”); L2: ....
    • CH10.50 CSE 4100 Unreachable Code ExampleUnreachable Code Example  Bottom LineBottom Line  Now L2 is instruction after goto...Now L2 is instruction after goto...  So get rid of goto altogether! .... goto L2 L2: .... .... goto L2 L2: .... .... L2: .... .... L2: ....
    • CH10.51 CSE 4100 Flow of Control OptimizationFlow of Control Optimization  SituationSituation  We can have chains of jumps  Direct to conditional or vice-versa  ObjectiveObjective  Avoid extra jumps.  ExampleExample if (x relop y) goto L2 .... L2: goto L4 L3: .... L4: L4_BLOCK if (x relop y) goto L2 .... L2: goto L4 L3: .... L4: L4_BLOCK
    • CH10.52 CSE 4100 Flow of ControlFlow of Control  What can be doneWhat can be done  Collapse the chain if (x relop y) goto L4 .... L2: goto L4 L3: .... L4: L4_BLOCK if (x relop y) goto L4 .... L2: goto L4 L3: .... L4: L4_BLOCK
    • CH10.53 CSE 4100 Algebraic SimplificationAlgebraic Simplification  Simple IdeaSimple Idea  Use algebraic rules to rewrite some code  ExamplesExamples x := y + 0x := y + 0 x := yx := y x := y * 1 x := y * 1 x := yx := y x := y * 0 x := y * 0 x := 0x := 0
    • CH10.54 CSE 4100 Strength ReductionStrength Reduction  IdeaIdea  Replace expensive operation  By semantically equivalent cheaper ones.  ExamplesExamples  Multiplication by 2 is equivalent to a left shift  Left shift is much faster
    • CH10.55 CSE 4100 Hardware IdiomHardware Idiom  IdeaIdea  Replace expensive instructions by...  Equivalent instruction that are optimized for the platform  ExampleExample add eax,1add eax,1 inc eax inc eax