Data Speculation Concepts

An ambiguous memory dependency is said to exist between a store (or any operation that may update memory state) and a load when it cannot be statically determined whether the load and store might access overlapping regions of memory. For convenience, a store that cannot be statically disambiguated relative to a particular load is said to be ambiguous relative to that load. In such cases, the compiler cannot change the order in which the load and store instructions were originally specified in the program. To overcome this scheduling limitation, a special kind of load instruction called an advanced load can be scheduled to execute earlier than one or more stores that are ambiguous relative to that load.

As with control speculation, the compiler can also speculate operations that are dependent upon the advanced load and later insert a check instruction that will determine whether the speculation was successful or not. For data speculation, the check can be placed anywhere the original non-data speculative load could have been scheduled.

Thus, a data-speculative sequence of instructions consists of an advanced load, zero or more instructions dependent on the value of that load, and a check instruction. This means that any sequence of stores followed by a load can be transformed into an advanced load followed by a sequence of stores followed by a check. The decision to perform such a transformation is highly dependent upon the likelihood and cost of recovering from an unsuccessful data speculation.

4.4.5.2

Data Speculation and Instructions

Advanced loads are available in integer (ld.a), floating-point (ldf.a), and floating-point pair (ldfp.a) forms. When an advanced load is executed, it allocates an entry in a structure called the Advanced Load Address Table (ALAT). Later, when a corresponding check instruction is executed, the presence of an entry indicates that the data speculation succeeded; otherwise, the speculation failed and one of two kinds of compiler-generated recovery is performed:

1. The check load instruction (ld.c, ldf.c, or ldfp.c) is used for recovery when the only instruction scheduled before a store that is ambiguous relative to the advanced load is the advanced load itself. The check load searches the ALAT for a matching entry. If found, the speculation was successful; if a matching entry was not found, the speculation was unsuccessful and the check load reloads the correct value from memory. Figure 4-2 shows this transformation.

2. The advanced load check (chk.a) is used when an advanced load and several instructions that depend on the loaded value are scheduled before a store that is ambiguous relative to the advanced load. The advanced load check works like the speculation check (chk.s) in that, if the speculation was successful, execution continues inline and no recovery is necessary; if speculation was unsuccessful, the chk.a branches to compiler-generated recovery code. The recovery code contains instructions that will re-execute all the work that was dependent on

Figure 4-2. Data Speculation Recovery Using ld.c

Before Data Speculation After Data Speculation

// other instructions

st8 [r4] = r12

ld8 r6 = [r8];;

add r5 = r6, r7;;

st8 [r18] = r5

ld8.a r6 = [r8];; // advanced load // other instructions

st8 [r4] = r12

ld8.c.clr r6 = [r8] // check load

add r5 = r6, r7;;

the failed data speculative load up to the point of the check instruction. As with the check load, the success of a data speculation using an advanced load check is determined by searching the ALAT for a matching entry. This transformation is shown in Figure 4-3.

Recovery code may use either a normal or advanced load to obtain the correct value for the failed advanced load. An advanced load is used only when it is advantageous to have an ALAT entry reallocated after a failed speculation. The last instruction in the recovery code should branch to the instruction following the chk.a.

4.4.5.3

Detailed Functionality of the ALAT and Related Instructions

The ALAT is the structure that holds the state necessary for advanced loads and checks to operate correctly. The ALAT is searched in two different ways: by physical addresses and by ALAT register tags. An ALAT register tag is a unique number derived from the physical target register number and type in conjunction with other implementation-specific state. Implementation-specific state might include register stack wraparound information to distinguish one instance of a physical register that may have been spilled by the RSE from the current instance of that register, thus avoiding the need to purge the ALAT on all register stack wraparounds.

IA-32 instruction set execution leaves the contents of the ALAT undefined. Software can not rely on ALAT values being preserved across an instruction set transition. On entry to IA-32 instruction set, existing entries in the ALAT are ignored.

4.4.5.3.1

Allocating and Checking ALAT Entries

Advanced loads perform the following actions:

1. The ALAT register tag for the advanced load is computed. (For ldfp.a, a tag is computed only for the first target register.)

2. If an entry with a matching ALAT register tag exists, it is removed.

3. A new entry is allocated in the ALAT which contains the new ALAT register tag, the load access size, and a tag derived from the physical memory address.

4. The value at the address specified in the advanced load is loaded into the target register and, if specified, the base register is updated and an implicit prefetch is performed.

Figure 4-3. Data Speculation Recovery Using chk.a

Before Data Speculation After Data Speculation

// other instructions st8 [r4] = r12 ld8 r6 = [r8];; add r5 = r6, r7;; st8 [r18] = r5 ld8.a r6 = [r8];; // other instructions add r5 = r6, r7;; // other instructions st8 [r4] = r12

chk.a.clr r6, recover back:

st8 [r18] = r5

// somewhere else in program recover:

ld8 r6 = [r8];;

add r5 = r6, r7

Since the success of a check is determined by finding a matching register tag in the ALAT, both the

