Crosscutting Issues: The Rôle of Compilers Architects must be aware of current compiler technology Compiler Architecture

Modern Compilers Front End High-level Optimisations Global Optimiser Code Generator E.g. procedure inlining, loop transformations Register allocation Machine dependent optimisations

Compiler Technology Multiple passes complicate matters –E.g. common subexpression elimination must assume that a register will be allocated for the temporary value –E.g. Procedure inlining before size is known Register allocation is critical –Uses graph colouring techniques –Requires at least 16 registers to be effective

Architectural Issues How are variables allocated and addressed? –Stack: local variables, scalars –Global data area: global variables, constants, arrays –Heap: dynamic objects, not scalars How many registers are needed? –Integer: 26 registers –FP: 20 registers

Aiding Compiler Writers Architectures should: –Be regular (orthogonal instruction set) –Provide primitives, not solutions –Simplify trade-offs among alternatives –Not require run-time interpretation of data known at compile-time VAX CALLS Keep it simple!

Compiler Support for Multimedia Instructions SIMD instructions act on multiple smaller data items in a large “word” –Solutions, not primitives! –Too few registers! –Data types not found in programming languages! Result: Only used by low-level graphics libraries.

Multimedia Instructions These SIMD instructions act like a “mini- vector” architecture –E.g. MMX in 64 bits 8 × 8-bit vectors 4 × 16-bit vectors 2 × 32-bit vectors –SSE: 128 bits –Much more limited than genuine vector processors

Putting It All Together: MIPS 64-bit load/store design RISC features: –GPR, load-store architecture –Small, simple instruction set –Designed for efficient pipelining (fixed length instructions) –Efficient compiler target

MIPS bit integer registers –R0…R31 –R0 fixed: bit or 32-bit floating point registers –Supports “paired single” operations

MIPS Data Types Integer: –Bytes, 16-bit halfwords, 32-bit words, 64-bit double words Operations are all 64-bit Floating point: –32-bit and 64-bit

MIPS Addressing Modes Only immediate and displacement –16-bit displacements/immediates –Register-indirect: set displacement = 0 –16-bit absolute: use R0 Byte addressable with 64-bit addresses Big-endian or little-endian Alignment required

MIPS Instructions Three instruction formats: opcode rs rt immediate I-type opcode offset 6 26 J-type opcode rs rtshamt R-type rd 5 funct 6

MIPS Operations Load-store ALU operations –Add, subtract, multiply, divide, and, or, xor, LUI (load upper immediate), shifts Control transfer –Set conditions –Branch (reg=0, reg  0, reg 1 =reg 2, reg 1  reg 2 ), jump, jump-and-link (call) –Conditional move Floating point –Paired single operations –Multiply-add (DSP)

MIPS: Instruction Usage Integer applications: –Load, add, branch, store, or, compare FP applications: –Add (int), load (int), load, multiply, add, store Figure 2.34.

Another View: Trimedia Media Processor Embedded processor for multimedia applications –E.g. set-top boxes (decoders, etc.) and TVs Very different architecture – bit registers (FP or int) –Partitioned (SIMD) instructions –2’s complement and saturating arithmetic –VLIW architecture

Trimedia: VLIW Approach Compiler can group up to five instructions for simultaneous execution –Must be independent –Use NOPs if there are insufficient independent instructions Large program size Trimedia uses memory compression Programs are 2-3 times larger than MIPS (even with compression)!

Fallacies and Pitfalls Pitfall: Designing a “high-level” instruction set to support HLL’s –Seldom provide an exact match –Often too general (VAX CALLS )

Fallacies and Pitfalls Fallacy: There is such a thing as a typical program –Programs vary very significantly Pitfall: Designing an architecture to reduce code size without considering compilers –Compilers have much greater impact on code size –Start with densest compiled code

Fallacies and Pitfalls Pitfall: Expecting good compiled performance for DSPs –Hand-tuned assembler is faster and more compact Fallacy: An architecture without flaws cannot be successful –80x86! Segments, accumulators, stack-based FP

Fallacies and Pitfalls Fallacy: You can design a flawless architecture –All designs have trade-offs VAX code size more important than easy decoding Early RISCs: delayed branches Address space

2.15. Concluding Remarks 1960’s: Stack architectures –Matched the compiler technology of the day 1970’s: CISC era –Tried to support HLL features in hardware Today: RISC era –Simple, load-store architectures

Concluding Remarks Trends in the 1990’s: –Move to 64 bits –Conditional instructions Eliminating branches –Optimisation of cache access (prefetch instructions) –Support for multimedia –Faster floating point

The Future Trend towards VLIW architectures Increased use of conditional execution Blending of general-purpose and DSP architectures Emulating 80x86 architecture