Stanford EE380 5/29/2013 - PowerPoint PPT Presentation

Presentation Transcript

Stanford EE380 5/29/2013

Drinking from the Firehose

Decode in the Mill™ CPU Architecture

The Mill Architecture

Instructions -

Format and decoding

New to the Mill:

Dual code streams

No-parse instruction shifting

Double-ended decode

Zero-length no-ops

In-line constants to 128 bits

addsx(b2, b5)

What chip architecture is this?

cores: 4cores

issuing:4operations

clock rate: 3300MHz

power: 130Watts

performance: 52.8 Gips

price: $885dollars

?

general-purpose out-of-order superscalar

(Intel XEON E5-2643)

What chip architecture is this?

cores: 1 core

issuing: 8operations

clock rate: 456 MHz

power: 1.1 Watts

price: $17dollars

?

in-order VLIW signal processor

(Texas Instruments TMS320C6748)

Which is better?

cores: 4 cores

issuing: 4 operations

clock rate: 3300 MHz

power: 130 Watts

price: $885 dollars

out-of-order superscalar

performance per Watt per dollar

cores: 1 core

clock rate: 456 MHz

power: 1.1 Watts

price: $17 dollars

in-order VLIW DSP

Which is better?

cores: 4 cores

power: 130 Watts

price: $885 dollars

out-of-order superscalar

0.46 mips/W/$

cores: 1 core

clock rate: 456 MHz

power: 1.1 Watts

price: $17 dollars

in-order VLIW DSP

195 mips/W/$

Which is better?

Why 400X difference?

32 vs. 64 bit
3,600 mips vs. 52,800 mips
incompatible workloads

signal processing ≠ general-purpose

goal – and technical challenge:

DSP numbers

- on general-purpose workloads

Our result:

cores: 2 cores

power: 28 Watts

price: $85 dollars

OOTBC Mill Gold.x2

33 Mips/W/$

superscalar 0.46 DSP 195

Which is better?

33 operations per cycle peak ??? Why?

80% of code is in loops

Pipelined loops have unbounded ILP

DSP loops are software-pipelined

But –

few general-purpose loops can be piped
(at least on conventional architectures)

Solution:

pipeline (almost) all loops
throw function hardware at pipe

Result: loops now < 15% of cycles

Which is better?

33 operations per cycle peak ??? How?

Biggest problem is decode

Fixed length instructions:

Easy to parse

Instruction size:

32 bits X 33 ops = 132 bytes.

Ouch!

Instruction cache pressure.

32k iCache = only 248 instructions

Ouch!!

Which is better?

33 operations per cycle peak ??? How?

Variable length instructions:

Hard to parse – x86 heroics gets 4 ops

Instruction size:

Mill ~15 bits X 33 ops = 61 bytes.

Ouch!

32k iCache = only 537 instructions

Ouch!!

Biggest problem is decode

A stream of instructions

Logical model

inst

Program

counter

decode

execute

bundle

Physical model

inst

execute

Program

counter

decode

execute

Fixed-length instructions

bundle

inst

Program

counter

decode

execute

Are easy!

(and BIG)

Variable-length instructions

bundle

inst

?

Program

counter

decode

execute

Where does the next one start?

Polynomial cost!

Polynomial cost

bundle

inst

OK if N=3, not if N=30

BUT…

Two bundles of length N are much easier than one bundle of length 2N

Program

counter

So split each bundle in half, and have two streams of half-bundles

Two streams of half-bundles

half bundle

inst

Two physical streams

Program

counter

decode

execute

Program

counter

decode

One logical stream

inst

But – how do you branch two streams?

half bundle

Extended Basic Blocks (EBBs)

Group each stream into Extended Basic Blocks, single-entry multiple-exit sequences of bundles.
Branches can only target EBB entry points; it is not possible to jump into the middle of an EBB.

EBB

EBB

Program

counter

EBB

EBB chain

branch

Program

counter

EBB chain

EBB

EBB

EBB

Take two half-EBBs

lower memory higher memory

bundle

EBB head

execution order

EBB head

Take two half-EBBs

Reverse one in memory

bundle

execution order

EBB head

bundle

Two halves of each instruction have same color

bundle

Two halves of each instruction have same color

execution order

bundle

EBB head

And join them head-to-head

Reverse one in memory

bundle

EBB head

bundle

EBB head

entry point

bundle

EBB head

Take a branch…

entry point

bundle

…

add …

load …

jump loop

Effective address

Take a branch…

program

counter

program

counter

entry point

bundle

…

add …

load …

jump loop

Effective address

Take a branch…

program

counter

higher

addresses

program

counter

lower

addresses

bundle

decode

execute

Take a branch…

program

counter

higher

addresses

program

counter

lower

addresses

bundle

decode

execute

Take a branch…

program

counter

higher

addresses

program

counter

lower

addresses

bundle

decode

execute

After a branch

Transfers of control set both XPC and FPC to the entry point

cycle 0

cycle n

memory

Flowcode

FPC

EBB entry point

XPC

Exucode

Program counters:

XPC = Exucode

FPC = Flowcode

XPC moves forward

FPC moves backwards

XPC

increasingaddresses

Physical layout

Conventional

Mill

iCache

critical distance

iCache

critical distance

decode

exec

critical distance

decode

iCache

critical distance

iCache

decode

exec

Generic Mill bundle format

The Mill issues one instruction (two half-bundles) per cycle.
That one instruction can call for many independent operations, all of which issue together and execute in parallel.

byte boundary

alignment hole

byte boundary

header

block 1

block 2

block n

block n-1

variable length blocks

Each instruction bundle begins with a fixed-length header, followed by blocks of operations; all operations in a block use the same format. The header contains the byte count of the whole bundle and an operation count for each block. Parsing reduces to isolating blocks.

Generic instruction decode

cycle 0

byte boundary

header

block 2

instruction

buffer

block 1

block 1 count to

block2 shifter &

block 1 decode

Byte count to

instruction shifter

to block 2 shifter

to block 1 decode

cycle 1

byte boundary

bundle

buffer

header

hole

block 3

block 1

Bundle is parsed from both ends toward the middle. Two blocks are isolated per cycle

to block 3 decode

block 2

buffer

block 2

to block 2 decode

Elided No-ops

Sometimes a cycle has work only for Exu, only for Flow, or neither. The number of cycles to skip is encoded in the alignment hole of the other code stream.

Exucode:

Flowcode:

hole

head

0

op

head

0

op

head

1

op