Browse Prior Art Database

Exception age determination on a SMT Superscalar Processor.

IP.com Disclosure Number: IPCOM000018882D
Original Publication Date: 2003-Aug-19
Included in the Prior Art Database: 2003-Aug-19
Document File: 4 page(s) / 48K

Publishing Venue

IBM

Abstract

On a Out-of-Order SMT Architecture we execute speculative interrupts and we need to keep track of the architectural register states of the oldest interrupt per threads. Instead of using the common out-of-order mechanisms like register rename or roleback, we use the Age detection method to maintain those architectural registers e.g. DAR(Data address register) and DSISR(Data Storage Interrupt Status Register.)

This text was extracted from a PDF file.
At least one non-text object (such as an image or picture) has been suppressed.
This is the abbreviated version, containing approximately 59% of the total text.

Page 1 of 4

Exception age determination on a SMT Superscalar Processor.

   Disclosed is a design to determine Age on an SMT superscalar processor. We will use Load Tags and Store Tags. Ltags and Stags are sequentially assigned to loads/ stores based on program order. There are 32 Ltags and 32 stags. The tags get assigned and when we reach tag 31 we wrap around to tag 0 if it is available. The completion pointer looks at the tag to be completed. In figure 1 we can see that the load A has and Ltag= 3 and load B has an Ltag= 9. The completion pointer is in ltag = 7 so we can see that the oldest load is load B. The same mechanism is used for stores.

0

31

3

9

7

load A

load B

completion ltag

Figure 1.

The way to assign ltags to loads and Stags to store it is used to determine age loads relative to loads and stores relative to stores. To determine age between a load and a store we assign to a Load an Ltag and an Stag, the same is true for a Store and the way they get assigned is the following:

-- Loads get the next available ltag and the last assigned Stag (Figure 2.) -- Stores get the next available Stag and the next available Ltag (Figure 2.)

Ld Ld St Ld St St Ltag 1 2 3 3 4 4 Stag 3 3 4 4 5 6

Figure 2. Assignment of Ltags and Stags on Load/Store type instructions.

1

Page 2 of 4

The way the algorithm works is the following way:

We use the following rules to determine age:

Ltags and Complete Ltags are used to detect older instruction between 2 loads. Ltags and Complete Ltags are used to detect older instruction between a load and a store. Stags and Complete Stags are used to detect older instruction between 2 stores.

We can see the sequence of instructions so we can see the 4 different cases where we will have to determine the 1 possible instructions to be committed to take and interrupt.

Case 1 (Ld-Ld):

Held Instr. Ld1(new instr)

(Ld0) Ltag 1 2 Stag 3 3 Complete Ltag = 5

2 Loads so we use the Ltags to determine age and since the complete ltag is 5 the older instruction is Ld0 and we hold now Ld0 Ltag and Stag as the oldest held instruction.

Case 2 (ld-St):

Held Instr. St(new instr)

(ld) Ltag 1 3 Stag 3 4 Complete Ltag = 8

A load and a Store so we use Ltags to determine age and since the complete ltag is 8 the older instructions is still the one being held then we don't load anything new.

Case 3 (Same tags):

Held Instr. St( new Instr)

(ld) Ltag 3 3 Stag 4 4 Complete Ltag = 3

In this case we have 2 instructions that have the exact same Ltag and Stag and its a Ld and a St then the algorithm decides that the store always wins when the tags are the same and there is a store involved either being held or being the new one on the pi...