{"id":91171,"date":"2015-08-05T07:00:00","date_gmt":"2015-08-05T21:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/20150805-00\/?p=91171\/"},"modified":"2019-03-13T12:18:07","modified_gmt":"2019-03-13T19:18:07","slug":"20150805-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20150805-00\/?p=91171","title":{"rendered":"The Itanium processor, part 8: Advanced loads"},"content":{"rendered":"

Today we’ll look at advanced loads, which is when you load a value before you’re supposed to, in the hope that the value won’t change in the meantime. <\/p>\n

Consider the following code: <\/p>\n

\nint32_t SomeClass::tryGetValue(int32_t *value)\n{\n if (!m_errno) {\n  *value = m_value;\n  m_readCount++;\n }\n return m_errno;\n}\n<\/pre>\n
Let’s say that the Some­Class<\/code> has m_value<\/code> at offset zero, m_errno<\/code> at offset 4, and m_readCount<\/code> at offset 8. <\/p>\n
The naïve way of compiling this function would go something like this: <\/p>\n
\n        \/\/ we are a leaf function, so no need to use \"alloc\" or to save rp.\n        \/\/ on entry: r32 = this, r33 = value\n\n        addl    r30 = 08h, r32          \/\/ calculate &m_errno\n        addl    r29 = 04h, r32 ;;       \/\/ calculate &m_readCount\n\n        ld4     ret0 = [r30] ;;         \/\/ load m_errno\n\n        cmp4.eq p6, p7 = ret0, r0       \/\/ p6 = m_errno == 0, p7 = !p6\n\n(p7)    br.ret.sptk.many rp             \/\/ return m_errno if there was an error¹\n\n        ld4     r31 = [r32] ;;          \/\/ load m_value (at offset 0)\n        st4     [r33] = r31 ;;          \/\/ store m_value to *value\n\n        ld4     r28 = [r29] ;;          \/\/ load m_readCount\n        addl    r28 = 01h, r28 ;;       \/\/ calculate m_readCount + 1\n        st4     [r29] = r28 ;;          \/\/ store updated m_readCount\n\n        ld4     ret0 = [r30]            \/\/ reload m_errno for return value\n\n        br.ret.sptk.many rp             \/\/ return\n<\/pre>\n
First, we calculate the addresses of our member variables. Then we load m_errno<\/code>, and if there is an error, then we return it immediately. Otherwise, we copy the current value to *value<\/code>, load m_readCount<\/code>, increment it, and finally, we return m_errno<\/code>. <\/p>\n
The problem here is that we have a deep dependency chain. <\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
<\/td>\n<\/td>\naddl r30 = 08h, r32<\/td>\n<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nld4 ret0 = [r30]<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\ncmp4.eq p6, p7 = ret0, r0<\/td>\n<\/tr>\n
<\/td>\n↙︎<\/td>\n↓<\/td>\n<\/tr>\n
(p7) br.ret.sptk.many rp<\/td>\n<\/td>\nld4 r31 = [r32]<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nst4 [r33] = r31<\/td>\n<\/td>\naddl r29 = 04h, r32<\/td>\n<\/tr>\n
non-obvious dependency<\/td>\n↓<\/td>\n↙︎<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nld4 r28 = [r29]<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\naddl r28 = 01h, r28<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nst4 [r29] = r28<\/td>\n<\/tr>\n
non-obvious dependency<\/td>\n↓<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nld4 ret0 = [r30]<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nbr.ret.sptk.many rp<\/td>\n<\/tr>\n<\/table>\n
Pretty much every instruction depends on the result of the previous instruction. Some of these dependencies are obvious. You have to calculate the address of a member variable before you can read it, and you have to get the result of a memory access befure you can perform arithmetic on it. Some of the dependencies are not obvious. For example, we cannot access m_value<\/code> or m_readCount<\/code> until after we confirm that m_errno<\/code> is zero to avoid a potential access violation if the object straddles a page boundary with m_errno<\/code> on one page and m_value<\/code> on the other (invalid) page. (We saw last time how this can be solved with speculative loads, but let’s not add that to the mix yet.) <\/p>\n
Returning m_errno<\/code> is a non-obvious dependency. We’ll see why later. For now, note that the return value came from a memory access, which means that if the caller of the function tries to use the return value, it may stall waiting for the result to arrive from the memory controller. <\/p>\n
When you issue a read on Itanium, the processor merely initiates the operation and proceeds to the next instruction before the read completes. If you try to use the result of the read too soon, the processor stalls until the value is received from the memory controller. Therefore, you want to put as much distance as possible between the load of a value from memory and the attempt to use the result. <\/p>\n
Let’s see what we can do to parallelize this function. We’ll perform the increment of m_readCount<\/code> and the fetch of m_value<\/code> simultaneously. <\/p>\n
\n        \/\/ we are a leaf function, so no need to use \"alloc\" or to save rp.\n        \/\/ on entry: r32 = this, r33 = value\n\n        addl    r30 = 08h, r32          \/\/ calculate &m_errno\n        addl    r29 = 04h, r32 ;;       \/\/ calculate &m_readCount\n\n        ld4     ret0 = [r30] ;;         \/\/ load m_errno\n\n        cmp4.eq p6, p7 = ret0, r0       \/\/ p6 = m_errno == 0, p7 = !p6\n\n(p7)    br.ret.sptk.many rp             \/\/ return m_errno if there was an error\n\n        ld4     r31 = [r32]             \/\/ load m_value (at offset 0)\n        ld4     r28 = [r29] ;;          \/\/ preload m_readCount\n\n        addl    r28 = 01h, r28          \/\/ calculate m_readCount + 1\n        st4     [r33] = r31 ;;          \/\/ store m_value to *value\n\n        st4     [r29] = r28             \/\/ store updated m_readCount\n\n        br.ret.sptk.many rp             \/\/ return (answer already in ret0)\n<\/pre>\n
We’ve basically rewritten the function as <\/p>\n
\nint32_t SomeClass::getValue(int32_t *value)\n{\n int32_t local_errno = m_errno;\n if (!local_errno) {\n  int32_t local_readCount = m_readCount;\n  int32_t local_value = m_value;\n  local_readCount = local_readCount + 1;\n  *value = local_value;\n  m_readCount = local_readCount;\n }\n return local_errno;\n}\n<\/pre>\n
This time we loaded the return value from m_errno<\/code> long before the function ends, so when the caller tries to use the return value, it will definitely be ready and not incur a memory stall. (If a stall were needed, it would have occurred at the cmp4<\/code>.) And we’ve also shortened the dependency chain significantly in the second half of the function. <\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
<\/td>\n<\/td>\naddl r30 = 08h, r32<\/td>\n<\/td>\n<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nld4 ret0 = [r30]<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\ncmp4.eq p6, p7 = ret0, r0<\/td>\n<\/td>\naddl r29 = 04h, r32<\/td>\n<\/tr>\n
<\/td>\n↙︎<\/td>\n↓<\/td>\n↘︎<\/td>\n↓<\/td>\n<\/tr>\n
(p7) br.ret.sptk.many rp<\/td>\n<\/td>\nld4 r31 = [r32]<\/td>\n<\/td>\nld4 r28 = [r29]<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nst4 [r33] = r31<\/td>\n<\/td>\naddl r28 = 01h, r28<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\nst4 [r29] = r28<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nbr.ret.sptk.many rp<\/td>\n<\/tr>\n<\/table>\n
This works great until somebody does this: <\/p>\n
\nint32_t SomeClass::Haha()\n{\n  return this->tryGetValue(&m_readCount);\n}\n<\/pre>\n
or even this: <\/p>\n
\nint32_t SomeClass::Hoho()\n{\n  return this->tryGetValue(&m_errno);\n}\n<\/pre>\n
Oops. <\/p>\n
Let’s look at Haha<\/code>. Suppose that our initial conditions are m_errno = 0<\/code>, m_value = 42<\/code>, and m_readCount = 0<\/code>. <\/p>\n\n\n\n\n\n\n\n\n\n
Original<\/th>\n<\/td>\nOptimized<\/th>\n<\/tr>\n
<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nlocal_errno = m_errno;<\/td>\n\/\/ true<\/td>\n<\/td>\n<\/tr>\n
if (!m_errno)<\/td>\n\/\/ true<\/td>\nif (!m_errno)<\/td>\n\/\/ true<\/td>\n<\/tr>\n
<\/td>\n<\/td>\nreadCount = m_readCount;<\/td>\n\/\/ 0<\/td>\n<\/td>\n<\/tr>\n
*value = m_value;<\/td>\n\/\/ m_readCount = 42<\/font><\/td>\n*value = m_value;<\/td>\n\/\/ m_readCount = 42<\/font><\/td>\n<\/tr>\n
m_readCount++;<\/td>\n\/\/ m_readCount = 43<\/td>\nm_readCount = readCount + 1;<\/td>\n\/\/ m_readCount = 1<\/font><\/td>\n<\/tr>\n
return m_errno;<\/td>\n\/\/ 0<\/td>\nreturn errno;<\/td>\n\/\/ 0<\/td>\n<\/tr>\n<\/table>\n
The original code copies the value<\/code> before incrementing the read count. This means that if the caller says that m_readCount<\/code> is the output variable, the act of copying the value modifies m_readCount<\/code><\/i>. This modified value is then incremented. Our optimized version does not take this case into account and sets m_readCount<\/code> to the old value incremented by 1. <\/p>\n
We were faked out by pointer aliasing! <\/p>\n
(A similar disaster occurs in Hoho<\/code>.) <\/p>\n
Now, whether the behavior described above is intentional or desirable is not at issue here. The C++ language specification requires that the original code result in the specified behavior, so the compiler is required to honor it. Optimizations cannot alter the behavior of standard-conforming code, even if that behavior seems strange to a human being reading it. <\/p>\n
But we can still salvage this optimization by handling the aliasing case. The processor contains support for aliasing detection via the ld.a<\/code> instruction. <\/p>\n
\n        \/\/ we are a leaf function, so no need to use \"alloc\" or to save rp.\n        \/\/ on entry: r32 = this, r33 = value\n\n        addl    r30 = 08h, r32          \/\/ calculate &m_errno\n        addl    r29 = 04h, r32 ;;       \/\/ calculate &m_readCount\n\n        ld4     ret0 = [r30] ;;         \/\/ load m_errno\n\n        cmp4.eq p6, p7 = ret0, r0       \/\/ p6 = m_errno == 0, p7 = !p6\n\n(p7)    br.ret.sptk.many rp             \/\/ return m_errno if there was an error\n\n        ld4     r31 = [r32]             \/\/ load m_value (at offset 0)\n        ld4.a   r28 = [r29] ;;          \/\/ preload m_readCount<\/font>\n\n        addl    r28 = 01h, r28          \/\/ calculate m_readCount + 1\n        st4     [r33] = r31             \/\/ store m_value to *value\n\n        chk.a.clr r28, recover ;;       \/\/ recover from pointer aliasing\nrecovered:\n        st4     [r29] = r28 ;;          \/\/ store updated m_readCount\n\n        br.ret.sptk.many rp             \/\/ return\n\nrecover:\n        ld4     r28 = [r29] ;;          \/\/ reload m_readCount\n        addl    r28 = 01h, r28          \/\/ recalculate m_readCount + 1\n        br      recovered               \/\/ recovery complete, resume mainline code\n<\/pre>\n
The ld.a<\/code> instruction is the same as an ld<\/code> instruction, but it also tells the processor that this is an advanced load<\/var>, and that the processor should stay on the lookout for any instructions that write to any bytes accessed by the load instruction. When the value is finally consumed, you perform a chk.a.clr<\/code> to check whether the value you loaded is still valid. If no instructions have written to the memory in the meantime, then great. But if the address was written to, the processor will jump to the recovery code you provided. The recovery code re-executes the load and any other follow-up calculations, then returns to the original mainline code path. <\/p>\n
The .clr<\/code> completer tells the processor to stop monitoring that address. It clears the entry from the Advanced Load Address Table, freeing it up for somebody else to use. <\/p>\n
There is also a ld.c<\/code> instruction which is equivalent to a chk.a<\/code> that jumps to a reload and then jumps back. In other words, <\/p>\n
\n    ld.c.clr r1 = [r2]\n<\/pre>\n
is equivalent to <\/p>\n
\n    chk.a.clr r1, recover\nrecovered:\n    ...\n\nrecover:\n    ld     r1 = [r2]\n    br     recovered\n<\/pre>\n
but is much more compact and doesn’t take branch penalties. This is used if there is no follow-up computation; you merely want to reload the value if it changed. <\/p>\n
As with recovery from speculative loads, we can inline some of the mainline code into the recovery code so that we don’t have to pad out the mainline code to get recovered<\/code> to sit on a bundle boundary. I didn’t bother doing it here; you can do it as an exercise. <\/p>\n
The nice thing about processor support for pointer aliasing detection is that it can be done across functions, something that cannot easily be done statically. Consider this function: <\/p>\n
\nvoid accumulateTenTimes(void (*something)(int32_t), int32_t *victim)\n{\n int32_t total = 0;\n for (int32_t i = 0; i < 10; i++) {\n  total += something(*victim);\n }\n *victim = total;\n}\n\nint32_t negate(int32_t a) { return -a; }\n\nint32_t value = 2;\naccumulateTenTimes(negate, &value);\n\/\/ result: value = -2 + -2 + -2 + ... + -2 = -20\n\nint32_t sneaky_negate(int32_t a) { value2 \/= 2; return -a; }\nint32_t value2 = 2;\naccumulateTenTimes(sneaky_negate, &value2);\n\/\/ result: value2 = -2 + -1 + -0 + -0 + ... + -0 = -3\n<\/pre>\n
When compiling the accumulate­Ten­Times<\/code> function, the compiler has no way of knowing whether the something<\/code> function will modify victim<\/code>, so it must be conservative and assume that it might, just in case we are in the sneaky_negate<\/code> case. <\/p>\n
Let’s assume that the compiler has done flow analysis and determined that the function pointer passed to accumulate­Ten­Times<\/code> is always within the same module, so it doesn’t need to deal with gp<\/code>. Since function descriptors are immutable, it can also enregister the function address. <\/p>\n
\n        \/\/ 2 input registers, 6 local registers, 1 output register\n        alloc   r34 = ar.pfs, 2, 6, 1, 0\n        mov     r35 = rp                \/\/ save return address\n        mov     r36 = ar.lc             \/\/ save loop counter\n        or      r37 = r0, r0            \/\/ total = 0\n        ld8     r38 = [r32]             \/\/ get the function address\n        or      r31 = 09h, r0 ;;        \/\/ r31 = 9\n        mov     ar.lc = r31             \/\/ loop nine more times (ten total)\nagain:\n        ld4     r39 = [r33]             \/\/ load *victim for output\n        mov     b6 = r38                \/\/ move to branch register\n        br.call.dptk.many rp = b6 ;;    \/\/ call function in b6\n        addl    r37 = ret0, r37         \/\/ accumulate total\n        br.cloop.sptk.few again ;;      \/\/ loop 9 more times\n\n        st4     [r33] = r37             \/\/ save the total\n\n        mov     ar.lc = r36             \/\/ restore loop counter\n        mov     rp = r35                \/\/ restore return address\n        mov     ar.pfs = r34            \/\/ restore stack frame\n        br.ret.sptk.many rp             \/\/ return\n<\/pre>\n
Note that at each iteration, we read *victim<\/code> from memory because we aren’t sure whether the something<\/code> function modifies it. But with advanced loads, we can remove the memory access from the loop. <\/p>\n
\n        \/\/ 2 input registers, 7 local registers, 1 output register\n        alloc   r34 = ar.pfs, 2, 7, 1, 0\n        mov     r35 = rp                \/\/ save return address\n        mov     r36 = ar.lc             \/\/ save loop counter\n        or      r37 = r0, r0            \/\/ total = 0\n        ld8     r38 = [r32]             \/\/ get the function address\n        or      r31 = 09h, r0 ;;        \/\/ r31 = 9\n        mov     ar.lc = r31             \/\/ loop nine more times (ten total)\n        ld4.a   r39 = [r33]             \/\/ get the value of *victim<\/font>\nagain:\n        ld4.c.nc r39 = [r33]            \/\/ reload *victim if necessary<\/font>\n        or      r40 = r39, r0           \/\/ set *victim as the output parameter\n        mov     b6 = r38                \/\/ move to branch register\n        br.call.dptk.many rp = b6 ;;    \/\/ call function in b6\n        addl    r37 = ret0, r37         \/\/ accumulate total\n        br.cloop.sptk.few again ;;      \/\/ loop 9 more times\n\n        invala.e r39                    \/\/ stop tracking r39<\/font>\n\n        st4     [r33] = r37             \/\/ save the total\n\n        mov     ar.lc = r36             \/\/ restore loop counter\n        mov     rp = r35                \/\/ restore return address\n        mov     ar.pfs = r34            \/\/ restore stack frame\n        br.ret.sptk.many rp             \/\/ return\n<\/pre>\n
We perform an advanced load of *value<\/code> in the hope that the callback function will not modify it. This is true if the callback function is negate<\/code>, but it will trigger reloads if the accumulator function is sneaky_negate<\/code>. <\/p>\n
Note here that we use the .nc<\/code> completer on the ld.c<\/code> instruction. This stands for no clear<\/var> and tells the processor to keep tracking the address because we will be checking it again. When the loop is over, we use invala.e<\/code> to tell the processor, “Okay, you can stop tracking it now.” This also shows how handy the ld.c<\/code> instruction is. We can do the reload inline rather than have to write separate recovery code and jumping out and back. <\/p>\n
(Processor trivia: We do not need a stop after the ld4.c.nc<\/code>. You are allowed to consume the result of a check load in the same instruction group.) <\/p>\n
In the case where the callback function does not modify value<\/code>, the only memory accesses performed by this function and the callback are loading the function address, loading the initial value from *value<\/code>, and storing the final value to *value<\/code>. The loop body itself runs without any memory access at all! <\/p>\n
Going back to our original function, I noted that we could also add speculation to the mix. So let’s do that. We’re going to speculate an advanced load! <\/p>\n
\n        \/\/ we are a leaf function, so no need to use \"alloc\" or to save rp.\n        \/\/ on entry: r32 = this, r33 = value\n\n        ld4.sa  r31 = [r32]             \/\/ speculatively preload m_value (at offset 0)<\/font>\n        addl    r30 = 08h, r32          \/\/ calculate &m_errno\n        addl    r29 = 04h, r32 ;;       \/\/ calculate &m_readCount\n\n        ld4.sa  r28 = [r29]             \/\/ speculatively preload m_readCount<\/font>\n        ld4     ret0 = [r30] ;;         \/\/ load m_errno\n\n        cmp4.eq p6, p7 = ret0, r0       \/\/ p6 = m_errno == 0, p7 = !p6\n\n(p7)    invala.e r31                    \/\/ abandon the advanced load\n(p7)    invala.e r28                    \/\/ abandon the advanced load<\/font>\n(p7)    br.ret.sptk.many rp             \/\/ return false if value not set\n\n        ld4.c.clr r31 = [r32]           \/\/ validate speculation and advanced load of m_value<\/font>\n        st4     [r33] = r31             \/\/ store m_value to *value\n\n        ld4.c.clr r28 = [r29]           \/\/ validate speculation and advanced load of m_readCount<\/font>\n        addl    r28 = 01h, r28 ;;       \/\/ calculate m_readCount + 1\n        st4     [r29] = r28             \/\/ store updated m_readCount\n\n        br.ret.sptk.many rp             \/\/ return\n<\/pre>\n
To validate a speculative advanced load, you just need to do a ld.c<\/code>. If the speculation failed, then the advanced load also fails, so all we need to do is check the advanced load. and the reload will raise the exception. <\/p>\n
The dependency chain for this function is even shorter now that we were able to speculate the case where there is no error. (Since you are allowed to consume an ld4.c<\/code> in the same instruction group, I combined the ld4.c<\/code> and its consumption in a single box since they occur within the same cycle.) <\/p>\n\n\n\n\n\n\n\n\n
ld4.sa r31 = [r32]<\/td>\n<\/td>\naddl r30 = 08h, r32<\/td>\n<\/td>\naddl r29 = 04h, r32<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\nld4 ret0 = [r30]<\/td>\n<\/td>\nld4.sa r28 = [r29]<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\n↓<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\ncmp4.eq p6, p7 = ret0, r0<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
↓<\/td>\n↙︎<\/td>\n↓<\/td>\n↘︎<\/td>\n↓<\/td>\n<\/tr>\n
\n\n\n
ld4.c<\/td>\nst4 [r33] = r31<\/td>\n<\/tr>\n<\/table>\n<\/td>\n<\/td>\n\n\n\n
invala.e r31<\/td>\ninvala.e r28<\/td>\nbr.ret rp<\/td>\n<\/tr>\n<\/table>\n<\/td>\n<\/td>\n\n\n\n\n\n\n\n
ld4.c<\/td>\naddl r28 = 01h, r28<\/td>\n<\/tr>\n<\/table>\n<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\n<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\n<\/td>\n<\/td>\nst4 [r29] = r28<\/td>\n<\/td>\n<\/tr>\n
↓<\/td>\n<\/td>\n<\/td>\n<\/td>\n↓<\/td>\n<\/tr>\n
br.ret.sptk.many rp<\/td>\n<\/tr>\n<\/table>\n
Aw, look at that pretty diagram. Control speculation and data speculation allowed us to run three different operations in parallel even though they might have dependencies on each other. The idea here is that if profiling suggests that the dependencies are rarely realized (pointers are usually not aliased), you can use speculation to run the operations as if they had no dependencies, and then use the check instructions to convert the speculated results to real ones. <\/p>\n
¹ Note the absence of a stop between the cmp4<\/code> and the br.ret<\/code>. That’s because of a special Itanium rule that says that a conditional branch is permitted to use a predicate register calculated earlier within the same instruction group. (Normally, instructions within an instruction group are not allowed to have dependencies among each other.) This allows a test and jump to occur within the same cycle. <\/p>\n","protected":false},"excerpt":{"rendered":"
I hoped you were going to say that.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[26],"class_list":["post-91171","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-other"],"acf":[],"blog_post_summary":"
I hoped you were going to say that.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/91171","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=91171"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/91171\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=91171"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=91171"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=91171"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}