Optimizing Compilers for Modern Architectures Preliminary Transformations Chapter 4 of Allen and...

Optimizing Compilers for Modern Architectures

Preliminary Transformations

Chapter 4 of Allen and Kennedy

Overview

• Why do we need this?—Requirements of dependence testing

– Stride 1– Normalized loop– Linear subscripts– Subscripts composed of functions of loop induction

variables—Higher dependence test accuracy—Easier implementation of dependence tests

An Example

INC = 2KI = 0DO I = 1, 100 DO J = 1, 100 KI = KI + INC U(KI) = U(KI) + W(J) ENDDO S(I) = U(KI)ENDDO

• Programmers optimized code—Confusing to smart compilers

An Example

INC = 2KI = 0DO I = 1, 100 DO J = 1, 100

! Deleted: KI = KI + INC U(KI + J*INC) = U(KI + J*INC) + W(J) ENDDO KI = KI + 100 * INC S(I) = U(KI)ENDDO

• Applying induction-variable substitution—Replace references to AIV with functions of loop index

An Example

INC = 2KI = 0DO I = 1, 100 DO J = 1, 100 U(KI + (I-1)*100*INC + J*INC) = U(KI + (I-1)*100*INC + J*INC) + W(J) ENDDO ! Deleted: KI = KI + 100 * INC S(I) = U(KI + I * (100*INC))ENDDOKI = KI + 100 * 100 * INC

• Second application of IVS—Remove all references to KI

An Example

INC = 2! Deleted: KI = 0DO I = 1, 100 DO J = 1, 100 U(I*200 + J*2 - 200) = U(I*200 + J*2 -200) + W(J) ENDDO S(I) = U(I*200)ENDDOKI = 20000

• Applying Constant Propagation—Substitute the constants

An Example

DO I = 1, 100 DO J = 1, 100 U(I*200 + J*2 - 200) = U(I*200 + J*2 - 200) + W(J) ENDDO S(I) = U(I*200)ENDDO

• Applying Dead Code Elimination—Removes all unused code

Information Requirements

• Transformations need knowledge—Loop Stride—Loop-invariant quantities—Constant-values assignment—Usage of variables

Loop Normalization

• Lower Bound 1 with Stride 1

• To make dependence testing as simple as possible

• Serves as information gathering phase

Loop Normalization

• Algorithm

Procedure normalizeLoop(L0);

i = a unique compiler-generated LIV

S1: replace the loop header for L0

DO I = L, U, S

with the adjusted loop header

DO i = 1, (U – L + S) / S;

S2: replace each reference to I within the loop by

i * S – S + L;

S3: insert a finalization assignment

I = i * S – S + L;

immediately after the end of the loop;

end normalizeLoop;

Loop Normalization

• Caveat— Un-normalized:

DO I = 1, M

DO J = I, N

A(J, I) = A(J, I - 1) + 5

Has a direction vector of (<,=)

— Normalized:

DO I = 1, M

DO J = 1, N – I + 1

A(J + I – 1, I) = A(J + I – 1, I – 1) + 5

Has a direction vector of (<,>)

Loop Normalization

• Caveat— Consider interchanging loops

– (<,=) becomes (=,>) OK– (<,>) becomes (>,<) Problem

Handled by another transformation— What if the step size is symbolic?

– Prohibits dependence testing– Workaround: use step size 1

Less precise, but allow dependence testing

Definition-use Graph

• Traditionally called Definition-use Chains

• Provides the map of variables usage

• Heavily used by the transformations

• Definition-use graph is a graph that contains an edge from each definition point in the program to every possible use of the variable at run time

• uses(b): the set of all variables used within the block b that have no prior definitions within the block

• defsout(b): the set of all definitions within block b that are not killed within the block

