compiler optimisation - 1 introductory lecturetextbooks engineering a compiler “ eac” by k. d....
TRANSCRIPT
![Page 1: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/1.jpg)
Compiler Optimisation1 – Introductory Lecture
Hugh LeatherIF 1.18a
Institute for Computing Systems ArchitectureSchool of Informatics
University of Edinburgh
2019
![Page 2: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/2.jpg)
Textbooks
Engineering a Compiler “ EaC” by K. D. Cooper and L.Torczon. Published by Morgan Kaufmann 2003Optimizing Compilers for Modern Architectures: ADependence-based Approach “ CMA” by R. Allen and K.Kennedy. Published Morgan Kaufmann 2001Advanced Compiler Design and Implementation bySteven S. Muchnick, published by Morgan Kaufmann. (extrareading - not required)Plus research papers in last part of course
Note: Slides do not replace books. Provide motivation, conceptsand examples not details.
![Page 3: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/3.jpg)
How to get the most out of the course
Read ahead including exam questions and use lectures to askquestionsL1 is a recap and sets the stage. Check you are comfortableTake notesDo the course work and write well. Straightforward - schedulesmartlyExam results tend to be highly bi-modalIf you are struggling, ask earlier rather than laterIf you dont understand - its probably my fault - so ask!
![Page 4: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/4.jpg)
Course structure
L1 Introduction and RecapL2 Course Work - again updated from last year4-5 lectures on classical optimisation(Based on EaC)5-6 lectures on high level/parallel(Based on CMA + papers)4-5 lectures on adaptive compilation(Based on papers)Additional lectures on course work/ revision/ external talks/research directions
![Page 5: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/5.jpg)
Compilers reviewWhat is a compiler?
Translates a program from source language to target languageOften target is assemblyIf target is a source language then “source-to-source” compiler
Compare this to an interpreter
![Page 6: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/6.jpg)
Compilers reviewWhat is a compiler?
Translates a program from source language to target languageOften target is assemblyIf target is a source language then “source-to-source” compilerCompare this to an interpreter
![Page 7: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/7.jpg)
Compilers reviewOptimisation
Just translating not enough - must optimise!Not just performance - also code size, power, energyGenerally undecidable, often NP-completeGap between potential performance and actual wideningMany architectural issues to think about
Exploiting parallelism: instruction, thread, multi-core,acceleratorsEffective management of memory hierarchyregisters,LI,L2,L3,Mem,Disk
Small architectural changes have big impact - hard to reason aboutProgram optimised for CPU with Random cache replacement.What do you change for new machine with LRU?
![Page 8: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/8.jpg)
Compilers reviewTypical compiler structure
Front end takes string of characters into abstract syntax treeOptimiser does machine independent optimisationsBack end does machine dependent optimisation and codegeneration
![Page 9: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/9.jpg)
Compilers reviewTypical compiler structure
Work broken into small passes or phasesDifferent IRs used - choice affects later analysis/optimisation
![Page 10: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/10.jpg)
Compilers reviewFront end
Front end stages
Lexical Analysis - ScannerFinds and verifies basic syntactic items - lexemes, tokens usingfinite state automata
Syntax Analysis - ParserChecks tokens follow a grammar based on a context free grammarand builds an Abstract Syntax Tree (AST)
Semantic Analysis - ParserChecks all names are consistently used. Various type checkingschemes employed. Attribute grammar to Milner type inference.Builds a symbol table
![Page 11: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/11.jpg)
Compilers reviewLexical analysis
Find keywords, identifiers, constants, etc. - these are tokensA set of rules are expressed as regular expressions (RE)Scanner automatically generated from rules 1
Transform RE → NFA → DFA → Scanner table
Example scanner rules
` → (‘a’|‘b’| . . . |‘z’|‘A’|‘B’| . . . |‘Z’)digit → (‘0’|‘1’| . . . |‘9’)
integer → digit digit∗
real → digit digit∗ ‘.’ digit digit∗
exp → digit digit∗ ‘.’ digit digit∗ ( ‘e’ | ‘E’ ) digit digit∗
1Except in practically every real compiler, where all of this is hand coded
![Page 12: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/12.jpg)
Compilers reviewLexical analysis
Token scanning example
How are the following classified?0, 01, 2.6, 2., 2.6E2, and 2E20
![Page 13: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/13.jpg)
Compilers reviewLexical analysis
Each token has at least:Type (Keyword, LBracket, RBracket, Number, Identifier,String, etc.)Text value (and number value etc.)Source file, line number, position
White space and comments are typically stripped outError tokens may be returned
![Page 14: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/14.jpg)
Compilers reviewSyntactic analysis
REs not powerful enough(matched parentheses, operator precedence, etc)Syntax parser described by context free grammar (often BNF)Care must be taken to avoid ambiguityGenerators (YACC, BISON, ANTLR) will complain
Example grammar
expr → term op expr | termterm → number | id
op → ∗|+ |−
Parse x − 2 ∗ y
![Page 15: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/15.jpg)
Compilers reviewSyntactic analysis
Parse tree for x − 2 ∗ y
Notice this is parsed as x − (2 ∗ y)What about x ∗ 2 − y?
![Page 16: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/16.jpg)
Compilers reviewSyntactic analysis
Parse trees have irrelevant intermediate nodesRemoving them gives AST
Simplified parse tree for x − 2 ∗ y
![Page 17: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/17.jpg)
Compilers reviewSyntactic analysis
Arbitrary CFGs can be expensive to parseSimple dynamic programming T (n) = O(n3)
Restricted classes of CFG with more efficient parsers
CFG classesLR(1) Left to right scan, Rightmost derivation with 1
symbol lookaheadLL(1) Left to right scan, Leftmost derivation with 1 symbol
lookahead; cannot handle left-recursive grammarsOthersa LR(k), LL(k), SLR(k), LALR(k), LR(k), IELR(k),
GLR(k), LL(*), etcaSome represent the same langauges
![Page 18: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/18.jpg)
Compilers reviewSemantic analysis
Syntactic analysis produces abstract syntax treeProgram may still be invalidSemantic analysis checks correct meaning and decorates ASTSymbol tables record what names refer to at different scopesSemantic actions embedded in grammar allow arbitrary codeduring parsingAttribute grammars propagate information around AST
![Page 19: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/19.jpg)
Compilers reviewSemantic analysis - symbol tables
Symbol tables provide two operationslookup(name) retrieve record associated with nameinsert(name, record) associate record with name
Stack of symbol tables manages lexical scopesLookup searches stack recursively for name
Scope example(0) char* n = "N";(0) char* fmt = "%d";(0) void foo() {(1) int n = 10;(2) for( int i = 0; i < n; ++i ) {(3) printf(fmt, n);(2) }(0) }
![Page 20: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/20.jpg)
Compilers reviewSemantic analysis - semantic actions
Semantic actions allow arbitrary code to be executed duringparsingAction executed only on successful parse of rule orAction provides conditional check to help parser choosebetween rulesSide effects can cause trouble with back tracking
Semantic actions
decl → var id = expr {symtab.insert(id.name)}
expr → number | id {assert(symtab.exists(id.name)}
![Page 21: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/21.jpg)
Compilers reviewSemantic analysis - attribute grammars
Attribute grammar is a CFG with:Attributes associated with each symbolSemantic rules per production to move attributes
Attributes can be inherited or synthesisedSemantic rules can access global data structures, such as asymbol table
Attribute grammar example - typesexpr → term op expr expr .type = Fop( term.type, expr .type )term → num | id term.type = num.type | id .typeop → ∗ | + | − Fop = F∗ | F+ | F−
![Page 22: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/22.jpg)
Compilers reviewSemantic analysis - attribute grammars
Attribute grammar example - x − 2 ∗ y x:int, y:real, int < real
F int realint int real
real real real
Type matrices can encode errors
ExampleF int real double
int int real doublereal real real ⊥
double double ⊥ real
![Page 23: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/23.jpg)
Compilers reviewBasic Code Generation
Translate AST in to assembler - walk through the tree and emitcode based on node type
ILOC instruction set2,3
Load constant 2 into r2loadI 2 → r2
Load value x into r1loadI @x → r1 @x is offset of xloadA0 r0, r1 → r1 Mem[r0 + r1] → r1
Add integers r1 = r2 + r3add r2, r3 → r1
3 EaC Appendix A3Assume activation record pointer in r0
![Page 24: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/24.jpg)
Compilers reviewBasic Code Generation
Typical top down generator - left to right - for simple expressionsAssume activation record pointer in register r0
function gen( node ) : Register
case numr = nextreg()emit(loadI value( node ) → r)return r
case idr = nextreg()emit( loadI offset( node ) → r)emit( loadA r0, r → r)return r
case binop( left, +, right )rL = gen( left ); rR = gen( right )emit( add rL, rR → rR )return rR
![Page 25: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/25.jpg)
Compilers reviewBasic Code Generation
Typical top down generator - left to right - for simple expressionsAssume activation record pointer in register r0
function gen( node ) : Registercase num
r = nextreg()emit(loadI value( node ) → r)return r
case idr = nextreg()emit( loadI offset( node ) → r)emit( loadA r0, r → r)return r
case binop( left, +, right )rL = gen( left ); rR = gen( right )emit( add rL, rR → rR )return rR
![Page 26: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/26.jpg)
Compilers reviewBasic Code Generation
Typical top down generator - left to right - for simple expressionsAssume activation record pointer in register r0
function gen( node ) : Registercase num
r = nextreg()emit(loadI value( node ) → r)return r
case idr = nextreg()emit( loadI offset( node ) → r)emit( loadA r0, r → r)return r
case binop( left, +, right )rL = gen( left ); rR = gen( right )emit( add rL, rR → rR )return rR
![Page 27: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/27.jpg)
Compilers reviewBasic Code Generation
Typical top down generator - left to right - for simple expressionsAssume activation record pointer in register r0
function gen( node ) : Registercase num
r = nextreg()emit(loadI value( node ) → r)return r
case idr = nextreg()emit( loadI offset( node ) → r)emit( loadA r0, r → r)return r
case binop( left, +, right )rL = gen( left ); rR = gen( right )emit( add rL, rR → rR )return rR
![Page 28: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/28.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ y
loadI @x → r1loadA0 r0, r1 → r1loadI 2 → r2loadI @y → r3loadA0 r0, r3 → r3mult r2, r3 → r3sub r1, r3 → r3
3 registers used
![Page 29: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/29.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ yloadI @x → r1loadA0 r0, r1 → r1
loadI 2 → r2loadI @y → r3loadA0 r0, r3 → r3mult r2, r3 → r3sub r1, r3 → r3
3 registers used
![Page 30: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/30.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ yloadI @x → r1loadA0 r0, r1 → r1loadI 2 → r2
loadI @y → r3loadA0 r0, r3 → r3mult r2, r3 → r3sub r1, r3 → r3
3 registers used
![Page 31: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/31.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ yloadI @x → r1loadA0 r0, r1 → r1loadI 2 → r2loadI @y → r3loadA0 r0, r3 → r3
mult r2, r3 → r3sub r1, r3 → r3
3 registers used
![Page 32: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/32.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ yloadI @x → r1loadA0 r0, r1 → r1loadI 2 → r2loadI @y → r3loadA0 r0, r3 → r3mult r2, r3 → r3
sub r1, r3 → r33 registers used
![Page 33: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/33.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ yloadI @x → r1loadA0 r0, r1 → r1loadI 2 → r2loadI @y → r3loadA0 r0, r3 → r3mult r2, r3 → r3sub r1, r3 → r3
3 registers used
![Page 34: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/34.jpg)
Compilers reviewBasic Code Generation
Generate code for x − 2 ∗ yloadI @x → r1loadA0 r0, r1 → r1loadI 2 → r2loadI @y → r3loadA0 r0, r3 → r3mult r2, r3 → r3sub r1, r3 → r3
3 registers used
![Page 35: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/35.jpg)
Compilers reviewOptimisation
Reducing number of registers used usually goodCurrent traversal order left to right(rL = gen( left ); rR = gen( right ))Instead traverse child needing most registers firstnextreg() must know which regs unused
Most registers first traversal orderloadI @y → r1loadA0 r0, r1 → r1loadI 2 → r2mult r2, r1 → r1loadI @x → r2loadA0 r0, r2 → r2sub r2, r1 → r2
2 registers used
![Page 36: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/36.jpg)
Compilers reviewOptimisation
Expression, x − 2 ∗ y will have contextSubtrees of expression already evaluated?
Common subexpression elimination
a = 2 ∗ y ∗ zb = x − 2 ∗ y
→ t = 2 ∗ ya = t ∗ zb = x − t
![Page 37: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/37.jpg)
Compilers reviewMachine models
In first part of courseAssume uni-processor with instruction level parallelism,registers and memoryGenerated assembler should not perform any redundantcomputationShould utilise all available functional units and minimiseimpact of latencyRegister access is fast compared to memory but limited innumber. Use wiselyTwo flavours considered superscalar out-of-order vs VLIW:Dynamic vs static scheduling
Later consider multi-core architecture
![Page 38: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/38.jpg)
Summary
Compilation as translation and optimisationCompiler structurePhase order lexical, syntactic, semantic analysisNaive code generation and optimisationNext lecture course workThen scalar optimisation - middle end
![Page 39: Compiler Optimisation - 1 Introductory LectureTextbooks Engineering a Compiler “ EaC” by K. D. Cooper and L. Torczon. Published by Morgan Kaufmann 2003 Optimizing Compilers for](https://reader030.vdocuments.us/reader030/viewer/2022040912/5e86a71458f7f502e224effa/html5/thumbnails/39.jpg)
PPar CDT Advert
The biggest revolution in the technological landscape for fifty years
Now accepting applications! Find out more and apply at:
pervasiveparallelism.inf.ed.ac.uk
• • 4-year programme: 4-year programme: MSc by Research + PhDMSc by Research + PhD
• Collaboration between: ▶ University of Edinburgh’s School of Informatics ✴ Ranked top in the UK by 2014 REF
▶ Edinburgh Parallel Computing Centre ✴ UK’s largest supercomputing centre
• Full funding available
• Industrial engagement programme includes internships at leading companies
• Research-focused: Work on your thesis topic from the start
• Research topics in software, hardware, theory and
application of: ▶ Parallelism ▶ Concurrency ▶ Distribution