chk.a and the target register of a ld.c must specify the same register as their corresponding advanced load. Additionally, the check load must use the same address and operand size as the corresponding advanced load; otherwise, the value written into the target register by the check load is undefined.

An advanced load check performs the following actions:

1. It looks for a matching ALAT entry and if found, falls through to the next instruction. 2. If no matching entry is found, the chk.a branches to the specified address.

An implementation may choose to implement a failing advanced load check directly as a branch or as a fault where the fault-handler emulates the branch. Although the expected mode of operation is for an implementation to detect matching entries in the ALAT during checks, an implementation may fail a check instruction even when an entry with a matching ALAT register tag exists. This will be a rare occurrence but software must not assume that the ALAT does not contain the entry. A check load checks for a matching entry in the ALAT. If no matching entry is found, it reloads the value from memory and any faults that occur during the memory reference are raised. When a matching entry is found, there is flexibility in the actions that a processor can perform:

1. The implementation may choose to either leave the target register unchanged or to reload the value from memory.

2. If the implementation chooses to leave the target register unchanged and a fault related to the data access or translation of the check load occurs, the implementation may choose to either raise the fault or ignore it and continue execution. The only faults that can be ignored are those related to data access and translation. See Table 5-5 on page 5-14.

3. If the implementation chooses to perform a reload, then any faults that occur because of the reload can not be ignored.

4. If the size, type, or address fields in the matching ALAT entry do not match that provided by a check load, the value returned by the check load is undefined. In such cases the

implementation may choose to raise a fault or when the “no clear” variant of the check load is issued, an implementation may choose to update the address, size, or type fields of the matching ALAT entry or to leave the entry unchanged.

If the check load was an ordered check load (ld.c.clr.acq), then it is performed with the semantics of an ordered load (ld.acq). ALAT register tag lookups by advanced load checks and check loads are subject to memory ordering constraints as outlined in “Memory Access Ordering” on page 4-25.

In addition to the flexibility described above, the size, organization, matching algorithm, and replacement algorithm of the ALAT are implementation dependent. Thus, the success or failure of specific advanced loads and checks in a program may change: when the program is run on different processor implementations, within the execution of a single program on the same implementation, or between different runs on the same implementation.

4.4.5.3.2

Invalidating ALAT Entries

In addition to entries removed by advanced loads, ALAT entry invalidations can occur implicitly by events that alter memory state or explicitly by any of the following instructions: ld.c.clr,

ld.c.clr.acq, chk.a.clr, invala, invala.e. Events that may implicitly invalidate ALAT entries include those that change memory state or memory translation state such as:

1. The execution of stores, semaphores, or ptc.ga on other processors in the coherence domain.

2. The execution of store or semaphore instructions issued on the local processor. 3. Platform-visible removal of a cache line from the processor’s caches.

When one of these events occurs, hardware checks each memory region represented by an entry in the ALAT to see if it overlaps with the locations affected by the invalidation event. ALAT entries whose memory regions overlap with the invalidation event locations are removed. Note that some invalidation events may require that multiple entries be removed from the ALAT. For example, the

ptc.ga instruction is page aligned, thus a ptc.ga from another processor would require that hardware invalidate all ALAT entries related to that page. Stores due to RSE spills are not checked for ALAT invalidation and do not cause ALAT entries to be removed. See “RSE and ALAT Interaction” on page 6-14 in Volume 2. When an external agent can observe that the processor has removed a physical address range from its caches, then that address range is guaranteed to be invalidated from that processor’s ALAT as well.

An implementation may invalidate entries over areas larger than explicitly required by a specific invalidation event. For example, a st1 only accesses one byte, but an implementation could choose to invalidate all ALAT entries whose memory region is in the same cache line.Software is

responsible for explicitly invalidating all affected ALAT entries whenever:

1. Software explicitly changes the virtual to physical register mapping on rotating registers that have been the target of advanced loads (clrrrb).

2. Software changes the virtual to physical memory mapping.

3. Software accesses the RSE backing store with advanced loads. See “RSE and ALAT Interaction” on page 6-14 (since RSE stores do not invalidate ALAT entries).

4. Software explicitly changes the virtual to physical register mapping on stacked registers by switching the RSE backing stores. See “Synchronous Backing Store Switch” on page 6-16.

4.4.5.4

Combining Control and Data Speculation

Control speculation and data speculation are not mutually exclusive; a given load may be both control and data speculative. Both control speculative (ld.sa, ldf.sa, ldfp.sa) and non-control speculative (ld.a, ldf.a, ldfp.a) variants of advanced loads are defined for general and floating- point registers. If a speculative advanced load generates a deferred exception token then:

1. Any existing ALAT entry with the same ALAT register tag is invalidated. 2. No new ALAT entry is allocated.

3. If the target of the load was a general-purpose register, its NaT bit is set.

4. If the target of the load was a floating-point register, then NaTVal is written to the target register.

If a speculative advanced load does not generate a deferred exception, then its behavior is the same as the corresponding non-control speculative advanced load.

Since there can be no matching entry in the ALAT after a deferred fault, a single advanced load check or check load is sufficient to check both for data speculation failures and to detect deferred exceptions.