• killed(b): the set of all definitions that define variables killed by other definitions within block b

)))()(()(()(bPp

pkilledpreachespdefsoutbreaches∈

¬∩∪=

• Computing reaches for one block b may immediately change all other reaches including b itself since reaches(b) is an input into other reaches equations

• Archiving correct solutions requires simultaneously solving all individual equations—There is a workaround this

Dead Code Elimination

• Removes all dead code

• What is Dead Code ?—Code whose results are never used in any ‘Useful

statements’

• What are Useful statements ?—Are they simply output statements ?—Output statements, input statements, control flow

statements, and their required statements

• Makes code cleaner

Dead Code Elimination

Constant Propagation

• Replace all variables that have constant values at runtime with those constant values

Static Single-Assignment

• Reduces the number of definition-use edges

• Improves performance of algorithms

Static Single-Assignment

• Example

Forward Expression Substitution

DO I = 1, 100 K = I + 2 A(K) = A(K) + 5 ENDDO

DO I = 1, 100 A(I+2) = A(I+2) + 5ENDDO

• Example

• Need definition-use edges and control flow analysis

• Need to guarantee that the definition is always executed on a loop iteration before the statement into which it is substituted

• Data structure to find out if a statement S is in loop L—Test whether level-K loop containing S is equal to L

Induction Variable Substitution

• Definition: an auxiliary induction variable in a DO loop headed by DO I = LB, UB, S is any variable that can be correctly expressed as cexpr * I + iexprL at every location L where it is used in the loop, where cexpr and iexprL are expressions that do not vary in the loop, although different locations in the loop may require substitution of different values of iexprL

• Example:

DO I = 1, N

A(I) = B(K) + 1

K = K + 4

D(K) = D(K) + A(I)

Induction Variable Recognition

• Induction Variable Recognition

• More complex example

DO I = 1, N, 2

K = K + 1

A(K) = A(K) + 1

K = K + 1

A(K) = A(K) + 1

• Alternative strategy is to recognize region invariance

DO I = 1, N, 2

A(K+1) = A(K+1) + 1

K = K+1 + 1

A(K) = A(K) + 1

• Driver

IVSub without loop normalization

DO I = L, U, S

K = K + N

… = A(K)

DO I = L, U, S

… = A(K + (I – L + S) / S * N)

K = K + (U – L + S) / S * N

IVSub without loop normalization

• Problem:—Inefficient code—Nonlinear subscript

IVSub with Loop Normalization

DO i = 1, (U-L+S)/S, 1

K = K + N

… = A (K)

I = I + 1

IVSub with Loop Normalization

DO i = 1, (U – L + S) / S, 1

… = A (K + i * N)

K = K + (U – L + S) / S * N

I = I + (U – L + S) / S

Summary

• Transformations to put more subscripts into standard form—Loop Normalization—Constant Propagation—Induction Variable Substitution

• Do loop normalization before induction-variable substitution

• Leave optimizations to compilers

Optimizing Compilers for Modern Architectures Preliminary Transformations Chapter 4 of Allen and...

Documents

Transcript of Optimizing Compilers for Modern Architectures Preliminary Transformations Chapter 4 of Allen and...

Optimizing Compilers for Modern Architectures Copyright, 1996 © Dale Carnegie & Associates, Inc. Dependence Testing Allen and Kennedy, Chapter 3 thru Section.

Compilers compilers . Q1>A translator converts _____________into______________. .

Honors Compilers

COMPILERS AND OPERATING SYSTEMS FOR LOW POWER · 2 Data Transfer and Storage Exploration Methodology 176 3 Global Data Flow and Loop Transformations 178 3.1 Removal of Interleaver

Compilers for embedded systems: Why are compilers an issue?

CSE P501 – Compiler Construction Introductions Compilers, from 10,000 feet Why study Compilers? Compilers, from 1,000 feet Some History Project Admin Books.

Optimizing Compilers CISC 673 Spring 2009 Overview of Compilers and JikesRVM

Mod02 compilers

Partial Compilers

Contemporary Compilers

May 4, 2015 Loop Transformations 1 - University of Texas ...lin/cs380c/handout28.pdf · Calvin Lin, The University of Texas at Austin CS380 C Compilers 3 May 4, 2015 Loop Transformations

CSE443 Compilers

Honors Compilers Run-Time Support for Compilers Mar 21st 2002.

- 1 - EE898- Compiler Compilers for embedded systems: Why are compilers an issue? Many reports about low efficiency of standard compilers Special.

Preliminary Transformations Chapter 4 of Allen and Kennedy Harel Paz.

Compilers and Computers

Data-Flow/Dependence Profiling for Structured Transformations · Optimizing compilers typically attempt, ... In full programs and in particular those relying on external binaries

Optimising Compilers

Compilers Notes

Optimizing Compilers for Modern Architectures Allen and Kennedy, Chapter 13 Compiling Array Assignments.

Compilers compilers . Q1>A translator converts _into__. .