SPECTECTOR: Principled Detection of Speculative Information Flows
Marco Guarnieri, Boris K\"opf, Jos\'e F. Morales, Jan Reineke,, Andr\'es S\'anchez
TL;DR
This paper introduces a formal security notion called speculative non-interference and presents SPECTECTOR, a symbolic execution tool that automatically verifies security against speculative execution attacks and identifies potential leaks.
Contribution
It defines the first semantic security model for speculative execution attacks and provides an automated tool to verify and analyze countermeasures in real-world code.
Findings
SPECTECTOR effectively detects subtle speculative leaks.
The tool uncovers optimization opportunities in compiler countermeasures.
Checking speculative non-interference scales reasonably with program complexity.
Abstract
Since the advent of SPECTRE, a number of countermeasures have been proposed and deployed. Rigorously reasoning about their effectiveness, however, requires a well-defined notion of security against speculative execution attacks, which has been missing until now. In this paper (1) we put forward speculative non-interference, the first semantic notion of security against speculative execution attacks, and (2) we develop SPECTECTOR, an algorithm based on symbolic execution to automatically prove speculative non-interference, or to detect violations. We implement SPECTECTOR in a tool, which we use to detect subtle leaks and optimizations opportunities in the way major compilers place SPECTRE countermeasures. A scalability analysis indicates that checking speculative non-interference does not exhibit fundamental bottlenecks beyond those inherited by symbolic execution.
Click any figure to enlarge with its caption.
Figure 1
Figure 2Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
frame = tb, belowskip=.4aboveskip=.4showstringspaces = false, breaklines = true, breakatwhitespace = true, tabsize = 3, numbers = left, stepnumber = 1, numberstyle = , language = [ANSI]C, alsoletter=.$, basicstyle=, stringstyle=, keywordstyle=, keywordstyle=[2], keywordstyle=[3], keywordstyle=[4], otherkeywords = temp,y,A,B,k,size, morekeywords = [2]A,B, morekeywords = [3], morekeywords = [4]y,size,k,temp,
frame = tb, belowskip=.4aboveskip=.4showstringspaces = false, breaklines = true, breakatwhitespace = true, tabsize = 3, numbers = left, stepnumber = 1, numberstyle = , alsoletter=.$%, basicstyle=, stringstyle=, keywordstyle=, keywordstyle=[2], keywordstyle=[3], keywordstyle=[4], keywordstyle=[5], keywords = cmova, cmovae, cmovb, cmove, cmovne, cmovbe, mov, xor, or, jbe, jne, add, jmp, cmp, shl, and, sar, lfence, jae, clt, and, lea, morekeywords = , morekeywords = [2]A, B, morekeywords = [3]%rax, %rbx, %rcx, %eax, %ecx, %rbp, %cl, %rdi, %edx, %esi, %rsi, %rdx, %rsp, %al, %rip, %ax, %bx, %cx, %bp, %di, %dx, %si, %sp, %ip, %r8b, morekeywords = [4]k, y, size, temp, morekeywords = [5]END, .L1, .L2
Spectector: Principled Detection of
Speculative Information Flows
Marco Guarnieri1, Boris Köpf2, José F. Morales1, Jan Reineke3, and Andrés Sánchez1
1IMDEA Software Institute 2Microsoft Research 3Saarland University
Abstract
Since the advent of Spectre, a number of countermeasures have been proposed and deployed. Rigorously reasoning about their effectiveness, however, requires a well-defined notion of security against speculative execution attacks, which has been missing until now.
In this paper (1) we put forward speculative non-interference, the first semantic notion of security against speculative execution attacks, and (2) we develop Spectector, an algorithm based on symbolic execution to automatically prove speculative non-interference, or to detect violations.
We implement Spectector in a tool, which we use to detect subtle leaks and optimizations opportunities in the way major compilers place Spectre countermeasures. A scalability analysis indicates that checking speculative non-interference does not exhibit fundamental bottlenecks beyond those inherited by symbolic execution.
I Introduction
Speculative execution avoids expensive pipeline stalls by predicting the outcome of branching (and other) decisions, and by speculatively executing the corresponding instructions. If a prediction is incorrect, the processor aborts the speculative execution and rolls back the effect of the speculatively executed instructions on the architectural (ISA) state, which consists of registers, flags, and main memory.
However, the speculative execution’s effect on the microarchitectural state, which comprises the content of the cache, is not (or only partially) rolled back. This side effect can leak information about the speculatively accessed data and thus violate confidentiality. The family of Spectre attacks [1, 2, 3, 4, 5] demonstrates that this vulnerability affects all modern general-purpose processors and poses a serious threat for platforms with multiple tenants.
Since the advent of Spectre, a number of countermeasures have been proposed and deployed. At the software-level, these include, for instance, the insertion of serializing instructions [6], the use of branchless bounds checks [7], and speculative load hardening [8]. Several compilers support the automated insertion of these countermeasures during compilation [9, 10, 8], and the first static analyses to help identify vulnerable code patterns are emerging [11].
However, we still lack a precise characterization of security against speculative execution attacks. Such a characterization is a prerequisite for reasoning about the effectiveness of countermeasures, and for making principled decisions about their placement. It would enable one, for example, to identify cases where countermeasures do not prevent all attacks, or where they are unnecessary.
Our approach
We develop a novel, principled approach for detecting information flows introduced by speculative execution, and for reasoning about software defenses against Spectre-style attacks. Our approach is backed by a semantic notion of security against speculative execution attacks, and it comes with an algorithm, based on symbolic execution, for proving the absence of speculative leaks.
Defining security
The foundation of our approach is speculative non-interference, a novel semantic notion of security against speculative execution attacks. Speculative non-interference is based on comparing a program with respect to two different semantics:
- •
The first is a standard, non-speculative semantics. We use this semantics as a proxy for the intended program behavior.
- •
The second is a novel, speculative semantics that can follow mispredicted branches for a bounded number of steps before backtracking. We use this semantics to capture the effect of speculatively executed instructions.
In a nutshell, speculative non-interference requires that speculatively executed instructions do not leak more information into the microarchitectural state than what the intended behavior does, i.e., than what is leaked by the standard, non-speculative semantics.
To capture “leakage into the microarchitectural state”, we consider an observer of the program execution that sees the locations of memory accesses and jump targets. This observer model is commonly used for characterizing “side-channel free” or “constant-time” code [12, 13] in the absence of detailed models of the microarchitecture.
Under this observer model, an adversary may distinguish two initial program states if they yield different traces of memory locations and jump targets. Speculative non-interference (SNI) requires that two initial program states can be distinguished under the speculative semantics only if they can also be distinguished under the standard, non-speculative semantics.
The speculative semantics, and hence SNI, depends on the decisions taken by a branch predictor. We show that one can abstract from the specific predictor by considering a worst-case predictor that mispredicts every branching decision. SNI w.r.t. this worst-case predictor implies SNI w.r.t. a large class of real-world branch predictors, without introducing false alarms.
Checking speculative non-interference
We propose Spectector, an algorithm to automatically prove that programs satisfy SNI. Given a program , Spectector uses symbolic execution with respect to the speculative semantics and the worst-case branch predictor to derive a concise representation of the traces of memory accesses and jump targets during execution along all possible program paths.
Based on this representation, Spectector creates an SMT formula that captures that, whenever two initial program states produce the same memory access patterns in the standard semantics, they also produce the same access patterns in the speculative semantics. Validity of this formula for each program path implies speculative non-interference.
Case studies
We implement a prototype of Spectector, with a front end for parsing (a subset of) x86 assembly and a back end for solving SMT formulas using the Z3 SMT solver. We perform two case studies where we evaluate the precision and scalability of Spectector.
- •
For evaluating precision, we analyze the 15 variants of Spectre v1 by Kocher [14]. We create a corpus of 240 microbenchmarks by compiling the 15 programs with the Clang, Intel Icc, and Microsoft Visual C++ compilers, using different levels of optimization and protection against Spectre. Using Spectector, we successfully (1) detect all leaks pointed out in [14], (2) detect novel, subtle leaks that are out of scope of existing approaches that check for known vulnerable code patterns [11], and (3) identify cases where compilers unnecessarily inject countermeasures, i.e., opportunities for optimization without sacrificing security.
- •
For evaluating scalability, we apply Spectector to the codebase of the Xen Project Hypervisor. Our evaluation indicates that the cost of checking speculative non-interference is comparable to that of discovering symbolic paths, which shows that our approach does not exhibit bottlenecks beyond those inherited by symbolic execution.
Scope
We focus on leaks introduced by speculatively executed instructions resulting from mispredicted branch outcomes, such as those exploited in Spectre v1 [2]. For an in-depth discussion of our approach’s scope, see Section X.
Summary of contributions
Our contributions are both theoretical and practical. On the theoretical side, we present speculative non-interference, the first semantic notion of security against speculative execution attacks. On the practical side, we develop Spectector, an automated technique for detecting speculative leaks (or prove their absence), and we use it to detect subtle leaks – and optimization opportunities – in the way compilers inject Spectre countermeasures.
Spectector is available at https://spectector.github.io. \IfEqCasefalsetrueAn extended version of this paper containing proofs of the technical results is available at [techReport].
II Illustrative example
To illustrate our approach, we show how Spectector applies to the Spectre v1 example [2] shown in Figure 1.
Spectre v1
The program checks whether the index stored in the variable y is less than the size of the array A, stored in the variable size. If that is the case, the program retrieves A[y], amplifies it with a multiple (here: 512) of the cache line size, and uses the result as an address for accessing the array B.
If size is not cached, evaluating the branch condition requires traditional processors to wait until size is fetched from main memory. Modern processors instead speculate on the condition’s outcome and continue the computation. Hence, the memory accesses in line 2 may be executed even if .
When size becomes available, the processor checks whether the speculated branch is the correct one. If it is not, it rolls back the architectural (i.e., ISA) state’s changes and executes the correct branch. However, the speculatively executed memory accesses leave a footprint in the microarchitectural state, in particular in the cache, which enables an adversary to retrieve A[y], even for , by probing the array B.
Detecting leaks with Spectector
Spectector automatically detects leaks introduced by speculatively executed instructions, or proves their absence. Specifically, Spectector detects a leak whenever executing the program under the speculative semantics, which captures that the execution can go down a mispredicted path for a bounded number of steps, leaks more information into the microarchitectural state than executing the program under a non-speculative semantics.
To illustrate how Spectector operates, we consider the x86 assembly111We use a simplified AT&T syntax without operand sizes translation of Figure 1’s program (cf. Figure 2).
Spectector performs symbolic execution with respect to the speculative semantics to derive a concise representation of the concrete traces of memory accesses and program counter values along each path of the program. These symbolic traces capture the program’s effect on the microarchitectural state.
During speculative execution, the speculatively executed parts are determined by the predictions of the branch predictor. As shown in Section V-C, leakage due to speculative execution is maximized under a branch predictor that mispredicts every branch. The code in Figure 2 yields two symbolic traces w.r.t. the speculative semantics that mispredicts every branch:222For simplicity of presentation, the example traces capture only loads but not the program counter.
[TABLE]
[TABLE]
where {{{{\tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ (\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{A}}}}}+\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{y}}}}})\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ (\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{B}}}}}+\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{A}}[{\@listingGroup{ltx_lst_identifier}{y}}]{\@listingGroup{ltx_lst_space}{}}\textasteriskcentered{\@listingGroup{ltx_lst_space}{}}512}}}). Here, the argument of {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}} is visible to the observer, while {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}} and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}} denote the start and the end of a misspeculated execution. The traces of the non-speculative semantics are obtained from those of the speculative semantics by removing all observations in between {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}} and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}.
Trace 1 shows that whenever y is in bounds (i.e., ) the observations of the speculative semantics and the non-speculative semantics coincide (i.e. they are both ). In contrast, Trace 2 shows that whenever , the speculative execution generates observations that depend on A[y] whose value is not visible in the non-speculative execution. This is flagged as a leak by Spectector.
Proving security with Spectector
The Clang 7.0.0 C++ compiler implements a countermeasure, called speculative load hardening [8], that applies conditional masks to addresses to prevent leaks into the microarchitectural state. Figure 3 depicts the protected output of Clang on the program from Figure 1.
The symbolic execution of the speculative semantics produces, as before, Trace 1 and Trace 2, but with
[TABLE]
where corresponds to the conditional move in line and is a bitwise-or operator. Here, is a symbolic if-then-else expression evaluating to 0x0 if and to 0xFF..FF otherwise.
The analysis of Trace 1 is as before. For Trace 2, however, Spectector determines (via a query to Z3 [15]) that, for all there is exactly one observation that the adversary can make during the speculative execution, namely {{{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ (\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{A}}}}}+\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{y}}}}})\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ (\leavevmode\lstinline{{\lst@@@set@language\lst@@@set@numbers\lst@@@set@frame\lst@@@set@rulecolor\lst@@@set@numbers\lst@@@set@frame{\@listingGroup{ltx_lst_identifier}{B}}}}}+\texttt{0xFF..FF}), from which it concludes that no information leaks into the microarchitectural state, i.e., the countermeasure is effective in securing the program. See Section VIII for examples where Spectector detects that countermeasures are not applied effectively.
III Language and Semantics
We now introduce Asm, a core assembly language which we use for defining speculative non-interference and describing Spectector.
III-A Syntax
The syntax of Asm is defined in Figure 4. Expressions are built from a set of register identifiers , which contains a designated element representing the program counter, and a set of values, which consists of the natural numbers and . Asm features eight kinds of instructions: a instruction, (conditional) assignments, load and store instructions, branching instructions, indirect jumps, and speculation barriers . Both conditional assignments and speculation barriers are commonly used to implement Spectre countermeasures [6, 8].
A Asm program is a sequence of pairs , where is an instruction and is a value representing the instruction’s label. We say that a program is well-formed if (1) it does not contain duplicate labels, (2) it contains an instruction labeled with [math], i.e., the initial instruction, and (3) it does not contain branch instructions of the form . In the following we consider only well-formed programs.
We often treat programs as partial functions from natural numbers to instructions. Namely, given a program and a number , we denote by the instruction labelled with in if it exists, and otherwise.
Example 1**.**
The Spectre v1 example from Figure 1 can be expressed in Asm as follows:
[TABLE]
Here, registers , , and store the respective variables. Similarly, registers and store the memory addresses of the first elements of the arrays A and B.
III-B Non-speculative Semantics
The standard, non-speculative semantics models the execution of Asm programs on a platform without speculation. This semantics is formalized as a ternary relation mapping a configuration to a configuration , while producing an observation . Observations are used to capture what an adversary can see about a given execution trace. We describe the individual components of the semantics below.
Configurations
A configuration is a pair of a memory and a register assignment , modeling the state of the computation. Memories are functions mapping memory addresses, represented by natural numbers, to values in . Register assignments are functions mapping register identifiers to values. We require that can only be assigned to the program counter , signaling termination. A configuration is initial (respectively final) if (respectively ). We denote the set of all configurations by .
Adversary model and observations
We consider an adversary that observes the program counter and the locations of memory accesses during computation. This adversary model is commonly used to formalize timing side-channel free code [12, 13], without requiring microarchitectural models. In particular, it captures leakage through caches without requiring an explicit cache model.
We model this adversary in our semantics by annotating transactions with observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ n and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ n, which expose read and write accesses to an address , and observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ n, which expose the value of the program counter. We denote the set of all observations by .
Evaluation relation
We describe the execution of Asm programs using the evaluation relation . Most of the rules defining are fairly standard, which is why Figure 5 presents only a selection. We refer the reader to Appendix A for the remaining rules.
The rules Load and Store describe the behavior of instructions and respectively. The former assigns to the register the memory content at the address to which expression evaluates; the latter stores the content of at that address. Both rules expose the address using observations and increment the program counter.
The rule CondUpdate-Sat describes the behavior of a conditional update whose condition is satisfied. It first checks that the condition evaluates to [math]. It then updates the register assignment by storing in the value of , and by incrementing .
The rule Beqz-Sat describes the effect of the instruction when the branch is taken. Under the condition that evaluates to [math], it sets the program counter to and exposes this change using the observation {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell.
Finally, the rule Jmp executes instructions. The rule stores the value of in the program counter and records this change using the observation {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell.
Runs and traces
The evaluation relation captures individual steps in the execution of a program. Runs capture full executions of the program. We formalize them as triples consisting of an initial configuration , a trace of observations , and a final configuration . Given a program , we denote by the set of all possible runs of the non-speculative semantics, i.e., it contains all triples corresponding to executions . Finally, we denote by the trace such that there is a final configuration for which . In this paper, we only consider terminating programs. Extending the definitions and algorithms to non-terminating programs is future work.
IV Speculative semantics
This section introduces a model of speculation that captures the execution of Asm programs on speculative in-order microarchitectures. We first informally explain this model in Section IV-A before formalizing it in the rest of the section.
IV-A Modeling speculation
Non-branching instructions are executed as in the standard semantics. Upon reaching a branching instruction, the prediction oracle, which is a parameter of our model, is queried to obtain a branch prediction that is used to decide which of the two branches to execute speculatively.
To enable a subsequent rollback in case of a misprediction, a snapshot of the current program configuration is taken, before starting a speculative transaction. In this speculative transaction, the program is executed speculatively along the predicted branch for a bounded number of computation steps. Computing the precise length of a speculative transactions would (among other aspects) require a detailed model of the memory hierarchy. To abstract from this complexity, in our model is also provided by the prediction oracle.
At the end of a speculative transaction, the correctness of the prediction is evaluated:
- •
If the prediction was correct, the transaction is committed and the computation continues using the current configuration.
- •
If the prediction was incorrect, the transaction is aborted, the original configuration is restored, and the computation continues on the correct branch.
In the following we formalize the behavior intuitively described above in the speculative semantics. The main technical challenge lies in catering for nested branches and transactions.
IV-B Prediction oracles
In our model, prediction oracles serve two distinct purposes: (1) predicting branches, and (2) determining the speculative transactions’ lengths. A prediction oracle is a partial function that takes as input a program , a branching history , and a label such that is a branching instruction, and that returns as output a pair , where represents the predicted branch (i.e., where ) and represents the speculative transaction’s length.
Taking into account the branching history enables us to capture history-based branch predictors, a general class of branch predictors that base their decisions on the sequence of branches leading up to a branching instruction. Formally, a branching history is a sequence of triples , where is the label of a branching instruction, is the label of the predicted branch, and is the identifier of the transaction in which the branch is executed.
A prediction oracle has speculative window at most if the length of the transactions generated by its predictions is at most , i.e., for all programs , branching histories , and labels , , for some and with .
Example 2**.**
The “backward taken forward not taken” (BTFNT) branch predictor, implemented in early CPUs [16], predicts the branch as taken if the target instruction address is lower than the program counter. It can be formalized as part of a prediction oracle , for a fixed speculative window , as follows: , where .
Dynamic branch predictors, such as simple 2-bit predictors and more complex correlating or tournament predictors [16], can also be formalized using prediction oracles.
IV-C Speculative transactions
To manage each ongoing speculative transaction333Due to nesting, multiple transactions may be happening simultaneously., the speculative semantics needs to remember a snapshot of the configuration prior to the start of the transaction, the length of the transaction (i.e., the number of instructions left to be executed in this transaction), the branch prediction used at the start of the transaction, and the transaction’s identifier . We call such a 4-tuple , a speculative state, and we denote by the set of all speculative states.
Nested transactions are represented by sequences of speculative states. We use standard notation for sequences: is the set of all finite sequences over the set , is the empty sequence, and is the concatenation of sequences and .
We use the following two helper functions to manipulate sequences of speculative states :
- •
decrements by the length of all transactions in the sequence.
- •
sets to [math] the length of all transactions in the sequence.
- •
The predicate holds if and only if none of the transactions in has remaining length [math].
In addition to branch and jump instructions, speculative transactions can also modify the program counter: rolling back a transaction results in resetting the program counter to the one in the correct branch. To expose such changes to the adversary, we extend the set of observations with elements of the form {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}, and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}, to denote start, commit, and rollback of a speculative transaction . denotes the set of extended observations.
IV-D Evaluation relation
The speculative semantics operates on extended configurations, which are 4-tuples consisting of a global counter for generating transaction identifiers, a configuration , a sequence of speculative states representing the ongoing speculative transactions, and a branching history . Along the lines of the standard semantics, we describe the speculative semantics of Asm programs under a prediction oracle using the relation . The rules are given in Figure 6 and are explained below:
Se-NoBranch captures the behavior of non-branching instructions as long as the length of all speculative states in is greater than [math], that is, as long as holds. In this case, mimics the behavior of the non-speculative semantics . If the instruction is not a speculation barrier, the lengths of all speculative transactions are decremented by 1 using . In contrast, if the instruction is a speculation barrier , the length of all transactions is set to [math] using . In this way, forces the termination (either with a commit or with a rollback) of all ongoing speculative transactions.
Se-Branch models the behavior of branch instructions. The rule
(1) queries the prediction oracle to obtain a prediction consisting of the predicted next instruction address and the length of the transaction ,
(2) sets the program counter to ,
(3) decrements the length of the transactions in ,
(4) increments the transaction counter ,
(5) appends a new speculative state with configuration , identifier , transaction’s length , and predicted instruction address , and
(6) updates the branching history by appending an entry modeling the prediction.
The rule also records the start of the speculative execution and the change of the program counter through observations.
Se-Commit captures a speculative transaction’s commit. It is executed whenever a speculative state’s remaining length reaches [math]. Application of the rule requires that the prediction made for the transaction is correct, which is checked by comparing the predicted address with the one obtained by executing one step of the non-speculative semantics starting from the configuration . The rule records the transaction’s commit through an observation, and it updates the branching history according to the branch decision that has been taken.
Se-Rollback captures a speculative transaction’s rollback. The rule checks that the prediction is incorrect (again by comparing the predicted address with the one obtained from the non-speculative semantics), and it restores the configuration stored in . Rolling back a transaction also terminates the speculative execution of all the nested transactions. This is modeled by dropping the portion of the speculative state associated with the nested transactions. The rule also produces observations recording the transaction’s rollback and the change of the program counter, and it updates the branching history by recording the branch instruction’s correct outcome.
Runs and traces
Runs and traces are defined analogously to the non-speculative case: Given a program and an oracle , we denote by the set of all possible runs of the speculative semantics. By we denote the trace such that there is a final configuration for which .
Example 3**.**
For illustrating the speculative semantics, we execute the program from Ex. 1 with the oracle from Ex. 2 and a configuration where .
First, the rule Se-NoJump is applied to execute the assignment . Then, the branch instruction is reached and so rule Se-Jump applies. This produces the observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ 0, modeling the beginning of a speculative transaction with id 0, and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 2, representing the program counter’s change. Next, rule Se-NoJump applies three times to execute the instructions 2–5, thereby producing the observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ v_{1} and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ v_{2} that record the memory accesses. Finally, rule Se-Rollback applies, which terminates the speculative transaction and rolls back its effects. This rule produces the observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ 0 and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \bot. Thus, executing the program produces the trace:
[TABLE]
where and .
IV-E Speculative and Non-speculative Semantics
We conclude this section by connecting the speculative and non-speculative semantics. For this, we introduce two projections of speculative traces :
- •
the non-speculative projection is the trace obtained by removing from (1) all substrings that correspond to rolled-back transactions, i.e. all substrings {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}\cdot\tau^{\prime}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}, and (2) all extended observations.
- •
the speculative projection is the trace produced by rolled-back transactions, i.e. the complement of .
We lift projections and to sets of runs in the natural way. Then, a program’s non-speculative behavior can be obtained from its speculative behavior by dropping all speculative observations, i.e., by applying to all of its runs :
Proposition 1**.**
Let be a program and be a prediction oracle. Then, .
\IfEqCase
falsefalseThe proof of Proposition 1 is given in \IfEqCasefalsefalseAppendix Ftrue[techReport] .
V Speculative Non-interference
This section introduces speculative non-interference (SNI), a semantic notion of security characterizing those information leaks that are introduced by speculative execution.
V-A Security policies
Speculative non-interference is parametric in a policy that specifies which parts of the configuration are known or controlled by an adversary, i.e., “public” or “low” data.
Formally, a security policy is a finite subset of specifying the low register identifiers and memory addresses. Two configurations are indistinguishable with respect to a policy , written , iff they agree on all registers and memory locations in .
Example 4**.**
A policy for the program from Example 1 may state that the content of the registers , , , and is non-sensitive, i.e., .
Policies need not be manually specified but can in principle be inferred from the context in which a piece of code executes, e.g., whether a variable is reachable from public input or not.
V-B Speculative non-interference
Speculative non-interference requires that executing a program under the speculative semantics does not leak more information than executing the same program under the non-speculative semantics. Formally, whenever two indistinguishable configurations produce the same non-speculative traces, then they must also produce the same speculative traces.
Definition 1**.**
A program satisfies speculative non-interference for a prediction oracle and a security policy iff for all initial configurations , if and , then .
Speculative non-interference is a variant of non-interference. While non-interference compares what is leaked by a program with a policy specifying the allowed leaks, speculative non-interference compares the program leakage under two semantics, the non-speculative and the speculative one. The security policy and the non-speculative semantics, together, specify what the program may leak under the speculative semantics.444Conceptually, the non-speculative semantics can be seen as a declassification assertion for the speculative semantics [17].
Example 5**.**
The program from Example 1 does not satisfy speculative non-interference for the BTFNT oracle from Example 2 and the policy from Example 4. Consider two initial configurations that agree on the values of , , , and but disagree on the value of . Say, for instance, that and . Additionally, assume that .
Executing the program under the non-speculative semantics produces the trace {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \bot when starting from and . Moreover, the two initial configurations are indistinguishable with respect to the policy . However, executing under the speculative semantics produces two distinct traces \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 3\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ v_{1}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ (a^{\prime}(\mathtt{B})+0)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \bot and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 3\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ v_{1}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ (a^{\prime}(\mathtt{B})+1)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \bot, where . Therefore, does not satisfy speculative non-interference.
V-C Always-mispredict speculative semantics
The speculative semantics and SNI are parametric in the prediction oracle . Often, it is desirable obtaining guarantees w.r.t. any prediction oracle, since branch prediction models in modern CPUs are unavailable and as different CPUs employ different predictors. To this end, we introduce a variant of the speculative semantics that facilitates such an analysis.
Intuitively, leakage due to speculative execution is maximized under a branch predictor that mispredicts every branch. This intuition holds true unless speculative transactions are nested, where a correct prediction of a nested branch sometimes yields more leakage than a misprediction.
Example 6**.**
Consider the following variation of the Spectre v1 example [2] from Figure 1, and assume that the function benign() runs for longer than the speculative window and does not leak any information.
1if (y < size)
2 if (y-1 < size)
3 benign();
4 temp &= B[A[y] * 512];
Then, under a branch predictor that mispredicts every branch, the speculative transaction corresponding to the outer branch will be rolled back before reaching line 4. On the other hand, given a correct prediction of the inner branch, line 4 would be reached and a speculative leak would be present.
A simple but inefficient approach to deal with this challenge would be to consider both cases, correct and incorrect prediction, upon every branch. This, however, would result in an exponential explosion of the number of paths to consider.
To avoid this, we introduce the always-mispredict semantics that differs from the speculative semantics in three key ways:
- (1)
It mispredicts every branch, hence its name. In particular, it is not parametric in the prediction oracle. 2. (2)
It initializes the length of every non-nested transaction to , and the length of every nested transaction to the remaining length of its enclosing transaction decremented by . 3. (3)
Upon executing instructions, only the remaining length of the innermost transaction is decremented.
The consequence of these modifications is that nested transactions do not reduce the number of steps that the semantics may explore the correct path for, after the nested transactions have been rolled back. In Example 6, after rolling back the nested speculative transaction, the outer transaction continues as if the nested branch had been correctly predicted in the first place, and thus the speculative leak in line 4 is reached.
Modifications (1)-(3) are formally captured in the three rules Am-NoBranch, Am-Branch, and Am-Rollback given in Appendix C. Similarly to , we denote by the trace of observations obtained by executing the program , starting from initial configuration according to the always-mispredict evaluation relation with speculative window .
Theorem 1 \IfEqCasefalsefalse(proved in Appendix H) states that checking SNI w.r.t. the always- mispredict semantics is sufficient to obtain security guarantees w.r.t. all prediction oracles.
Theorem 1**.**
A program satisfies SNI for a security policy and all prediction oracles with speculative window at most iff for all initial configurations , if and , then .
In our case studies in Sections VIII and IX, we use . This is motivated by typical sizes of the reorder buffer [18], which limits the lengths of speculative transactions in modern microarchitectures.
VI Detecting speculative information flows
We now present Spectector, an approach to detect speculative leaks, or to prove their absence. Spectector symbolically executes the program under analysis to derive a concise representation of ’s behavior as a set of symbolic traces. It analyzes each symbolic trace using an SMT solver to detect possible speculative leaks through memory accesses or control-flow instructions. If neither memory nor control leaks are detected, Spectector reports the program as secure.
VI-A Symbolically executing Asm programs
We symbolically execute programs w.r.t. the always mispredict semantics, which enables us to derive security guarantees that hold for arbitrary prediction oracles, see Theorem 1. Our symbolic execution engine relies on the following components:
- •
A symbolic expression is a concrete value , a symbolic value , an if-then-else expression , or the application of unary or binary operators to symbolic expressions.
- •
A symbolic memory is a term in the standard theory of arrays [19]. A memory update updates the symbolic memory by assigning the symbolic value to the symbolic address . We extend symbolic expressions with memory reads , which retrieve the value of the symbolic address from the symbolic memory .
- •
A symbolic trace is a sequence of symbolic observations of the form {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \mathit{se} or {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \mathit{se}, symbolic branching conditions of the form {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}), and transaction-related observations of the form {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ n and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ n, for natural numbers and symbolic expressions .
- •
The path condition \mathit{pthCnd}(\tau)\!\!=\!\!\bigwedge_{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se})\in\tau}\mathit{se} of trace is the conjunction of all symbolic branching conditions in .
- •
The symbolic execution derives symbolic runs , consisting of symbolic configurations and a symbolic trace . The set of all symbolic runs forms the symbolic semantics, which we denote by . The derivation rules are fairly standard and are given in Appendix D.
- •
The value of an expression depends on a valuation mapping symbolic values to concrete ones. The evaluation of under is standard and formalized in Appendix D.
- •
A symbolic expression is satisfiable, written , if there is a valuation such that . Every valuation that satisfies a symbolic run’s path condition maps the run to a concrete run. We denote by the set of ’s concretizations, and we lift it to . The concretization of the symbolic runs yields the set of all concrete runs:
Proposition 2**.**
Let be a program and be a speculative window. Then, .
The proof of Proposition 2 is given in \IfEqCasefalsefalseAppendix Itrue[techReport] .
Example 7**.**
Executing the program from Example 1 under the symbolic speculative semantics with speculative window yields the following two symbolic traces: \tau_{1}:={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}({\mathtt{y}}<{\mathtt{size}})\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 2\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 10\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 3\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{A}}+{\mathtt{y}}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{B}}+\mathbf{read}(sm\mathchar 44\relax({\mathtt{A}}+{\mathtt{y}}))*512, and \tau_{2}:={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}({\mathtt{y}}\geq{\mathtt{size}})\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 3\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{A}}+{\mathtt{y}}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{B}}+\mathbf{read}(sm\mathchar 44\relax({\mathtt{A}}+{\mathtt{y}}))*512\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 2\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 10.
VI-B Checking speculative non-interference
Spectector is given in Algorithm 1. It relies on two procedures: MemLeak and CtrlLeak, to detect leaks resulting from memory and control-flow instructions, respectively. We start by discussing the Spectector algorithm and next explain the MemLeak and CtrlLeak procedures.
Spectector takes as input a program , a policy specifying the non-sensitive information, and a speculative window . The algorithm iterates over all symbolic runs produced by the symbolic always-mispredict speculative semantics (lines 2-4). For each run , the algorithm checks whether speculatively leaks information through memory accesses or control-flow instructions. If this is the case, then Spectector has found a witness of a speculative leak and it reports as Insecure. If none of the traces contain speculative leaks, the algorithms terminates returning Secure (line 5).
Detecting leaks caused by memory accesses
The procedure MemLeak takes as input a trace and a policy , and it determines whether leaks information through symbolic {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ observations. The check is expressed as a satisfiability check of a constraint . The construction of is inspired by self-composition [20], which reduces reasoning about pairs of program runs to reasoning about single runs by replacing each symbolic variable with two copies and . We lift the subscript notation to symbolic expressions.
The constraint is the conjunction of four formulas:
- •
stands for , which ensures that both runs follow the path associated with .
- •
introduces constraints for each register and for each memory location , which ensure that both runs agree on all non-sensitive inputs.
- •
introduces a constraint for each {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \mathit{se} or {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \mathit{se} in , which ensures that the non-speculative observations associated with memory accesses are the same in both runs.
- •
ensures that speculative observations associated with memory accesses differ among the two runs.
If is satisfiable, there are two -indistinguishable configurations that produce the same non-speculative traces (since is satisfied) and whose speculative traces differ in a memory access observation (since is satisfied), i.e. a violation of SNI.
Detecting leaks caused by control-flow instructions
To detect leaks caused by control-flow instructions, CtrlLeak checks whether there are two traces in ’s concretization that agree on the outcomes of all non-speculative branch and jump instructions, while differing in the outcome of at least one speculatively executed branch or jump instruction.
In addition to , , and , the procedure relies on the function that introduces the constraint ensuring that is satisfied in one concretization iff it is satisfied in the other.
CtrlLeak checks, for each prefix \nu\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}) in ’s speculative projection , the satisfiability of the conjunction of , , , and . Whenever the formula is satisfiable, there are two -indistinguishable configurations that produce the same non-speculative traces, but whose speculative traces differ on program counter observations, i.e. a violation of SNI.
Example 8**.**
Consider the trace \tau_{2}:={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}({\mathtt{y}}\geq{\mathtt{size}})\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 3\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{A}}+{\mathtt{y}}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{B}}+\mathbf{read}(sm\mathchar 44\relax({\mathtt{A}}+{\mathtt{y}}))*512\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ 0\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 2\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ 10 from Example 7. MemLeak detects a leak caused by the observation {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{B}}+\mathbf{read}(sm\mathchar 44\relax({\mathtt{A}}+{\mathtt{y}}))*512. Specifically, it detects that there are distinct symbolic valuations that agree on the non-speculative observations but disagree on the value of {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ {\mathtt{B}}+\mathbf{read}(sm\mathchar 44\relax({\mathtt{A}}+{\mathtt{y}}))*512. That is, the observation depends on sensitive information that is not disclosed by ’s non-speculative projection.
Soundness and completeness
Theorem 2 states that Spectector deems secure only speculatively non-interferent programs, and all detected leaks are actual violations of SNI.
Theorem 2**.**
If terminates, then iff the program satisfies speculative non-interference w.r.t. the policy and all prediction oracles with speculative window at most .
The theorem follows from the soundness and completeness of the always-mispredict semantics w.r.t. prediction oracles (Theorem 1) and of the symbolic semantics w.r.t. to the always-mispredict semantics (Proposition 2). \IfEqCasefalsefalseThe proof of Theorem 2 is given in Appendix J.
VII Tool Implementation
We implement our approach in our tool Spectector, which is available at https://spectector.github.io. The tool, which is implemented on top of the Ciao logic programming system [21], consists of three components: a front end that translates x86 assembly programs into Asm, a core engine implementing Algorithm 1, and a back end handling SMT queries.
x86 front end
The front end translates AT&T/GAS and Intel-style assembly files into Asm. It currently supports over 120 instructions: data movement instructions (, etc.), logical, arithmetic, and comparison instructions (, , , etc.), branching and jumping instructions (, , etc.), conditional moves (, etc.), stack manipulation (, , etc.), and function calls555We model the so-called “near calls”, where the callee is in the same code segment as the caller. (, ).
It currently does not support privileged x86 instructions, e.g., for handling model specific registers and virtual memory. Further it does not support sub-registers (like , , and ) and unaligned memory accesses, i.e., we assume that only 64-bit words are read/written at each address without overlaps. Finally, the translation currently maps symbolic address names to Asm instruction addresses, limiting arithmetic on code addresses.
Core engine
The core engine implements Algorithm 1. It relies on a concolic approach to implement symbolic execution that performs a depth-first exploration of the symbolic runs. Starting from a concrete initial configuration, the engine executes the program under the always-mispredict speculative semantics while keeping track of the symbolic configuration and path condition. It discovers new runs by iteratively negating the last (not previously negated) conjunct in the path condition until it finds a new initial configuration, which is then used to re-execute the program concolically. In our current implementation, indirect jumps are not included in the path conditions, and thus new symbolic runs and corresponding inputs are only discovered based on negated branch conditions.666We plan to remove this limitation in a future release of our tool. This process is interleaved with the MemLeak and CtrlLeak checks and iterates until a leak is found or all paths have been explored.
SMT back end
The Z3 SMT solver [15] acts as a back end for checking satisfiability and finding models of symbolic expressions using the Bitvector and Array theories, which are used to model registers and memory. The implementation currently does not rely on incremental solving, since it was less efficient than one-shot solving for the selected theories.
VIII Case study: Compiler countermeasures
This section reports on a case study in which we apply Spectector to analyze the security of compiler-level countermeasures against Spectre. We analyze a corpus of 240 assembly programs derived from the variants of the Spectre v1 vulnerability by Kocher [14] using different compilers and compiler options. This case study’s goals are: (1) to determine whether speculative non-interference realistically captures speculative leaks, and (2) to assess Spectector’s precision.
VIII-A Experimental Setup
For our analysis, we rely on three state-of-the-art compilers: Microsoft Visual C++ versions v19.15.26732.1 and v19.20.27317.96, Intel Icc v19.0.0.117, and Clang v7.0.0.
We compile the programs using two different optimization levels (-O0 and -O2) and three mitigation levels:
(a) Unp: we compile without any Spectre mitigations.
(b) Fen: we compile with automated injection of speculation barriers.777Fences are supported by Clang with the flag -x86-speculativeload-hardening-lfence, by Icc with -mconditionalbranch=all-fix, and by Visual C++ with /Qspectre.
(c) Slh: we compile using speculative load hardening.888Speculative load hardening is supported by Clang with the flag -x86-speculative-load-hardening.
Compiling each of the 15 examples from [14] with each of the 3 compilers, each of the 2 optimization levels, and each of the 2-3 mitigation levels, yields a corpus of 240 x64 assembly programs.999The resulting assembly files are available at https://spectector.github.io. For each program, we specify a security policy that flags as “low” all registers and memory locations that can either be controlled by the adversary or can be assumed to be public. This includes variables y and size, and the base addresses of the arrays A and B as well as the stack pointer.
VIII-B Experimental Results
Figure 7 depicts the results of applying Spectector to the 240 examples. We highlight the following findings:
- •
Spectector detects the speculative leaks in almost all unprotected programs, for all compilers (see the Unp columns). The exception is Example #8, which uses a conditional expression instead of the if statement of Figure 1:
1temp &= B[A[y<size?(y+1):0]*512];
At optimization level -O0, this is translated to a (vulnerable) branch instruction by all compilers, and at level -O2 to a (safe) conditional move, thus closing the leak. See Appendix E-A for the corresponding Clang assembly.
- •
The Clang and Intel Icc compilers defensively insert fences after each branch instruction, and Spectector can prove security for all cases (see the Fen columns for Clang and Icc). In Example #8 with options -O2 and Fen, Icc inserts an lfence instruction, even though the baseline relies on a conditional move, see line 10 below. This lfence is unnecessary according to our semantics, but may close leaks on processors that speculate over conditional moves.
1 mov y, %rdi
2 lea 1(%rdi), %rdx
3 mov size, %rax
4 xor %rcx, %rcx
5 cmp %rax, %rdi
6 cmovb %rdx, %rcx
7 mov temp, %r8b
8 mov A(%rcx), %rsi
9 shl $9, %rsi
10 lfence
11 and B(%rsi), %r8b
12 mov %r8b, temp
- •
For the Visual C++ compiler, Spectector automatically detects all leaks pointed out in [14] (see the Fen 19.15 -O2 column for Vcc). Our analysis differs from Kocher’s only on Example #8, where the compiler v19.15.26732.1 introduces a safe conditional move, as explained above. Moreover, without compiler optimizations (which is not considered in [14]), Spectector establishes the security of Examples #3 and #5 (see the Fen 19.15 -O0 column). The latest Vcc compiler additionally mitigates the leaks in Examples #4, #12, and #14 (see the Fen 19.20 column).
- •
Spectector can prove the security of speculative load hardening in Clang (see the Slh column for Clang), except for Example #10 with -O2 and Example #15 with -O0.
Example 10 with Speculative Load Hardening
Example #10 differs from Figure 1 in that it leaks sensitive information into the microarchitectural state by conditionally reading the content of B[0], depending on the value of A[y].
1 if (y < size)
2 if (A[y] == k)
3 temp &= B[0];
Spectector proves the security of the program produced with Clang -O0, and speculative load hardening.
However, at optimization level -O2, Clang outputs the following code that Spectector reports as insecure.
1 mov size, %rdx
2 mov y, %rbx
3 mov $0, %rax
4 cmp %rbx, %rdx
5 jbe END
6 cmovbe $-1, %rax
7 or %rax, %rbx
8 mov k, %rcx
9 cmp %rcx, A(%rbx)
10 jne END
11 cmovne $-1, %rax
12 mov B, %rcx
13 and %rcx, temp
14 jmp END
The reason for this is that Clang masks only the register %rbx that contains the index of the memory access A[y], cf. lines 6–7. However, it does not mask the value that is read from A[y]. As a result, the comparison at line 9 speculatively leaks (via the jump target) whether the content of A[0xFF...FF] is k. Spectector detects this subtle leak and flags a violation of speculative non-interference.
While this example nicely illustrates the scope of Spectector, it is likely not a problem in practice: First, the leak may be mitigated by how data dependencies are handled in modern out-of-order CPUs. Specifically, the conditional move in line 6 relies on the comparison in Line 4. If executing the conditional leak effectively terminates speculation, the reported leak is spurious. Second, the leak can be mitigated at the OS-level by ensuring that 0xFF...FF is not mapped in the page tables, or that the value of A[0xFF...FF] does not contain any secret [22]. Such contextual information can be expressed with policies (see V-A) to improve the precision of the analysis.
VIII-C Performance
We run all experiments on a Linux machine (kernel 4.9.0-8-amd64) with Debian 9.0, a Xeon Gold 6154 CPU, and 64 GB of RAM. We use Ciao version 1.18 and the Z3 version 4.8.4.
Spectector terminates within less than 30 seconds on all examples, with several examples being analyzed in about 0.1 seconds, except for Example #5 in mode Slh -O2. In this exceptional case, Spectector needs 2 minutes for proving security. This is due to Example #5’s complex control-flow, which leads to loops involving several branch instructions.
IX Case study: Xen Project Hypervisor
This section reports on a case study in which we apply Spectector on the Xen Project hypervisor [23]. This case study’s goal is to understand the challenges in scaling the tool to a significant real-world code base. It forms a snapshot of our ongoing effort towards the comprehensive side-channel analysis of the Xen hypervisor.
IX-A Challenges for scaling-up
There are three main challenges for scaling Spectector to a large code base such as the Xen hypervisor:
ISA support
Our front end currently supports only a fraction of the x64 ISA (cf. Section VII). Supporting the full x64 ISA is conceptually straightforward but out of the scope of this paper. For this case study, we treat unsupported instructions as , sacrificing the analysis’s correctness.
Policies
Spectector uses policies specifying the public and secret parts of configurations. The manual specification of precise policies (as in Section VIII) is infeasible for large code bases, and their automatic inference from the calling context is not yet supported by Spectector. For this case study, we use a policy that treats registers as “low” and memory locations as “high”, which may introduce false alarms. For instance, the policy treats as “high” all function parameters that are retrieved from memory (e.g., popped from the stack), which is why Spectector flags their speculative uses in memory or branching instructions as leaks.
Path explosion and nontermination
Spectector is based on symbolic execution, which suffers from path explosion and nontermination when run on programs with loops and indirect jumps. In the future, we plan to address this challenge by employing approximate but sound static analysis techniques, such as abstract interpretation. Such techniques can be employed both to efficiently infer loop invariants, and jump targets, but also to directly address the question whether a given program satisfies SNI or not. A systematic study of techniques to soundly approximate SNI is out of scope of this paper. For this case study, as discussed in the following section, we bound the number and the lengths of symbolic paths that are explored, thereby sacrificing the soundness of our analysis.
IX-B Evaluating scalability
Approach
To perform a meaningful evaluation of Spectector’s scalability despite the incomplete path coverage, we compare the time spent on discovering new symbolic paths with the time spent on checking SNI. Analyzing paths of different lengths enables us to evaluate the scalability of checking SNI relative to that of symbolic execution, which factors out the path explosion problem from the analysis.
We stress that we sacrifice soundness and completeness of the analysis for running Spectector on the full Xen codebase (see Section IX-A). This is why in this section we do not attempt to make statements about the security of the hypervisor.
Setup
We analyze the Xen Project hypervisor version 4.10, which we compile using Clang v7.0.0. We identify 3 959 functions in the generated assembly. For each function, we explore at most 25 symbolic paths of at most 10 000 instructions each, with a global timeout of 10 minutes.101010The sources and scripts needed for reproducing our results are available at https://spectector.github.io.
We record execution times as a function of the trace length, i.e., the number of {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ se, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ se, and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se) observations, rather than path length, since the former is more relevant for the size of the resulting SMT formulas. We execute our experiments on the machine described in Section VIII-C.
IX-C Experimental results
Cost of symbolic execution
We measure the time taken for discovering symbolic paths (cf. Section VII). In total, Spectector discovers 24 701 symbolic paths. Figure 8(c) depicts the time for discovering paths. We highlight the following findings:
- •
As we apply concolic execution, discovering the first symbolic path does not require any SMT queries and is hence cheap. These cases are depicted by yellow dots in Fig. 8(c).
- •
Discovering further paths requires SMT queries. This increases execution time by approximately two orders of magnitude. These cases correspond to the blue dots in Fig. 8(c).
- •
For 48.3% of the functions we do not reach the limit of 25 paths, for 35.4% we do not reach the limit of 10 000 instructions per path, and for 18.7% we do not encounter unsupported instructions. 13 functions satisfy all three conditions.
Cost of checking SNI
We apply MemLeak and CtrlLeak to the 24 701 traces (derived from the discovered paths), with a timeout of 1 minute each. Figure 8(a) and 8(b) depict the respective analysis runtimes; Figure 8(d) relates the time required for discovering a new trace with the time for checking SNI, i.e., for executing lines 3–4 in Algorithm 1.
We highlight the following findings:
- •
MemLeak and CtrlLeak can analyze 93.8% and 94.7%, respectively, of the 24 701 traces in less than 1 minute. The remaining traces result in timeouts.
- •
For 41.9% of the traces, checking SNI is at most 10x faster than discovering the trace, and for 20.2% of the traces it is between 10x and 100x faster. On the other hand, for 26.9% of the traces, discovering the trace is at most 10x faster than checking SNI, and for 7.9% of the traces, discovering the trace is between 10x and 100x faster than checking SNI.
Summary
Overall, our data indicates that the cost of checking SNI is comparable to that of discovering symbolic paths. This may be surprising since SNI is a relational property, which requires comparing executions and is know to scale poorly. However, note that Spectector only compares executions that follow the same symbolic path. This is sufficient because the program counter is observable, i.e., speculative non-interference never requires to consider two executions that disagree on path conditions. We hence conclude that our approach does not exhibit fundamental bottlenecks beyond those it inherits from symbolic execution.
X Discussion
X-A Exploitability
Exploiting speculative execution attacks requires an adversary to (1) prepare the microarchitectural state, (2) run victim code—partially speculatively—to encode information into the microarchitectural state, and (3) extract the leaked information from the microarchitectural state. Spectector analyzes the victim code to determine whether it may speculatively leak information into the microarchitectural state in any possible attack context. Following the terminology of [24, 25], speculative non-interference is a semantic characterization of disclosure gadgets enabled by speculative execution.
X-B Scope of the model
The results obtained by Spectector are only valid to the extent that the speculative semantics and the observer model accurately capture the target system.
In particular, Spectector may incorrectly classify a program as secure if the speculative semantics does not implicitly111111Implicitly, because we take the memory accesses performed by the program and the flow of control as a proxy for the observations an adversary might make, e.g., through the cache. capture all additional observations an adversary may make due to speculative execution on an actual microarchitecture. For example, microarchitectures could potentially speculate on the condition of a conditional update, which our speculative semantics currently does not permit.
Similarly, Spectector may incorrectly classify a program as insecure if the speculative semantics admits speculative executions that are not actually possible on an actual microarchitecture. This might be the case for speculative load hardening on Kocher’s Example #10, as discussed in Section VIII.
The speculative semantics, however, can always be adapted to more accurately reflect reality, once better documentation of processor behavior becomes available. In particular, it would be relatively straightforward to extend the speculative semantics with models of indirect jump predictors [2], return stack buffers [1], and memory disambiguation predictors [26]. The notion of SNI itself is robust to such changes, as it is defined relative to the speculative semantics.
We capture “leakage into the microarchitectural state” using the relatively powerful observer of the program execution that sees the location of memory accesses and the jump targets. This observer could be replaced by a weaker one, which accounts for more detailed models of a CPU’s memory hierarchy, and Spectector could be adapted accordingly, e.g. by adopting the cache models from CacheAudit [27]. We believe, however, that highly detailed models are not actually desirable for several reasons:
(a) they encourage brittle designs that break under small changes to the model,
(b) they have to be adapted frequently, and
(c) they are hard to understand and reason about for compiler developers and hardware engineers.
The “constant-time” observer model adopted in this paper has proven to offer a good tradeoff between precision and robustness [12, 13].
XI Related work
Speculative execution attacks
These attacks exploit speculatively executed instructions to leak information. After Spectre [2, 5], many speculative execution attacks have been discovered that differ in the exploited speculation sources [1, 4, 26], the covert channels [28, 3, 29] used, or the target platforms [30]. We refer the reader to [25] for a survey of speculative execution attacks and their countermeasures.
Here, we overview only Spectre v1 software-level countermeasures. AMD and Intel suggest inserting lfence instructions after branches [6, 31]. These instructions effectively act as speculation barriers, and prevent speculative leaks. The Intel C++ compiler [9], the Microsoft Visual C++ compiler [10], and the Clang [8] compiler can automatically inject this countermeasure at compile time. Taram et al. [32] propose context-sensitive fencing, a defense mechanism that dynamically injects fences at the microoperation level where necessary, as determined by a dynamic information-flow tracker. An alternative technique to injecting fences is to introduce artificial data dependencies [33, 8]. Speculative Load Hardening (SLH) [8], implemented in the Clang compiler, employs carefully injected data dependencies and masking operations to prevent the leak of sensitive information into the microarchitectural state. A third software-level countermeasure consists in replacing branching instructions by other computations, like bit masking, that do not trigger speculative execution [7].
Detecting speculative leaks
oo7 [11] is a binary analysis tool for detecting speculative leaks. The tool looks for specific syntactic code patterns and it can analyze large code bases. However, it misses some speculative leaks, like Example #4 from Section VIII. oo7 would also incorrectly classify all the programs patched by SLH in our case studies as insecure, since they still match oo7’s vulnerable patterns. In contrast, Spectector builds on a semantic notion of security and is thus not limited to particular syntactic code patterns.
Disselkoen et al. [34] and Mcilroy et al. [35] develop models for capturing speculative execution, which they use to illustrate several known Spectre variants. Neither approach provides a security notion or a detection technique. Compared with our speculative semantics, the model of [35] more closely resembles microarchitectural implementations by explicitly modeling the reorder buffer, caches, and branch predictors, which we intentionally abstract away.
In work concurrent to ours, Cheang et al. [36] introduce the notion of trace property-dependent observational determinism (TPOD), which they instantiate to formally capture the new leaks introduced by the interaction of microarchitectural side channels with speculative execution. As TPOD is a 4-safety property it can be checked using 4-way self composition. In contrast, SNI can be checked by 2-way self composition (cf. Proposition 1), which is likely to be more efficient.
Formal architecture models
Armstrong et al. [37] present formal models for the ARMv8-A, RISC-V, MIPS, and CHERI-MIPS instruction-set architectures. Degenbaev [38] and Goel et al. [39] develop formal models for parts of the x86 architecture. Such models enable, for instance, the formal verification of compilers, operating systems, and hypervisors. However, ISA models naturally abstract from microarchitectural aspects such as speculative execution or caches, which are required to reason about side-channel vulnerabilities.
Zhang et al. [40] present Coppelia, a tool to automatically generate software exploits for hardware designs. However, the processor designs they consider, OR1200, PULPino, and Mor1kx, do not feature speculative execution.
Static detection of side-channel vulnerabilities
Several approaches have been proposed for statically detecting side-channel vulnerabilities in programs [27, 41, 42, 13]. These differ from our work in that (1) they do not consider speculative execution, and (2) we exclusively target speculation leaks, i.e., we ignore leaks from the standard semantics. However, we note that our tool could easily be adapted to also detect leaks from the standard semantics.
XII Conclusions
We introduce speculative non-interference, the first semantic notion of security against speculative execution attacks. Based on this notion we develop Spectector, a tool for automatically detecting speculative leaks or proving their absence, and we show how it can be used to detect subtle leaks—and optimization opportunities—in the way state-of-the-art compilers apply Spectre mitigations.
Acknowledgments
We thank Roberto Giacobazzi, Catalin Marinas, Matt Miller, Matthew Parkinson, Niki Vazou, and the anonymous reviewers for helpful discussions and comments. This work was supported by a grant from Intel Corporation, Ramón y Cajal grant RYC-2014-16766, Atracción de Talento Investigador grant 2018-T2/TIC-11732A, Spanish projects TIN2015-70713-R DEDETIS, TIN2015-67522-C3-1-R TRACES, and RTI2018-102043-B-I00 SCUM, and Madrid regional projects S2013/ICE-2731 N-GREENS and S2018/TCS-4339 BLOQUES.
Appendix A Non-speculative semantics
Given a program , we formalize its non-speculative semantics using the relation in Figure 9.
Appendix B Trace projections
Here, we formalize the speculative projection and the non-speculative projection .
Non-speculative projection
Given a trace , its non-speculative projection contains only the observations that are produced by committed transactions; in other words, rolled-back transactions are removed in the projection. Formally, is defined as follows: , if is {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \mathit{se}, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \mathit{se}, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ n, or {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}), ({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ i\cdot\tau)\mathord{\upharpoonright_{nse}}=\tau\mathord{\upharpoonright_{nse}} if {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ i is not in , ({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ i\cdot\tau)\mathord{\upharpoonright_{nse}}=\tau\mathord{\upharpoonright_{nse}}, ({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ i\cdot\tau\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ i\cdot\tau^{\prime})\mathord{\upharpoonright_{nse}}=\tau^{\prime}\mathord{\upharpoonright_{nse}}, and otherwise.
Speculative projection
Given a speculative trace , its speculative projection contains only the observations produced by rolled-back transactions. Formally, is defined as: , if is {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \mathit{se}, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \mathit{se}, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ n, or {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}), ({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ i\cdot\tau)\mathord{\upharpoonright_{se}}=\tau\mathord{\upharpoonright_{se}} if {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ i is not in , ({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ i\cdot\tau)\mathord{\upharpoonright_{se}}=\tau\mathord{\upharpoonright_{se}}, ({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ i\cdot\tau\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ i\cdot\tau^{\prime})\mathord{\upharpoonright_{se}}=\mathit{filter}(\tau)\cdot\tau^{\prime}\mathord{\upharpoonright_{nse}}, and otherwise, where denotes the trace obtained by dropping all extended observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}, {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}, and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id} from .
Appendix C Always-mispredict semantics
We describe the execution of Asm programs under the always-mispredict oracle with speculative window as a ternary evaluation relation mapping a configuration to a configuration while producing the observations . Differently from the speculative semantics, the always-mispredict semantics does not require a branching history , since its prediction only depends on the branch outcome. The rules formalizing the always-mispredict semantics are given in Figure 10.
Am-NoBranch captures the behavior of non-branching instructions. Similar to its counterpart Se-NoBranch, the rule acts as a wrapper for the standard semantics. The difference lies in the the auxiliary predicate and the auxiliary functions , and , which apply their non-primed counterpart only to the last transaction in the speculative state. E.g., . This ensures that upon rolling back a nested transaction, its enclosing transaction can explore the other alternative branch to the full depth of the speculative window (corresponding to the case of a correct prediction).
Am-Branch models the behavior of branching instructions . The rule mispredicts the outcome of the branch instruction by setting the program counter to only when the condition is not satisfied. The length of the new transaction is set to the minimum of the oracle’s speculative window and , where is the remaining length of the last speculative transaction in . This ensures that nested transactions are not explored for longer than permitted by their enclosing transactions, whose remaining lengths are not decremented during the execution of the nested transaction.
Am-Rollback models the rollback of speculative transactions. Different from SE-Rollback, and by design of Am-NoBranch, the rule applies only to the last transaction in . Since the semantics always-mispredicts the outcome of branch instructions, SE-Rollback is always applied, i.e there is no need for a rule that handles committed transactions.
Similarly to Proposition 1, a program’s non-speculative behavior can be recovered from the always-mispredict semantics.
Proposition 3**.**
Let be a program and be a speculative window. Then, .
\IfEqCase
falsefalseThe proof of Proposition 3 is given in Appendix G.
Proposition 4 states that the always-mispredict semantics yields the worst-case leakage.
Proposition 4**.**
Let be a program, be a speculative window, and be initial configurations. iff for all prediction oracles with speculative window at most .
\IfEqCase
falsefalseThe proof of Proposition 4 is given in Appendix H.
Appendix D Symbolic semantics
Here, we formalize the symbolic semantics.
Symbolic expressions
Symbolic expressions represent computations over symbolic values. A symbolic expression is a concrete value , a symbolic value , an if-then-else expression , or the application of a unary or a binary operator .
[TABLE]
Symbolic memories
We model symbolic memories as symbolic arrays using the standard theory of arrays [19]. That is, we model memory updates as triples of the form , which updates the symbolic memory by assigning the symbolic value to the symbolic location , and memory reads as , which denote retrieving the value assigned to the symbolic expression .
A symbolic memory is either a function mapping memory addresses to symbolic values or a term , where is a symbolic memory and are symbolic expressions. To account for symbolic memories, we extend symbolic expressions with terms of the form , where is a symbolic memory and is a symbolic expression, representing memory reads.
[TABLE]
Evaluating symbolic expressions
The value of a symbolic expression depends on a valuation mapping symbolic values to concrete ones:
[TABLE]
An expression is satisfiable if there is a valuation satisfying it, i.e., .
Symbolic assignments
A symbolic assignment is a function mapping registers to symbolic expressions . Given a symbolic assignment and a valuation , denotes the assignment . We assume the program counter to always be concrete, i.e., .
Symbolic configurations
A symbolic configuration is a pair consisting of a symbolic memory and a symbolic assignment . We lift speculative states to symbolic configurations. A symbolic extended configuration is a triple where is a counter, is a symbolic configuration, and is a symbolic speculative state.
Symbolic observations
When symbolically executing a program, we may produce observations whose value is symbolic. To account for this, we introduce symbolic observations of the form {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \mathit{se} and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \mathit{se}, which are produced when symbolically executing and commands, and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}), produced when symbolically evaluating branching instructions, where is a symbolic expression. In our symbolic semantics, we use the observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}) to represent the symbolic path condition indicating when a path is feasible. Given a sequence of symbolic observations and a valuation , denotes the trace obtained by (1) dropping all observations {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}), and (2) evaluating all symbolic observations different from {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}) under .
Symbolic semantics
The non-speculative semantics is captured by the relation in Fig. 11, while the speculative semantics is captured by the relation in Fig. 12.
Computing symbolic runs and traces
We now fix the symbolic values. The set consists of a symbolic value for each register identifier and of a symbolic value for each memory address . We also fix the initial symbolic memory and the symbolic assignment such that and .
The set contains all runs that can be derived using the symbolic semantics (with speculative window ) starting from the initial configuration . That is, contains all triples , where is a symbolic trace and is a final symbolic configuration, corresponding to symbolic computations where the path condition \bigwedge_{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se})\in\tau}\mathit{se} is satisfiable.
We compute in the standard way. We keep track of a path constraint and we update it whenever the semantics produces an observation {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}). We start the computation from and . When executing branch and jump instructions, we explore all branches consistent with the current , and, for each of them, we update .
Appendix E Code from Case Studies
E-A Example #8
In Example #8, the bounds check of Figure 1 is implemented using a conditional operator:
1temp &= B[A[y<size?(y+1):0]*512];
When compiling the example without countermeasures or optimizations, the conditional operator is translated to a branch instruction (cf. line 4), which is a source of speculation. Hence, the resulting program contains a speculative leak, which Spectector correctly detects.
1 mov size, %rcx
2 mov y, %rax
3 cmp %rcx, %rax
4 jae .L1
5 add $1, %rax
6 jmp .L2
7.L1:
8 xor %rax, %rax
9 jmp .L2
10.L2:
11 mov A(%rax), %rax
12 shl $9, %rax
13 mov B(%rax), %rax
14 mov temp, %rcx
15 and %rax, %rcx
16 mov %rcx, temp
In the Unp -O2 mode, the conditional operator is translated as a conditional move (cf. line 6), for which Spectector can prove security.
1 mov size, %rax
2 mov y, %rdx
3 xor %rcx, %rcx
4 cmp %rdx, %rax
5 lea 1(%rdx), %rax
6 cmova %rax, %rcx
7 mov A(%rcx), %rax
8 shl $9, %rax
9 mov B(%rax), %rax
10 and %rax, temp
E-B Example #15 in Slh mode
Here, the adversary provides the input via the pointer *y:
1 if (*y < size)
2 temp &= B[A[*y] * 512];
In the -O0 Slh mode, Clang hardens the address used for performing the memory access A[*y] in lines 8–12, but not the resulting value, which is stored in the register %cx. However, the value stored in %cx is used to perform a second memory access at line 14. An adversary can exploit the second memory access to speculatively leak the content of A[0xFF...FF]. In our experiments, Spectector correctly detected such leak.
1 mov $0, %rax
2 mov y, %rdx
3 mov (%rdx), %rsi
4 mov size, %rdx
5 cmp %rdx, %rsi
6 jae END
7 cmovae $-1, %rax
8 mov y, %rcx
9 mov (%rcx), %rcx
10 mov %rax, %rdx
11 or %rcx, %rdx
12 mov A(%rdx), %rcx
13 shl $9, %rcx
14 mov B(%rcx), %rcx
15 mov temp, %rdx
16 and %rcx, %rdx
17 mov %rdx, temp
In contrast, when Example #15 is compiled with the -O2 flag, Clang correctly hardens A[*y]’s result (cf. line 10). This prevents information from flowing into the microarchitectural state during speculative execution. Indeed, Spectector proves that the program satisfies speculative non-interference.
1 mov $0, %rax
2 mov y, %rdx
3 mov (%rdx), %rdx
4 mov size, %rsi
5 cmp %rsi, %rdx
6 jae END
7 cmovae $-1, %rax
8 mov A(%rdx), %rcx
9 shl $9, %rcx
10 or %rax, %rcx
11 mov B(%rcx), %rcx
12 or %rax, %rcx
13 and %rcx, temp
Appendix F Relating the speculative and non-speculative semantics (Proposition 1)
We start by spelling out the definition of . Given a program and a prediction oracle , we denote by the set of all triples corresponding to executions \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax h\rangle.
We are now ready to prove Proposition 1, which we restate here for simplicity:
See 1
Proof.
We prove the two directions separately.
Assume that . From Proposition 5 (proved in Section F-A), it follows that .
Assume that . From Proposition 6 (proved in Section F-B), it follows that there exists a trace such that and . ∎
In the following, we rely on the concept of rolled-back transactions to denote portions of program executions associated with rolled-back speculative transactions. Concretely, an execution \langle\mathit{ctr}_{0}\mathchar 44\relax\sigma_{0}\mathchar 44\relax s_{0}\mathchar 44\relax h_{0}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{0}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{1}\mathchar 44\relax\sigma_{1}\mathchar 44\relax s_{1}\mathchar 44\relax h_{1}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\ldots\mathrel{\leavevmode\hbox to13.38pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 6.6916pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-4.39717pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n-1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.09161pt}{-12.74582pt}\pgfsys@lineto{2.99161pt}{-12.74582pt}\pgfsys@lineto{2.13803pt}{-13.44582pt}\pgfsys@lineto{0.43086pt}{-12.04582pt}\pgfsys@lineto{-1.2763pt}{-13.44582pt}\pgfsys@lineto{-2.98347pt}{-12.04582pt}\pgfsys@lineto{-4.69064pt}{-13.44582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.29161pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n}\mathchar 44\relax\sigma_{n}\mathchar 44\relax s_{n}\mathchar 44\relax h_{n}\rangle\mathrel{\leavevmode\hbox to10.05pt{\vbox to27.46pt{\pgfpicture\makeatletter\hbox{\hskip 5.02493pt\lower-15.13191pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.7305pt}{-10.4375pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.42494pt}{-12.53194pt}\pgfsys@lineto{1.32494pt}{-12.53194pt}\pgfsys@lineto{0.47136pt}{-13.23193pt}\pgfsys@lineto{-1.23581pt}{-11.83194pt}\pgfsys@lineto{-2.94298pt}{-13.23193pt}\pgfsys@lineto{-4.82494pt}{-12.53194pt}\pgfsys@lineto{-4.82494pt}{-12.53194pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.62494pt}{-12.53194pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n+1}\mathchar 44\relax\sigma_{n+1}\mathchar 44\relax s_{n+1}\mathchar 44\relax h_{n+1}\rangle is a rolled back speculative transaction iff there is an identifier and two labels such that \tau_{0}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ i\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell and \tau_{n}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ i\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}.
F-A Soundness of the speculative semantics
Proposition 5 states that the speculative semantics does not introduce spurious non-speculative behaviors.
Proposition 5**.**
Let be a program and be a prediction oracle. Whenever \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax h\rangle, , and , then .
Proof.
Let be a program and be a prediction oracle. Furthermore, let be an execution \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax h\rangle such that and . We denote by the set of rolled back transactions and by the set containing all identifiers of transactions committed in , i.e., R=\{\mathit{id}\in\mathbb{N}\mid\exists i\in\mathbb{N}.\ \tau|_{i}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\} and C=\{\mathit{id}\in\mathbb{N}\mid\exists i\in\mathbb{N}.\ \tau|_{i}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}\}. We can incrementally construct the execution by applying Lemmas 1–4. In particular, for instructions that are not inside a speculative transaction we apply Lemma 1. For branch instructions, there are two cases. If the associated speculative transaction is eventually rolled back (i.e., its identifier is in ), then we apply Lemma 4 to the whole rolled back transaction to generate the corresponding step in the non-speculative semantics. In contrast, if the speculative transaction is eventually committed (i.e., its identifier is in ), then we can apply Lemma 2 (in conjunction with Lemmas 5) to generate the corresponding step in the non-speculative semantics as well as Lemma 1 for the other instructions in the transaction. Finally, we can simply ignore the steps associated with the Se-Commit rule (see Lemma 3). Observe that the resulting traces can be combined to obtain since \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax h\rangle is a terminated execution. ∎
The above proof relies on the auxiliary lemmas below to handle non-branch instructions (Lemma 1), committed transactions (Lemmas 2, 3, and 5), and rolled back transactions (Lemma 4).
Lemma 1**.**
Let be a program and be a prediction oracle. Whenever \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, , and , then .
Proof.
Let be a program and be a prediction oracle. Assume that \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, , and . From this and the Se-NoBranch rule, it follows . ∎
Lemma 2**.**
Let be a program and be a prediction oracle. Whenever \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, , , , \sigma\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}\sigma^{\prime\prime}, then .
Proof.
Let be a program and be a prediction oracle. Assume that \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, , , , \sigma\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}\sigma^{\prime\prime}. From this, the run was produced by applying the Se-Branch rule. Hence, and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}. From this, \sigma\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}\sigma^{\prime\prime}, \tau\mathord{\upharpoonright_{nse}}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}, and , it follows that \tau\mathord{\upharpoonright_{nse}}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime} and . Hence, . ∎
Lemma 3**.**
Let be a program and be a prediction oracle. Whenever \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to36.87pt{\vbox to28.45pt{\pgfpicture\makeatletter\hbox{\hskip 18.43333pt\lower-15.62495pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-16.1389pt}{-10.93054pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{17.83334pt}{-13.02498pt}\pgfsys@lineto{14.73334pt}{-13.02498pt}\pgfsys@lineto{13.87976pt}{-13.72498pt}\pgfsys@lineto{12.17259pt}{-12.32498pt}\pgfsys@lineto{10.46542pt}{-13.72498pt}\pgfsys@lineto{8.75826pt}{-12.32498pt}\pgfsys@lineto{7.05109pt}{-13.72498pt}\pgfsys@lineto{5.34392pt}{-12.32498pt}\pgfsys@lineto{3.63675pt}{-13.72498pt}\pgfsys@lineto{1.92958pt}{-12.32498pt}\pgfsys@lineto{0.22241pt}{-13.72498pt}\pgfsys@lineto{-1.48476pt}{-12.32498pt}\pgfsys@lineto{-3.19193pt}{-13.72498pt}\pgfsys@lineto{-4.8991pt}{-12.32498pt}\pgfsys@lineto{-6.60626pt}{-13.72498pt}\pgfsys@lineto{-8.31343pt}{-12.32498pt}\pgfsys@lineto{-10.0206pt}{-13.72498pt}\pgfsys@lineto{-11.72777pt}{-12.32498pt}\pgfsys@lineto{-13.43494pt}{-13.72498pt}\pgfsys@lineto{-15.1421pt}{-12.32498pt}\pgfsys@lineto{-16.84927pt}{-13.72498pt}\pgfsys@lineto{-18.23334pt}{-13.02498pt}\pgfsys@lineto{-18.23334pt}{-13.02498pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{18.03334pt}{-13.02498pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, then .
Proof.
Let be a program and be a prediction oracle. Assume that \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to36.87pt{\vbox to28.45pt{\pgfpicture\makeatletter\hbox{\hskip 18.43333pt\lower-15.62495pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-16.1389pt}{-10.93054pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{17.83334pt}{-13.02498pt}\pgfsys@lineto{14.73334pt}{-13.02498pt}\pgfsys@lineto{13.87976pt}{-13.72498pt}\pgfsys@lineto{12.17259pt}{-12.32498pt}\pgfsys@lineto{10.46542pt}{-13.72498pt}\pgfsys@lineto{8.75826pt}{-12.32498pt}\pgfsys@lineto{7.05109pt}{-13.72498pt}\pgfsys@lineto{5.34392pt}{-12.32498pt}\pgfsys@lineto{3.63675pt}{-13.72498pt}\pgfsys@lineto{1.92958pt}{-12.32498pt}\pgfsys@lineto{0.22241pt}{-13.72498pt}\pgfsys@lineto{-1.48476pt}{-12.32498pt}\pgfsys@lineto{-3.19193pt}{-13.72498pt}\pgfsys@lineto{-4.8991pt}{-12.32498pt}\pgfsys@lineto{-6.60626pt}{-13.72498pt}\pgfsys@lineto{-8.31343pt}{-12.32498pt}\pgfsys@lineto{-10.0206pt}{-13.72498pt}\pgfsys@lineto{-11.72777pt}{-12.32498pt}\pgfsys@lineto{-13.43494pt}{-13.72498pt}\pgfsys@lineto{-15.1421pt}{-12.32498pt}\pgfsys@lineto{-16.84927pt}{-13.72498pt}\pgfsys@lineto{-18.23334pt}{-13.02498pt}\pgfsys@lineto{-18.23334pt}{-13.02498pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{18.03334pt}{-13.02498pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle. The only applicable rule is Se-Commit and directly follows from the rule’s definition. ∎
Lemma 4**.**
Let be a Asm program and be a prediction oracle. Whenever r:=\langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, , , and the run is a rolled-back transaction, then .
Proof.
Let be a Asm program and be a prediction oracle. Assume that r:=\langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}^{\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime}\mathchar 44\relax h^{\prime}\rangle, , , and the run is a rolled-back transaction. Since is a rolled back transaction, there is an identifier and two labels such that \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to43.93pt{\vbox to29.81pt{\pgfpicture\makeatletter\hbox{\hskip 21.96252pt\lower-16.30551pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-19.66809pt}{-11.6111pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{21.36253pt}{-13.70554pt}\pgfsys@lineto{18.26253pt}{-13.70554pt}\pgfsys@lineto{17.40895pt}{-14.40553pt}\pgfsys@lineto{15.70178pt}{-13.00554pt}\pgfsys@lineto{13.99461pt}{-14.40553pt}\pgfsys@lineto{12.28745pt}{-13.00554pt}\pgfsys@lineto{10.58028pt}{-14.40553pt}\pgfsys@lineto{8.87311pt}{-13.00554pt}\pgfsys@lineto{7.16594pt}{-14.40553pt}\pgfsys@lineto{5.45877pt}{-13.00554pt}\pgfsys@lineto{3.7516pt}{-14.40553pt}\pgfsys@lineto{2.04443pt}{-13.00554pt}\pgfsys@lineto{0.33727pt}{-14.40553pt}\pgfsys@lineto{-1.3699pt}{-13.00554pt}\pgfsys@lineto{-3.07707pt}{-14.40553pt}\pgfsys@lineto{-4.78424pt}{-13.00554pt}\pgfsys@lineto{-6.49141pt}{-14.40553pt}\pgfsys@lineto{-8.19858pt}{-13.00554pt}\pgfsys@lineto{-9.90575pt}{-14.40553pt}\pgfsys@lineto{-11.61292pt}{-13.00554pt}\pgfsys@lineto{-13.32008pt}{-14.40553pt}\pgfsys@lineto{-15.02725pt}{-13.00554pt}\pgfsys@lineto{-16.73442pt}{-14.40553pt}\pgfsys@lineto{-18.44159pt}{-13.00554pt}\pgfsys@lineto{-20.14876pt}{-14.40553pt}\pgfsys@lineto{-21.76253pt}{-13.70554pt}\pgfsys@lineto{-21.76253pt}{-13.70554pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{21.56253pt}{-13.70554pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{1}\mathchar 44\relax\sigma_{1}\mathchar 44\relax s_{1}\mathchar 44\relax h_{1}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\ldots\mathrel{\leavevmode\hbox to13.38pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 6.6916pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-4.39717pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n-1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.09161pt}{-12.74582pt}\pgfsys@lineto{2.99161pt}{-12.74582pt}\pgfsys@lineto{2.13803pt}{-13.44582pt}\pgfsys@lineto{0.43086pt}{-12.04582pt}\pgfsys@lineto{-1.2763pt}{-13.44582pt}\pgfsys@lineto{-2.98347pt}{-12.04582pt}\pgfsys@lineto{-4.69064pt}{-13.44582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.29161pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n}\mathchar 44\relax\sigma_{n}\mathchar 44\relax s_{n}\mathchar 44\relax h_{n}\rangle\mathrel{\leavevmode\hbox to54.71pt{\vbox to30.92pt{\pgfpicture\makeatletter\hbox{\hskip 27.35419pt\lower-16.86107pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-25.05975pt}{-12.16666pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{26.7542pt}{-14.2611pt}\pgfsys@lineto{23.65419pt}{-14.2611pt}\pgfsys@lineto{22.80061pt}{-14.96109pt}\pgfsys@lineto{21.09344pt}{-13.5611pt}\pgfsys@lineto{19.38628pt}{-14.96109pt}\pgfsys@lineto{17.67911pt}{-13.5611pt}\pgfsys@lineto{15.97194pt}{-14.96109pt}\pgfsys@lineto{14.26477pt}{-13.5611pt}\pgfsys@lineto{12.5576pt}{-14.96109pt}\pgfsys@lineto{10.85043pt}{-13.5611pt}\pgfsys@lineto{9.14326pt}{-14.96109pt}\pgfsys@lineto{7.4361pt}{-13.5611pt}\pgfsys@lineto{5.72893pt}{-14.96109pt}\pgfsys@lineto{4.02176pt}{-13.5611pt}\pgfsys@lineto{2.31459pt}{-14.96109pt}\pgfsys@lineto{0.60742pt}{-13.5611pt}\pgfsys@lineto{-1.09975pt}{-14.96109pt}\pgfsys@lineto{-2.80692pt}{-13.5611pt}\pgfsys@lineto{-4.51408pt}{-14.96109pt}\pgfsys@lineto{-6.22125pt}{-13.5611pt}\pgfsys@lineto{-7.92842pt}{-14.96109pt}\pgfsys@lineto{-9.63559pt}{-13.5611pt}\pgfsys@lineto{-11.34276pt}{-14.96109pt}\pgfsys@lineto{-13.04993pt}{-13.5611pt}\pgfsys@lineto{-14.7571pt}{-14.96109pt}\pgfsys@lineto{-16.46426pt}{-13.5611pt}\pgfsys@lineto{-18.17143pt}{-14.96109pt}\pgfsys@lineto{-19.8786pt}{-13.5611pt}\pgfsys@lineto{-21.58577pt}{-14.96109pt}\pgfsys@lineto{-23.29294pt}{-13.5611pt}\pgfsys@lineto{-25.0001pt}{-14.96109pt}\pgfsys@lineto{-27.15419pt}{-14.2611pt}\pgfsys@lineto{-27.15419pt}{-14.2611pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{26.9542pt}{-14.2611pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n+1}\mathchar 44\relax\sigma_{n+1}\mathchar 44\relax s_{n+1}\mathchar 44\relax h_{n+1}\rangle.
First, observe that is {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ i\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell\cdot\tau^{\prime}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ i\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}. From this, \tau\mathord{\upharpoonright_{nse}}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}\mathord{\upharpoonright_{nse}}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}.
Next, the first step in is obtained by applying the Se-Branch rule (since it is the only rule producing {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id} observations). Hence, the last transaction in is , where is the prediction produced by , and . We never modify the identifier, label, and rollback state inside the speculative transaction during the execution up to the last step. Therefore, it follows (from the rules) that is a transaction in .
Finally, the last step is obtained by applying the Se-Rollback rule (since it is the only rule producing {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id} observations). Hence, the rolled back transaction in is . From this, we have \sigma\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}\sigma_{n+1}. From this, \tau\mathord{\upharpoonright_{nse}}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}, and (by construction), we have . ∎
Lemma 5**.**
Let be a program, be a prediction oracle, and \langle\mathit{ctr}_{0}\mathchar 44\relax\sigma_{0}\mathchar 44\relax s_{0}\mathchar 44\relax h_{0}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{0}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{1}\mathchar 44\relax\sigma_{1}\mathchar 44\relax s_{1}\mathchar 44\relax h_{1}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\ldots\mathrel{\leavevmode\hbox to13.38pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 6.6916pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-4.39717pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n-1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.09161pt}{-12.74582pt}\pgfsys@lineto{2.99161pt}{-12.74582pt}\pgfsys@lineto{2.13803pt}{-13.44582pt}\pgfsys@lineto{0.43086pt}{-12.04582pt}\pgfsys@lineto{-1.2763pt}{-13.44582pt}\pgfsys@lineto{-2.98347pt}{-12.04582pt}\pgfsys@lineto{-4.69064pt}{-13.44582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.29161pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n}\mathchar 44\relax\sigma_{n}\mathchar 44\relax s_{n}\mathchar 44\relax h_{n}\rangle\mathrel{\leavevmode\hbox to10.05pt{\vbox to27.46pt{\pgfpicture\makeatletter\hbox{\hskip 5.02493pt\lower-15.13191pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.7305pt}{-10.4375pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.42494pt}{-12.53194pt}\pgfsys@lineto{1.32494pt}{-12.53194pt}\pgfsys@lineto{0.47136pt}{-13.23193pt}\pgfsys@lineto{-1.23581pt}{-11.83194pt}\pgfsys@lineto{-2.94298pt}{-13.23193pt}\pgfsys@lineto{-4.82494pt}{-12.53194pt}\pgfsys@lineto{-4.82494pt}{-12.53194pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.62494pt}{-12.53194pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n+1}\mathchar 44\relax\sigma_{n+1}\mathchar 44\relax s_{n+1}\mathchar 44\relax h_{n+1}\rangle be an execution. For all identifiers , if there is a index such that \tau_{j}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}, then there exists an and such that \langle m\mathchar 44\relax a\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle m\mathchar 44\relax a[\mathbf{pc}\mapsto\ell]\rangle, , , and \tau_{i}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}_{i}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma_{i+1}(\mathbf{pc}).
Proof.
Let be a program, be a prediction oracle, and \langle\mathit{ctr}_{0}\mathchar 44\relax\sigma_{0}\mathchar 44\relax s_{0}\mathchar 44\relax h_{0}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{0}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{1}\mathchar 44\relax\sigma_{1}\mathchar 44\relax s_{1}\mathchar 44\relax h_{1}\rangle\mathrel{\leavevmode\hbox to9.65pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 4.82446pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.53003pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.22447pt}{-12.74582pt}\pgfsys@lineto{1.12447pt}{-12.74582pt}\pgfsys@lineto{0.27089pt}{-13.44582pt}\pgfsys@lineto{-1.43628pt}{-12.04582pt}\pgfsys@lineto{-3.14345pt}{-13.44582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@lineto{-4.62447pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.42447pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\ldots\mathrel{\leavevmode\hbox to13.38pt{\vbox to27.89pt{\pgfpicture\makeatletter\hbox{\hskip 6.6916pt\lower-15.3458pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-4.39717pt}{-10.65138pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n-1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.09161pt}{-12.74582pt}\pgfsys@lineto{2.99161pt}{-12.74582pt}\pgfsys@lineto{2.13803pt}{-13.44582pt}\pgfsys@lineto{0.43086pt}{-12.04582pt}\pgfsys@lineto{-1.2763pt}{-13.44582pt}\pgfsys@lineto{-2.98347pt}{-12.04582pt}\pgfsys@lineto{-4.69064pt}{-13.44582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@lineto{-6.49161pt}{-12.74582pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.29161pt}{-12.74582pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n}\mathchar 44\relax\sigma_{n}\mathchar 44\relax s_{n}\mathchar 44\relax h_{n}\rangle\mathrel{\leavevmode\hbox to10.05pt{\vbox to27.46pt{\pgfpicture\makeatletter\hbox{\hskip 5.02493pt\lower-15.13191pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.7305pt}{-10.4375pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{n}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{4.42494pt}{-12.53194pt}\pgfsys@lineto{1.32494pt}{-12.53194pt}\pgfsys@lineto{0.47136pt}{-13.23193pt}\pgfsys@lineto{-1.23581pt}{-11.83194pt}\pgfsys@lineto{-2.94298pt}{-13.23193pt}\pgfsys@lineto{-4.82494pt}{-12.53194pt}\pgfsys@lineto{-4.82494pt}{-12.53194pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{4.62494pt}{-12.53194pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}_{n+1}\mathchar 44\relax\sigma_{n+1}\mathchar 44\relax s_{n+1}\mathchar 44\relax h_{n+1}\rangle be an execution. Let be an arbitrary identifier such that \tau_{j}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id} for some . The -th step in the run has been produced by applying the Se-Commit rule, which is the only rule producing {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id} observations, while committing the the speculative transaction in . Hence, \langle m\mathchar 44\relax a\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle m\mathchar 44\relax a[\mathbf{pc}\mapsto\ell]\rangle holds. Therefore, there is an when we executed the Se-Branch rule for the identifier . In particular, the rule created the speculative transaction where , the observations are \tau_{i}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}_{i}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}, and the next program counter is . Since (1) we only modify the speculative windows inside the speculative transactions states, and (2) there is always only one speculative transaction per identifier, it follows that , , and . From this, \langle m\mathchar 44\relax a\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle m\mathchar 44\relax a[\mathbf{pc}\mapsto\ell]\rangle, , , and \tau_{i}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}_{i}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma_{i+1}(\mathbf{pc}). ∎
F-B Completeness of the speculative semantics
Proposition 6 states that the speculative semantics models all behaviors of the non-speculative semantics (independently on the prediction oracle).
Proposition 6**.**
Let be a program and be a prediction oracle. Whenever , , and , there are , , and such that \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.75pt{\vbox to27.71pt{\pgfpicture\makeatletter\hbox{\hskip 4.37447pt\lower-15.25691pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.08003pt}{-10.5625pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.77448pt}{-12.65694pt}\pgfsys@lineto{0.67447pt}{-12.65694pt}\pgfsys@lineto{-0.17911pt}{-13.35693pt}\pgfsys@lineto{-1.88628pt}{-11.95694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.97447pt}{-12.65694pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax h\rangle and .
Proof.
Let be a program and be a prediction oracle. Moreover, let be an execution such that and .
We now define a procedure for constructing the execution under the speculative semantics as follows:
- •
If and , then we apply the Se-NoBranch rule once. This produces the step r^{\prime}:=\langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\mathit{decr}(s)\mathchar 44\relax h^{\prime}\rangle. We return .
- •
If and , there are two cases:
- –
If and , then we correctly predict the outcome of the branch instruction. We produce the execution by applying the Se-Branch rule: r^{\prime}:=\langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to46.67pt{\vbox to29.81pt{\pgfpicture\makeatletter\hbox{\hskip 23.33336pt\lower-16.30551pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-21.03893pt}{-11.6111pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{22.73337pt}{-13.70554pt}\pgfsys@lineto{19.63336pt}{-13.70554pt}\pgfsys@lineto{18.77979pt}{-14.40553pt}\pgfsys@lineto{17.07262pt}{-13.00554pt}\pgfsys@lineto{15.36545pt}{-14.40553pt}\pgfsys@lineto{13.65828pt}{-13.00554pt}\pgfsys@lineto{11.95111pt}{-14.40553pt}\pgfsys@lineto{10.24394pt}{-13.00554pt}\pgfsys@lineto{8.53677pt}{-14.40553pt}\pgfsys@lineto{6.8296pt}{-13.00554pt}\pgfsys@lineto{5.12244pt}{-14.40553pt}\pgfsys@lineto{3.41527pt}{-13.00554pt}\pgfsys@lineto{1.7081pt}{-14.40553pt}\pgfsys@lineto{0.00093pt}{-13.00554pt}\pgfsys@lineto{-1.70624pt}{-14.40553pt}\pgfsys@lineto{-3.4134pt}{-13.00554pt}\pgfsys@lineto{-5.12057pt}{-14.40553pt}\pgfsys@lineto{-6.82774pt}{-13.00554pt}\pgfsys@lineto{-8.53491pt}{-14.40553pt}\pgfsys@lineto{-10.24208pt}{-13.00554pt}\pgfsys@lineto{-11.94925pt}{-14.40553pt}\pgfsys@lineto{-13.65642pt}{-13.00554pt}\pgfsys@lineto{-15.36359pt}{-14.40553pt}\pgfsys@lineto{-17.07076pt}{-13.00554pt}\pgfsys@lineto{-18.77792pt}{-14.40553pt}\pgfsys@lineto{-20.48509pt}{-13.00554pt}\pgfsys@lineto{-22.19226pt}{-14.40553pt}\pgfsys@lineto{-23.13336pt}{-13.70554pt}\pgfsys@lineto{-23.13336pt}{-13.70554pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{22.93336pt}{-13.70554pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}+1\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\mathit{decr}(s)\cdot\langle\sigma\mathchar 44\relax\mathit{ctr}\mathchar 44\relax w\mathchar 44\relax\ell\rangle\mathchar 44\relax h\cdot\langle\sigma(\mathbf{pc})\mathchar 44\relax\mathit{ctr}\mathchar 44\relax\ell\rangle\rangle. Observe that this step starts a speculative transaction that will be committed (since ). We return .
- –
If and , then we mispredict the outcome of the branch instruction.We produce the execution by (1) applying Se-Branch once to start the transaction , (2) we repeatedly apply the speculative semantics rules until we roll back the transaction . This is always possible since speculative transactions always terminate. Hence, is \langle\mathit{ctr}\mathchar 44\relax\sigma\mathchar 44\relax s\mathchar 44\relax h\rangle\mathrel{\leavevmode\hbox to46.67pt{\vbox to29.81pt{\pgfpicture\makeatletter\hbox{\hskip 23.33336pt\lower-16.30551pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-21.03893pt}{-11.6111pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{22.73337pt}{-13.70554pt}\pgfsys@lineto{19.63336pt}{-13.70554pt}\pgfsys@lineto{18.77979pt}{-14.40553pt}\pgfsys@lineto{17.07262pt}{-13.00554pt}\pgfsys@lineto{15.36545pt}{-14.40553pt}\pgfsys@lineto{13.65828pt}{-13.00554pt}\pgfsys@lineto{11.95111pt}{-14.40553pt}\pgfsys@lineto{10.24394pt}{-13.00554pt}\pgfsys@lineto{8.53677pt}{-14.40553pt}\pgfsys@lineto{6.8296pt}{-13.00554pt}\pgfsys@lineto{5.12244pt}{-14.40553pt}\pgfsys@lineto{3.41527pt}{-13.00554pt}\pgfsys@lineto{1.7081pt}{-14.40553pt}\pgfsys@lineto{0.00093pt}{-13.00554pt}\pgfsys@lineto{-1.70624pt}{-14.40553pt}\pgfsys@lineto{-3.4134pt}{-13.00554pt}\pgfsys@lineto{-5.12057pt}{-14.40553pt}\pgfsys@lineto{-6.82774pt}{-13.00554pt}\pgfsys@lineto{-8.53491pt}{-14.40553pt}\pgfsys@lineto{-10.24208pt}{-13.00554pt}\pgfsys@lineto{-11.94925pt}{-14.40553pt}\pgfsys@lineto{-13.65642pt}{-13.00554pt}\pgfsys@lineto{-15.36359pt}{-14.40553pt}\pgfsys@lineto{-17.07076pt}{-13.00554pt}\pgfsys@lineto{-18.77792pt}{-14.40553pt}\pgfsys@lineto{-20.48509pt}{-13.00554pt}\pgfsys@lineto{-22.19226pt}{-14.40553pt}\pgfsys@lineto{-23.13336pt}{-13.70554pt}\pgfsys@lineto{-23.13336pt}{-13.70554pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{22.93336pt}{-13.70554pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}+1\mathchar 44\relax\sigma[\mathbf{pc}\mapsto\ell]\mathchar 44\relax\mathit{decr}(s)\cdot\langle\sigma\mathchar 44\relax\mathit{ctr}\mathchar 44\relax w\mathchar 44\relax\ell\rangle\mathchar 44\relax h\cdot\langle\sigma(\mathbf{pc})\mathchar 44\relax\mathit{ctr}\mathchar 44\relax\ell\rangle\rangle\mathrel{\leavevmode\hbox to8.75pt{\vbox to27.71pt{\pgfpicture\makeatletter\hbox{\hskip 4.37447pt\lower-15.25691pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.08003pt}{-10.5625pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.77448pt}{-12.65694pt}\pgfsys@lineto{0.67447pt}{-12.65694pt}\pgfsys@lineto{-0.17911pt}{-13.35693pt}\pgfsys@lineto{-1.88628pt}{-11.95694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.97447pt}{-12.65694pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}\langle\mathit{ctr}^{\prime\prime}\mathchar 44\relax\sigma^{\prime\prime}\mathchar 44\relax s^{\prime\prime}\cdot\langle\sigma\mathchar 44\relax\mathit{ctr}\mathchar 44\relax 0\mathchar 44\relax\ell\rangle\cdot s^{\prime\prime\prime}\mathchar 44\relax h^{\prime}\rangle\mathrel{\leavevmode\hbox to71.17pt{\vbox to30.59pt{\pgfpicture\makeatletter\hbox{\hskip 35.58609pt\lower-16.69441pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-33.29166pt}{-12.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma^{\prime}(\mathbf{pc})}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{34.9861pt}{-14.09444pt}\pgfsys@lineto{31.8861pt}{-14.09444pt}\pgfsys@lineto{31.03252pt}{-14.79443pt}\pgfsys@lineto{29.32535pt}{-13.39444pt}\pgfsys@lineto{27.61818pt}{-14.79443pt}\pgfsys@lineto{25.91101pt}{-13.39444pt}\pgfsys@lineto{24.20384pt}{-14.79443pt}\pgfsys@lineto{22.49667pt}{-13.39444pt}\pgfsys@lineto{20.7895pt}{-14.79443pt}\pgfsys@lineto{19.08234pt}{-13.39444pt}\pgfsys@lineto{17.37517pt}{-14.79443pt}\pgfsys@lineto{15.668pt}{-13.39444pt}\pgfsys@lineto{13.96083pt}{-14.79443pt}\pgfsys@lineto{12.25366pt}{-13.39444pt}\pgfsys@lineto{10.5465pt}{-14.79443pt}\pgfsys@lineto{8.83932pt}{-13.39444pt}\pgfsys@lineto{7.13216pt}{-14.79443pt}\pgfsys@lineto{5.42499pt}{-13.39444pt}\pgfsys@lineto{3.71782pt}{-14.79443pt}\pgfsys@lineto{2.01065pt}{-13.39444pt}\pgfsys@lineto{0.30348pt}{-14.79443pt}\pgfsys@lineto{-1.40369pt}{-13.39444pt}\pgfsys@lineto{-3.11086pt}{-14.79443pt}\pgfsys@lineto{-4.81802pt}{-13.39444pt}\pgfsys@lineto{-6.52519pt}{-14.79443pt}\pgfsys@lineto{-8.23236pt}{-13.39444pt}\pgfsys@lineto{-9.93953pt}{-14.79443pt}\pgfsys@lineto{-11.6467pt}{-13.39444pt}\pgfsys@lineto{-13.35387pt}{-14.79443pt}\pgfsys@lineto{-15.06104pt}{-13.39444pt}\pgfsys@lineto{-16.7682pt}{-14.79443pt}\pgfsys@lineto{-18.47537pt}{-13.39444pt}\pgfsys@lineto{-20.18254pt}{-14.79443pt}\pgfsys@lineto{-21.88971pt}{-13.39444pt}\pgfsys@lineto{-23.59688pt}{-14.79443pt}\pgfsys@lineto{-25.30405pt}{-13.39444pt}\pgfsys@lineto{-27.01122pt}{-14.79443pt}\pgfsys@lineto{-28.71838pt}{-13.39444pt}\pgfsys@lineto{-30.42555pt}{-14.79443pt}\pgfsys@lineto{-32.13272pt}{-13.39444pt}\pgfsys@lineto{-33.83989pt}{-14.79443pt}\pgfsys@lineto{-35.3861pt}{-14.09444pt}\pgfsys@lineto{-35.3861pt}{-14.09444pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{35.1861pt}{-14.09444pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}\langle\mathit{ctr}^{\prime\prime}\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax s^{\prime\prime}\mathchar 44\relax h^{\prime}\cdot\langle\sigma(\mathbf{pc})\mathchar 44\relax\mathit{ctr}\mathchar 44\relax\sigma^{\prime}(\mathbf{pc})\rangle\rangle. We return .
- •
If , then there is a pending transaction (with identifier ) that has to be committed. In this case, we simply perform one step by applying the Se-Commit rule.
Finally, the execution is constructed by concatenating the partial executions , which are constructed as follows:
[TABLE]
From the construction, it immediately follows that the initial extended configuration in is and the final configuration is (for some and ) since (1) is a terminating run, (2) we always execute all transactions until completion, (3) speculative transactions always terminate given that speculative windows are decremented during execution, (4) rolled-back speculative transactions do not affect the configuration . Similarly, it is easy to see that since (1) the observations associated with committed steps are equivalent to those in the non-speculative semantics, (2) observations associated with rolled back transactions are removed by the projection (and we execute all transactions until termination, and (3) other extended observations are removed by the non-speculative projection. ∎
Appendix G Relating the always-mispredict and non-speculative semantics (Proposition 3)
We start by spelling out the definition of . Given a program and a speculative window , we denote by the set of all triples corresponding to executions .
We are now ready to prove Proposition 3, which we restate here for simplicity:
See 3
Proof.
The proposition can be proved in a similar way to Proposition 1. Specifically, the proof of the direction is a simpler version of Proposition 5’s proof since there are only rolled-back transactions. The proof of the direction , instead, is identical Proposition 6’s proof. ∎
Appendix H Relating speculative and always mispredict semantics (Theorem 1 and Proposition 4)
Below, we provide the proof of Theorem 1, which we restate here for simplicity:
See 1
Proof.
Let be a program, be a policy, and be a speculative window. We prove the two directions separately.
Assume that satisfies SNI for and all prediction oracles with speculative window at most . Then, for all with speculative window at most , for all initial configurations , if and , then . From this and Proposition 4 (proved below), we have that for all initial configurations , if and , then .
Assume that is such that for all initial configurations , if and , then . Let be an arbitrary prediction oracle with speculative window at most . From Proposition 4 (proved below), we have that for all initial configurations , if and , then . Therefore, satisfies SNI w.r.t. and . Since is an arbitrary predictor with speculation window at most , then satisfies SNI for and all prediction oracles with speculative window at most . ∎
The proof of Theorem 1 depends on Proposition 4, which we restate here for simplicity:
See 4
Proof.
The proposition follows immediately from Propositions 7 (proved in Section H-B) and 8 (proved in Section H-C). ∎
H-A Auxiliary definitions
Before proving Propositions 7 and 8, we introduce some auxiliary definitions.
-similar configurations
Two configurations are -similar, written , iff .
Next-step agreeing configurations
Two configurations are next-step agreeing, written , iff there are such that , , and .
Similar extended configurations
Two speculative states and in are similar, written , iff , , , , and .
Two sequences of speculative states and in are similar, written , iff all their speculative states are similar. Formally, and iff and .
Two extended configurations are similar, written , iff , , and . Similarly, iff , , , and .
Commit-free projection
The commit-free projection of a sequence of speculative state , written , is as follows: , if and , and if and .
Mirrored configurations
Two speculative states and in are mirrors if and . Two sequences of speculative states and in are mirrors, written , if and their speculative states are pairwise mirrors. Finally, iff and .
Auxiliary functions for handling transactions’ lenghts
The function is defined as follows: and . The function is defined as follows: and .
Invariants
We denote by , where , the fact that and for all , , where denotes the prefix of of length . Additionally, , where is an extended configuration for the always mispredict semantics whereas is an extended configuration for the speculative semantics, holds iff does.
We denote by , where , the fact that and for all , , where denotes the prefix of of length . Moreover, , where is an extended configuration for the always mispredict semantics whereas is an extended configuration for the speculative semantics, holds iff does.
Notation for runs and traces
For simplicity, we restate here the definitions of and . Let be a program, be a speculative window, be a prediction oracle, and be an initial configuration. Then, denotes the trace such that there is a final configuration such that , whereas denotes the trace such that there is a final configuration such that . If there is no such , then we write (respectively ).
H-B Soundness
In Proposition 7 , we prove the soundness of the always mispredict semantics w.r.t. the speculative semantics.
Proposition 7**.**
Let be a program, be a speculative window, and be two initial configurations. If , then for all prediction oracle with speculation window at most .
Proof.
Let be a speculative window and be two initial configurations such that . Moreover, let be an arbitrary prediction oracle with speculative window at most . If , then the computation does not terminate in and . Since speculation does not introduce non-termination, the computation does not terminate according to as well. Hence, . If , then we can obtain the runs for by repeatedly applying Lemma 6 (proved below) to the runs corresponding to and . Observe that we can apply the Lemma 6 because (I) , (II) , (III) the initial configurations , , , trivially satisfy conditions (1)–(4), and (IV) the application of Lemma 6 preserves (1)–(4). From the point (g) in Lemma 6, we immediately have that the runs have the same traces. Hence, . ∎
We now prove Lemma 6.
Lemma 6**.**
Let be a program, be a speculative window, be a prediction oracle with speculative window at most , be two extended speculative configurations for the always mispredict semantics, and be two extended speculative configurations for the speculative semantics.
If the following conditions hold:
, 2. 2.
, 3. 3.
, 4. 4.
, 5. 5.
, 6. 6.
,
then there are configurations (for the always mispredict semantics), (for the speculative semantics), and such that:
- (a)
, 2. (b)
sp_{0}\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}\wedge sp_{0}^{\prime}\mathrel{\leavevmode\hbox to8.75pt{\vbox to27.71pt{\pgfpicture\makeatletter\hbox{\hskip 4.37447pt\lower-15.25691pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.08003pt}{-10.5625pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.77448pt}{-12.65694pt}\pgfsys@lineto{0.67447pt}{-12.65694pt}\pgfsys@lineto{-0.17911pt}{-13.35693pt}\pgfsys@lineto{-1.88628pt}{-11.95694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.97447pt}{-12.65694pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}^{\prime}, 3. (c)
, 4. (d)
, 5. (e)
, 6. (f)
, and 7. (g)
.
Proof.
Let be a program, be a speculative window, be a prediction oracle with speculative window at most , be two extended speculative configurations for the “always mispredict” semantics, and be two extended speculative configurations for the speculative semantics.
In the following, we use a dot notation to refer to the components of the extended configurations. For instance, we write to denote the configuration in . We also implicitly lift functions like and to extended configurations.
Assume that (1)–(6) hold. Observe that, from (2), it follows . We proceed by case distinction on :
- :
From , (1), (2), and (4), we also get that and (this follows from and (4)). From and (2), it follows that and hold. Additionally, from and (1), we also get and . That is, we can apply only the rules Se-NoBranch and Se-Branch according to both semantics. Observe that (from (2)) and (from (1)). Moreover, and (from (3)). Hence, the program counters in the four states point to the same instructions. There are two cases:
- is a branch instruction :
Observe that since , (from (2)), and is a prediction oracle. Let be the corresponding prediction.
There are two cases:
- ** is a correct prediction w.r.t. **:
We first show that is a correct prediction w.r.t. as well. From (6), we know that the trace produced starting from and are the same. From this, , and is a branch instruction, we have that the always mispredict semantics modifies the program counter in the same way in and when applying the Se-Branch in . Hence, . From this and (3), we also have . Thus, is a correct prediction w.r.t. as well.
According to the always mispredict semantics, there are such that:
[TABLE]
From (1) and (6), we immediately have that , , , , and . Moreover, since is a correct prediction we also have that and . Hence, we pick to be .
Additionally, by applying the rule Se-Branch once in we also get sp_{0}\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1} and sp_{0}^{\prime}\mathrel{\leavevmode\hbox to8.75pt{\vbox to27.71pt{\pgfpicture\makeatletter\hbox{\hskip 4.37447pt\lower-15.25691pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.08003pt}{-10.5625pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.77448pt}{-12.65694pt}\pgfsys@lineto{0.67447pt}{-12.65694pt}\pgfsys@lineto{-0.17911pt}{-13.35693pt}\pgfsys@lineto{-1.88628pt}{-11.95694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.97447pt}{-12.65694pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}^{\prime}.
We have already shown that (a) and (b) hold. We now show that (c)–(g) hold as well.
- (c):
To show that , we need to show , , and . First, immediately follows from and (1) (that is, and during the mispredicted branch we created the same transactions in both runs). Second, follows from (since and ). Finally, immediately follows from , , and (1). 2. (d):
To show that , we need to show , , , and . First, immediately follows from , , and (2). Second, follows from (2) and (so the program counter is updated in the same way in both configurations). Third, follows from (2), being , being , (from (2)), (from (2)), and (we proved above that ; from this, it follows that the outcome of the branch instruction w.r.t. the non-speculative semantics is the same). Finally, immediately follows from (2), , , (from (2)), and (from (2)). 3. (e):
We show only (the proof for is similar). To show , we need to show and . From the Se-Branch rule in , we have that . The last step in is obtained by applying the rule Se-Rollback in . From this rule, is the configuration obtained by executing one step of the non-speculative semantics starting from . From (3), we have that . Moreover, since is a correct prediction for , we have that . Hence, .
We now show that . From the Se-Branch rule in , we have that . Since is a correct prediction for , however, . Moreover, from , it follows that . Hence, follows from (3), , and . 4. (f):
Here we prove that holds. can be proved in a similar way. To show , we need to show that and for all , .
We first prove . From (4), we have . From the run , we have that and, therefore, . From the Se-Branch rule in , we have that . Since is a correct prediction for , we have that . Hence, . From , , and , we therefore have that .
We now show that for all , . Observe that and . Since is a correct prediction for , we have that . Let be an arbitrary value such that . Then, and . From (4), we have that . From this and , we get . From the definition of , we also have . From this and , we have . Hence, for all (since we have proved it for an arbitrary ). 5. (g):
The observations are \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ sp_{0}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime} and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ sp_{0}^{\prime}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}. From this, , and (from (2)), we get .
This completes the proof of this case.
- ** is a misprediction w.r.t. **:
We first show that is a misprediction w.r.t. as well. From (6), we know that the trace produced starting from and are the same. From this, , and is a branch instruction, we have that the always mispredict semantics modifies the program counter in the same way in and when applying the Se-Branch in . Hence, . From this and (3), we also have . Thus, is a misprediction w.r.t. as well.
Let . We obtain and by applying once the rule Se-Branch in . From (5) and (6), we have that . Moreover, by applying the rule Se-Branch once in we also get sp_{0}\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1} and sp_{0}^{\prime}\mathrel{\leavevmode\hbox to8.75pt{\vbox to27.71pt{\pgfpicture\makeatletter\hbox{\hskip 4.37447pt\lower-15.25691pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.08003pt}{-10.5625pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.77448pt}{-12.65694pt}\pgfsys@lineto{0.67447pt}{-12.65694pt}\pgfsys@lineto{-0.17911pt}{-13.35693pt}\pgfsys@lineto{-1.88628pt}{-11.95694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.97447pt}{-12.65694pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}^{\prime}.
We have already shown that (a) and (b) hold. We now show that (c)–(g) hold as well.
- (c):
To show that , we need to show , , and . First, immediately follows from , , and (1). Second, follows from (i.e., the program counter is modified in the same ways in both runs). Finally, to show that , we need to show that , , , , and (since and ). Observe that follows from (1), also follow from (1), follows from (which indicates that is modified in a similar way), follows from (1), and follows from (i.e., since we mispredict in the same direct, then the outcome of the branch instruction must be the same according to the non-speculative semantics). 2. (d):
To show that , we need to show , , , and . First, immediately follows from , , and (2). Second, follows from (2) and (so the program counter is updated in the same way in both configurations). Third, follows from (2), being , being , (from (2)), (from (2)), and (we proved above that ; from this, it follows that the outcome of the branch instruction w.r.t. the non-speculative semantics is the same). Finally, immediately follows from (2), , , (from (2)), and (from (2)). 3. (e):
To show , we need to show , , , and . In the following, we show only and ( and can be derived in the same way). The Se-Branch rule in both semantics only modify the program counter. From this and (3), for showing , it is enough to show . From the Se-Branch rule in the speculative semantics , we have that . There are two cases:
- :
From this and being a misprediction for , it follows that . Moreover, from and (3), we also have that . From this and the Se-Branch rule in , we have . Therefore, (because follows from (3)). Hence, . Thus, .
- :
From this and being a misprediction for , it follows that . Moreover, from and (3), we also have that . From this and the Se-Branch rule in , we have . Hence, . Thus, .
We still have to show that . From the Se-Branch rule in , we have that (note that the prediction is as we showed above). In contrast, from the Se-Branch rule in , we have that . Since is a misprediction for , we have that . Observe that immediately follows from (3). Hence, we just have to show that . Since the prediction is the same in both speculative states, this requires only to show that , which follows from (3). 4. (f):
Here we prove that holds. can be proved in a similar way. To show , we need to show that and for all , .
We first prove . From (4), we have . From the Se-Branch rule in , we have that (note that the prediction is as we showed above). Hence, . From the Se-Branch rule in , we have that . Since is a misprediction for , we have that . Hence, . From , , and , we therefore have .
We now show that for all , . Observe that and . Since is a misprediction for , we have that . There are two cases:
- :
From the Se-Branch rule in , we have that . From the Se-Branch rule in , we also have that . Moreover, we have that (1) (since has speculative window at most ), and (2) (since we have from (4) because ). As a result, we immediately have that . Hence, .
- :
We have (because ) and (because ). From (4), we also have that . Therefore, . From this, , and , we have . 5. (g):
The observations are \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ sp_{0}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime} and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ sp_{0}^{\prime}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}. From this, , and (from (2)), we get .
This completes the proof of this case.
This completes the proof of this case.
- is not a branch instruction:
Let . We obtain and by applying once the rule Se-NoBranch in . From (5) and (6), we have that . Moreover, by applying the rule Se-NoBranch once in we also get sp_{0}\mathrel{\leavevmode\hbox to7.65pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 3.82446pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.53003pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.22447pt}{-12.10138pt}\pgfsys@lineto{0.12447pt}{-12.10138pt}\pgfsys@lineto{-0.72911pt}{-12.80138pt}\pgfsys@lineto{-2.43628pt}{-11.40138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@lineto{-3.62447pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.42447pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1} and sp_{0}^{\prime}\mathrel{\leavevmode\hbox to8.75pt{\vbox to27.71pt{\pgfpicture\makeatletter\hbox{\hskip 4.37447pt\lower-15.25691pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-2.08003pt}{-10.5625pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.77448pt}{-12.65694pt}\pgfsys@lineto{0.67447pt}{-12.65694pt}\pgfsys@lineto{-0.17911pt}{-13.35693pt}\pgfsys@lineto{-1.88628pt}{-11.95694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@lineto{-4.17447pt}{-12.65694pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.97447pt}{-12.65694pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}^{\prime}.
We have already shown that (a) and (b) hold. We now show that (c)–(g) hold as well.
- (c):
To show that , we need to show , , and . First, immediately follows from , , and (1). Second, follows from (1) and the fact that modifies the program counters in and in the same way (if the current instruction is not a jump, both program counters are incremented by 1 and if the instruction is a jump, the target is the same since ). Finally, follows from (1), being either or (depending on ), and being either or (depending on ). 2. (d):
To show that , we need to show , , , and . First, immediately follows from , , and (2). Second, follows from (2) and the fact that modifies the program counters in and in the same way (if the current instruction is not a jump, both program counters are incremented by 1 and if the instruction is a jump, the target is the same since , which we prove in (g) below). Third, follows from (2), being either or (depending on ), and being either or (depending on ). Finally, immediately follows from (2), , and . 3. (e):
To show , we need to show , , , and . From the Se-NoBranch, we have that , , , . From this and (3), we have that and (since , ). Moreover, , and immediately follow from (3), being either or (depending on ), and being either or (depending on ), which only modify the speculation windows. 4. (f):
For simplicity, we show only , the proof for is analogous. To show , we need to show that (which immediately follows from and the fact that we do not add or remove speculative states) and for all , . There are two cases:
- :
If the instruction is not , then and . From (4), we also have that . Hence, .
If the executed instruction is , then and . Therefore, .
- :
If the executed instruction is not , then (because ) and . From (4), we also have that . Therefore, . From this, , and , we have .
If the executed instruction is , then (because ) and . From this, we immediately have . 5. (g):
From (3), we have that and . From the Se-NoBranch, we have that , , , . That is, and . From this and , we get .
This completes the proof of this case.
This completes the proof of this case.
- :
Let be the largest values such that and . We now show that . From (2), we have that which means that the speculative states in and are pairwise similar. As a result, the remaining speculative windows are pairwise the same. Hence, for all . Observe also that each pair of speculative states in and results either in two commits or two rollbacks (again from (2)).
There are two cases:
- We can apply the Se-Commit rule in :
Hence, , , , and . From (2), we have that , , , , , and . As a result, we can apply the Se-Commit rule also to . Therefore, we have sp_{0}\mathrel{\leavevmode\hbox to71.33pt{\vbox to30.59pt{\pgfpicture\makeatletter\hbox{\hskip 35.66527pt\lower-16.69441pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-33.37083pt}{-12.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}{0}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma{1}(\mathbf{pc})}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{35.06528pt}{-14.09444pt}\pgfsys@lineto{31.96527pt}{-14.09444pt}\pgfsys@lineto{31.1117pt}{-14.79443pt}\pgfsys@lineto{29.40453pt}{-13.39444pt}\pgfsys@lineto{27.69736pt}{-14.79443pt}\pgfsys@lineto{25.99019pt}{-13.39444pt}\pgfsys@lineto{24.28302pt}{-14.79443pt}\pgfsys@lineto{22.57585pt}{-13.39444pt}\pgfsys@lineto{20.86868pt}{-14.79443pt}\pgfsys@lineto{19.16151pt}{-13.39444pt}\pgfsys@lineto{17.45435pt}{-14.79443pt}\pgfsys@lineto{15.74718pt}{-13.39444pt}\pgfsys@lineto{14.04001pt}{-14.79443pt}\pgfsys@lineto{12.33284pt}{-13.39444pt}\pgfsys@lineto{10.62567pt}{-14.79443pt}\pgfsys@lineto{8.9185pt}{-13.39444pt}\pgfsys@lineto{7.21133pt}{-14.79443pt}\pgfsys@lineto{5.50417pt}{-13.39444pt}\pgfsys@lineto{3.797pt}{-14.79443pt}\pgfsys@lineto{2.08983pt}{-13.39444pt}\pgfsys@lineto{0.38266pt}{-14.79443pt}\pgfsys@lineto{-1.32451pt}{-13.39444pt}\pgfsys@lineto{-3.03168pt}{-14.79443pt}\pgfsys@lineto{-4.73885pt}{-13.39444pt}\pgfsys@lineto{-6.44601pt}{-14.79443pt}\pgfsys@lineto{-8.15318pt}{-13.39444pt}\pgfsys@lineto{-9.86035pt}{-14.79443pt}\pgfsys@lineto{-11.56752pt}{-13.39444pt}\pgfsys@lineto{-13.27469pt}{-14.79443pt}\pgfsys@lineto{-14.98186pt}{-13.39444pt}\pgfsys@lineto{-16.68903pt}{-14.79443pt}\pgfsys@lineto{-18.3962pt}{-13.39444pt}\pgfsys@lineto{-20.10336pt}{-14.79443pt}\pgfsys@lineto{-21.81053pt}{-13.39444pt}\pgfsys@lineto{-23.5177pt}{-14.79443pt}\pgfsys@lineto{-25.22487pt}{-13.39444pt}\pgfsys@lineto{-26.93204pt}{-14.79443pt}\pgfsys@lineto{-28.6392pt}{-13.39444pt}\pgfsys@lineto{-30.34637pt}{-14.79443pt}\pgfsys@lineto{-32.05354pt}{-13.39444pt}\pgfsys@lineto{-33.76071pt}{-14.79443pt}\pgfsys@lineto{-35.46527pt}{-14.09444pt}\pgfsys@lineto{-35.46527pt}{-14.09444pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{35.26527pt}{-14.09444pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1} and sp_{0}^{\prime}\mathrel{\leavevmode\hbox to71.33pt{\vbox to31.31pt{\pgfpicture\makeatletter\hbox{\hskip 35.66527pt\lower-17.05551pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-33.37083pt}{-12.3611pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}{0}^{\prime}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma{1}^{\prime}(\mathbf{pc})}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{35.06528pt}{-14.45554pt}\pgfsys@lineto{31.96527pt}{-14.45554pt}\pgfsys@lineto{31.1117pt}{-15.15553pt}\pgfsys@lineto{29.40453pt}{-13.75554pt}\pgfsys@lineto{27.69736pt}{-15.15553pt}\pgfsys@lineto{25.99019pt}{-13.75554pt}\pgfsys@lineto{24.28302pt}{-15.15553pt}\pgfsys@lineto{22.57585pt}{-13.75554pt}\pgfsys@lineto{20.86868pt}{-15.15553pt}\pgfsys@lineto{19.16151pt}{-13.75554pt}\pgfsys@lineto{17.45435pt}{-15.15553pt}\pgfsys@lineto{15.74718pt}{-13.75554pt}\pgfsys@lineto{14.04001pt}{-15.15553pt}\pgfsys@lineto{12.33284pt}{-13.75554pt}\pgfsys@lineto{10.62567pt}{-15.15553pt}\pgfsys@lineto{8.9185pt}{-13.75554pt}\pgfsys@lineto{7.21133pt}{-15.15553pt}\pgfsys@lineto{5.50417pt}{-13.75554pt}\pgfsys@lineto{3.797pt}{-15.15553pt}\pgfsys@lineto{2.08983pt}{-13.75554pt}\pgfsys@lineto{0.38266pt}{-15.15553pt}\pgfsys@lineto{-1.32451pt}{-13.75554pt}\pgfsys@lineto{-3.03168pt}{-15.15553pt}\pgfsys@lineto{-4.73885pt}{-13.75554pt}\pgfsys@lineto{-6.44601pt}{-15.15553pt}\pgfsys@lineto{-8.15318pt}{-13.75554pt}\pgfsys@lineto{-9.86035pt}{-15.15553pt}\pgfsys@lineto{-11.56752pt}{-13.75554pt}\pgfsys@lineto{-13.27469pt}{-15.15553pt}\pgfsys@lineto{-14.98186pt}{-13.75554pt}\pgfsys@lineto{-16.68903pt}{-15.15553pt}\pgfsys@lineto{-18.3962pt}{-13.75554pt}\pgfsys@lineto{-20.10336pt}{-15.15553pt}\pgfsys@lineto{-21.81053pt}{-13.75554pt}\pgfsys@lineto{-23.5177pt}{-15.15553pt}\pgfsys@lineto{-25.22487pt}{-13.75554pt}\pgfsys@lineto{-26.93204pt}{-15.15553pt}\pgfsys@lineto{-28.6392pt}{-13.75554pt}\pgfsys@lineto{-30.34637pt}{-15.15553pt}\pgfsys@lineto{-32.05354pt}{-13.75554pt}\pgfsys@lineto{-33.76071pt}{-15.15553pt}\pgfsys@lineto{-35.46527pt}{-14.45554pt}\pgfsys@lineto{-35.46527pt}{-14.45554pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{35.26527pt}{-14.45554pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}^{\prime}.
Let . Therefore, we have , , , and .
We have already shown that (a) and (b) hold. We now show that (c)-(g) hold as well.
- (c):
immediately follows from (1), , and . 2. (d):
To show that , we need to show , , , and . First, immediately follows from , , and (2). Second, follows from (2), , and . Third, follows from (2), , and . Finally, immediately follows from (2), , and , (from (2)), (since all configurations in the speculative states are pairwise -agreeing), and (since all configurations in the speculative states are pairwise next-step agreeing). 3. (e):
Here we prove only ( can be proved in the same way). To show , we need to show and . From the Se-Commit rule in , we have that . Moreover, and, therefore, . From (3), , and , we have . Observe also that follows from (since ) and (since the removed speculative state is one leading to a commit). 4. (f):
For simplicity, we show only , the proof for is analogous. To show , we need to show that and for all , . Observe that (because ) and (because we remove a committed speculative state). As a result, both and for all immediately follow from (4). 5. (g):
The observations and are respectively {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}_{0} and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ \mathit{id}_{0}^{\prime}. From (2), we have that which implies . Hence, .
This completes the proof of this case.
- We can apply the Se-Rollback rule in :
Hence, , , , and . From (2), we have that , , , , , and . As a result, we can apply the Se-Rollback rule also to . Therefore, we have sp_{0}\mathrel{\leavevmode\hbox to71.33pt{\vbox to30.59pt{\pgfpicture\makeatletter\hbox{\hskip 35.66527pt\lower-16.69441pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-33.37083pt}{-12.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}{0}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma{1}(\mathbf{pc})}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{35.06528pt}{-14.09444pt}\pgfsys@lineto{31.96527pt}{-14.09444pt}\pgfsys@lineto{31.1117pt}{-14.79443pt}\pgfsys@lineto{29.40453pt}{-13.39444pt}\pgfsys@lineto{27.69736pt}{-14.79443pt}\pgfsys@lineto{25.99019pt}{-13.39444pt}\pgfsys@lineto{24.28302pt}{-14.79443pt}\pgfsys@lineto{22.57585pt}{-13.39444pt}\pgfsys@lineto{20.86868pt}{-14.79443pt}\pgfsys@lineto{19.16151pt}{-13.39444pt}\pgfsys@lineto{17.45435pt}{-14.79443pt}\pgfsys@lineto{15.74718pt}{-13.39444pt}\pgfsys@lineto{14.04001pt}{-14.79443pt}\pgfsys@lineto{12.33284pt}{-13.39444pt}\pgfsys@lineto{10.62567pt}{-14.79443pt}\pgfsys@lineto{8.9185pt}{-13.39444pt}\pgfsys@lineto{7.21133pt}{-14.79443pt}\pgfsys@lineto{5.50417pt}{-13.39444pt}\pgfsys@lineto{3.797pt}{-14.79443pt}\pgfsys@lineto{2.08983pt}{-13.39444pt}\pgfsys@lineto{0.38266pt}{-14.79443pt}\pgfsys@lineto{-1.32451pt}{-13.39444pt}\pgfsys@lineto{-3.03168pt}{-14.79443pt}\pgfsys@lineto{-4.73885pt}{-13.39444pt}\pgfsys@lineto{-6.44601pt}{-14.79443pt}\pgfsys@lineto{-8.15318pt}{-13.39444pt}\pgfsys@lineto{-9.86035pt}{-14.79443pt}\pgfsys@lineto{-11.56752pt}{-13.39444pt}\pgfsys@lineto{-13.27469pt}{-14.79443pt}\pgfsys@lineto{-14.98186pt}{-13.39444pt}\pgfsys@lineto{-16.68903pt}{-14.79443pt}\pgfsys@lineto{-18.3962pt}{-13.39444pt}\pgfsys@lineto{-20.10336pt}{-14.79443pt}\pgfsys@lineto{-21.81053pt}{-13.39444pt}\pgfsys@lineto{-23.5177pt}{-14.79443pt}\pgfsys@lineto{-25.22487pt}{-13.39444pt}\pgfsys@lineto{-26.93204pt}{-14.79443pt}\pgfsys@lineto{-28.6392pt}{-13.39444pt}\pgfsys@lineto{-30.34637pt}{-14.79443pt}\pgfsys@lineto{-32.05354pt}{-13.39444pt}\pgfsys@lineto{-33.76071pt}{-14.79443pt}\pgfsys@lineto{-35.46527pt}{-14.09444pt}\pgfsys@lineto{-35.46527pt}{-14.09444pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{35.26527pt}{-14.09444pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1} and sp_{0}^{\prime}\mathrel{\leavevmode\hbox to71.33pt{\vbox to31.31pt{\pgfpicture\makeatletter\hbox{\hskip 35.66527pt\lower-17.05551pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-33.37083pt}{-12.3611pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}{0}^{\prime}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma{1}^{\prime}(\mathbf{pc})}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{35.06528pt}{-14.45554pt}\pgfsys@lineto{31.96527pt}{-14.45554pt}\pgfsys@lineto{31.1117pt}{-15.15553pt}\pgfsys@lineto{29.40453pt}{-13.75554pt}\pgfsys@lineto{27.69736pt}{-15.15553pt}\pgfsys@lineto{25.99019pt}{-13.75554pt}\pgfsys@lineto{24.28302pt}{-15.15553pt}\pgfsys@lineto{22.57585pt}{-13.75554pt}\pgfsys@lineto{20.86868pt}{-15.15553pt}\pgfsys@lineto{19.16151pt}{-13.75554pt}\pgfsys@lineto{17.45435pt}{-15.15553pt}\pgfsys@lineto{15.74718pt}{-13.75554pt}\pgfsys@lineto{14.04001pt}{-15.15553pt}\pgfsys@lineto{12.33284pt}{-13.75554pt}\pgfsys@lineto{10.62567pt}{-15.15553pt}\pgfsys@lineto{8.9185pt}{-13.75554pt}\pgfsys@lineto{7.21133pt}{-15.15553pt}\pgfsys@lineto{5.50417pt}{-13.75554pt}\pgfsys@lineto{3.797pt}{-15.15553pt}\pgfsys@lineto{2.08983pt}{-13.75554pt}\pgfsys@lineto{0.38266pt}{-15.15553pt}\pgfsys@lineto{-1.32451pt}{-13.75554pt}\pgfsys@lineto{-3.03168pt}{-15.15553pt}\pgfsys@lineto{-4.73885pt}{-13.75554pt}\pgfsys@lineto{-6.44601pt}{-15.15553pt}\pgfsys@lineto{-8.15318pt}{-13.75554pt}\pgfsys@lineto{-9.86035pt}{-15.15553pt}\pgfsys@lineto{-11.56752pt}{-13.75554pt}\pgfsys@lineto{-13.27469pt}{-15.15553pt}\pgfsys@lineto{-14.98186pt}{-13.75554pt}\pgfsys@lineto{-16.68903pt}{-15.15553pt}\pgfsys@lineto{-18.3962pt}{-13.75554pt}\pgfsys@lineto{-20.10336pt}{-15.15553pt}\pgfsys@lineto{-21.81053pt}{-13.75554pt}\pgfsys@lineto{-23.5177pt}{-15.15553pt}\pgfsys@lineto{-25.22487pt}{-13.75554pt}\pgfsys@lineto{-26.93204pt}{-15.15553pt}\pgfsys@lineto{-28.6392pt}{-13.75554pt}\pgfsys@lineto{-30.34637pt}{-15.15553pt}\pgfsys@lineto{-32.05354pt}{-13.75554pt}\pgfsys@lineto{-33.76071pt}{-15.15553pt}\pgfsys@lineto{-35.46527pt}{-14.45554pt}\pgfsys@lineto{-35.46527pt}{-14.45554pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{35.26527pt}{-14.45554pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{1}^{\prime}.
In the following, we denote by the index of ’s -th speculative state (i.e., the one that we are rolling back) inside its commit-free projection , i.e., the -th speculative state in is the -th state in . Observe that is also the index of ’s -th speculative state, which we are rolling back, inside .
Let be the transaction identifier in the -th speculative state in . From (1), it follows that is also the identifier in the -th speculative state in . According to the always mispredict semantics, there are such that:
[TABLE]
From (1) and (6), we immediately have that , , and . Hence, we pick to be .
We have already shown that (a) and (b) hold. We now show that (c)-(g) hold as well.
- (c):
To show that , we need to show , , and . First, follows from (1) and . Second, follows from (1) (since the configurations in the speculative states in and are pairwise next-step agreeing and no intermediate steps in has modified the state that we are rolling back in the last step). Finally, follows from (1), , and . 2. (d):
To show that , we need to show , , , and . First, immediately follows from , , and (2). Second, follows from (2) (since the configurations in the speculative states are pairwise next-step agreeing). Third, follows from (2), , and . Finally, immediately follows from (2), , and , (from (2)), (since all configurations in the speculative states are pairwise -agreeing), and (since all configurations in the speculative states are pairwise next-step agreeing). 3. (e):
Here we prove only ( can be proved in the same way). To show , we need to show and . From the Se-Rollback rule in , we have that , which is the configuration obtained by executing one step starting from the configuration in the -th speculative state in . From the run , is obtained by applying the Se-Rollback rule in . As a result, is the configuration obtained by executing one step starting from the configuration in -th speculative state in . Observe that, from (3), is exactly the configuration in the -th speculative state in (because the -th state in that we are rolling back is also the -th state in ). Hence, . Moreover, observe that immediately follows from (3), being , . 4. (f):
For simplicity, we show only , the proof for is analogous. To show , we need to show that and for all , .
First, follows from (4), (because we are rolling back the -th transaction in the speculative state and the semantics only modifies the last speculative state), , and (because ’s -th speculative state corresponds to ’s -th state by construction).
We now show that for all , . Let be an arbitrary value such that . Observe that and (since ). From this and (4), we therefore immediately have that . 5. (g):
The observations and are respectively {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}_{0}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma_{1}(\mathbf{pc}) and {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}_{0}^{\prime}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma_{1}^{\prime}(\mathbf{pc}). From (2), we have that which implies . Moreover, we also have that and, therefore, . Hence, .
This completes the proof of this case.
This completes the proof of this case.
This completes the proof of our claim. ∎
H-C Completeness
In Proposition 8, we prove the completeness of the always mispredict semantics w.r.t. the speculative semantics.
Proposition 8**.**
Let be a speculative window and be two initial configurations. If , then there exists a prediction oracle with speculation window at most such that .
Proof.
Let be a speculative window and be two initial configurations such that .
We first analyze the case when the program does not terminate. There are two cases: either or . Consider the first case (the proof for the second case is similar). Since speculative execution does not introduce or prevent non-termination, we have that for all prediction oracles . Hence, there is a prediction oracle with speculative window at most such that .
We now consider the case where both and . From this and , it follows that there are , extended configurations , final extended configurations , and sequences of observations such that , and:
[TABLE]
We claim that there is a prediction oracle with speculative window at most such that (1) \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1} and and , and (2) \langle 0\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}^{\prime} and and , and (3) .
We now proceed by case distinction on the rule in used to derive . Observe that from and , it follows that the only possible rules are Se-NoBranch and Se-Branch (since applying the Se-Rollback rule would lead to ):
- Se-NoBranch:
From the rule, we have that , , and . From , we also have (since ) and (since ). Hence, also is obtained by applying the Se-NoBranch rule. Therefore, .
From our claim, we have (1) \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}, , and , and (2) \langle 0\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}^{\prime} and and . From , , , and , we immediately have , and . Moreover, from , , , and , we also have and . Hence, we can apply to both configurations the Se-NoBranch rule in . As a result, sp_{1}\mathrel{\leavevmode\hbox to14.65pt{\vbox to28.67pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-15.73468pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.04027pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.1347pt}\pgfsys@lineto{3.62378pt}{-13.1347pt}\pgfsys@lineto{2.7702pt}{-13.8347pt}\pgfsys@lineto{1.06303pt}{-12.43471pt}\pgfsys@lineto{-0.64413pt}{-13.8347pt}\pgfsys@lineto{-2.3513pt}{-12.43471pt}\pgfsys@lineto{-4.05847pt}{-13.8347pt}\pgfsys@lineto{-5.76564pt}{-12.43471pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.1347pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2} and sp_{1}^{\prime}\mathrel{\leavevmode\hbox to14.65pt{\vbox to29.78pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-16.29024pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.59583pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.69026pt}\pgfsys@lineto{3.62378pt}{-13.69026pt}\pgfsys@lineto{2.7702pt}{-14.39026pt}\pgfsys@lineto{1.06303pt}{-12.99026pt}\pgfsys@lineto{-0.64413pt}{-14.39026pt}\pgfsys@lineto{-2.3513pt}{-12.99026pt}\pgfsys@lineto{-4.05847pt}{-14.39026pt}\pgfsys@lineto{-5.76564pt}{-12.99026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.69026pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2}^{\prime} where the traces are derived using the non-speculative semantics and . From this, , , and the determinism of the non-speculative semantics, we have that and . This, together with , leads to . Observe also that both and are observations in . Therefore, there are sequences of observations such that and . As a result, .
- Se-Branch:
From the rule, we have that and . From , we also have (since ) and (since ). Hence, also is obtained by applying the Se-Branch rule. Therefore, \tau_{am\mathchar 44\relax 1}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ am_{1}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell and \tau_{am\mathchar 44\relax 1}^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ am_{1}^{\prime}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}, where and . Since (from ) and , we have that either or . Without loss of generality, we assume that (the proof for the other case is analogous).
We now executes two steps starting from and with respect to , and we construct sp_{1}\mathrel{\leavevmode\hbox to14.65pt{\vbox to28.67pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-15.73468pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.04027pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.1347pt}\pgfsys@lineto{3.62378pt}{-13.1347pt}\pgfsys@lineto{2.7702pt}{-13.8347pt}\pgfsys@lineto{1.06303pt}{-12.43471pt}\pgfsys@lineto{-0.64413pt}{-13.8347pt}\pgfsys@lineto{-2.3513pt}{-12.43471pt}\pgfsys@lineto{-4.05847pt}{-13.8347pt}\pgfsys@lineto{-5.76564pt}{-12.43471pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.1347pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2}\mathrel{\leavevmode\hbox to14.65pt{\vbox to28.67pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-15.73468pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.04027pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 2}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.1347pt}\pgfsys@lineto{3.62378pt}{-13.1347pt}\pgfsys@lineto{2.7702pt}{-13.8347pt}\pgfsys@lineto{1.06303pt}{-12.43471pt}\pgfsys@lineto{-0.64413pt}{-13.8347pt}\pgfsys@lineto{-2.3513pt}{-12.43471pt}\pgfsys@lineto{-4.05847pt}{-13.8347pt}\pgfsys@lineto{-5.76564pt}{-12.43471pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.1347pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{3} and sp_{1}^{\prime}\mathrel{\leavevmode\hbox to14.65pt{\vbox to29.78pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-16.29024pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.59583pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.69026pt}\pgfsys@lineto{3.62378pt}{-13.69026pt}\pgfsys@lineto{2.7702pt}{-14.39026pt}\pgfsys@lineto{1.06303pt}{-12.99026pt}\pgfsys@lineto{-0.64413pt}{-14.39026pt}\pgfsys@lineto{-2.3513pt}{-12.99026pt}\pgfsys@lineto{-4.05847pt}{-14.39026pt}\pgfsys@lineto{-5.76564pt}{-12.99026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.69026pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2}^{\prime}\mathrel{\leavevmode\hbox to14.65pt{\vbox to29.78pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-16.29024pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.59583pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 2}^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.69026pt}\pgfsys@lineto{3.62378pt}{-13.69026pt}\pgfsys@lineto{2.7702pt}{-14.39026pt}\pgfsys@lineto{1.06303pt}{-12.99026pt}\pgfsys@lineto{-0.64413pt}{-14.39026pt}\pgfsys@lineto{-2.3513pt}{-12.99026pt}\pgfsys@lineto{-4.05847pt}{-14.39026pt}\pgfsys@lineto{-5.76564pt}{-12.99026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.69026pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{3}^{\prime}. From our claim, we have (1) \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}, , and , and (2) \langle 0\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}^{\prime} and and , and (3) . From , , , and , we immediately have , , , and . Moreover, from , , , and , we also have and . Hence, we can apply to both configurations the Se-Branch rule in . From , , and , we immediately have that . From this, (3), and the way in which we construct (see below), we have that . By applying the Se-Branch rule to we get sp_{1}\mathrel{\leavevmode\hbox to14.65pt{\vbox to28.67pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-15.73468pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.04027pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.1347pt}\pgfsys@lineto{3.62378pt}{-13.1347pt}\pgfsys@lineto{2.7702pt}{-13.8347pt}\pgfsys@lineto{1.06303pt}{-12.43471pt}\pgfsys@lineto{-0.64413pt}{-13.8347pt}\pgfsys@lineto{-2.3513pt}{-12.43471pt}\pgfsys@lineto{-4.05847pt}{-13.8347pt}\pgfsys@lineto{-5.76564pt}{-12.43471pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.1347pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2}, where \tau_{sp\mathchar 44\relax 1}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ sp_{1}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}, , , , and . Similarly, by applying the Se-Branch rule to we get sp_{1}^{\prime}\mathrel{\leavevmode\hbox to14.65pt{\vbox to29.78pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-16.29024pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.59583pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.69026pt}\pgfsys@lineto{3.62378pt}{-13.69026pt}\pgfsys@lineto{2.7702pt}{-14.39026pt}\pgfsys@lineto{1.06303pt}{-12.99026pt}\pgfsys@lineto{-0.64413pt}{-14.39026pt}\pgfsys@lineto{-2.3513pt}{-12.99026pt}\pgfsys@lineto{-4.05847pt}{-14.39026pt}\pgfsys@lineto{-5.76564pt}{-12.99026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.69026pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2}^{\prime}, where \tau_{sp\mathchar 44\relax 1}^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ sp_{1}^{\prime}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}, , , , and . Observe that immediately follows from (3).
Since and , we can commit or rollback the transactions associated with the last speculative states in and (i.e., the transactions we started in the step sp_{1}\mathrel{\leavevmode\hbox to14.65pt{\vbox to28.67pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-15.73468pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.04027pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.1347pt}\pgfsys@lineto{3.62378pt}{-13.1347pt}\pgfsys@lineto{2.7702pt}{-13.8347pt}\pgfsys@lineto{1.06303pt}{-12.43471pt}\pgfsys@lineto{-0.64413pt}{-13.8347pt}\pgfsys@lineto{-2.3513pt}{-12.43471pt}\pgfsys@lineto{-4.05847pt}{-13.8347pt}\pgfsys@lineto{-5.76564pt}{-12.43471pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.1347pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2} and sp_{1}^{\prime}\mathrel{\leavevmode\hbox to14.65pt{\vbox to29.78pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-16.29024pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.59583pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 1}^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.69026pt}\pgfsys@lineto{3.62378pt}{-13.69026pt}\pgfsys@lineto{2.7702pt}{-14.39026pt}\pgfsys@lineto{1.06303pt}{-12.99026pt}\pgfsys@lineto{-0.64413pt}{-14.39026pt}\pgfsys@lineto{-2.3513pt}{-12.99026pt}\pgfsys@lineto{-4.05847pt}{-14.39026pt}\pgfsys@lineto{-5.76564pt}{-12.99026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.69026pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{2}^{\prime}). We start by considering . From and , we have that . From this, , and , the configuration obtained as is such that . Hence, we can apply the Se-Commit rule to and obtain sp_{2}\mathrel{\leavevmode\hbox to14.65pt{\vbox to28.67pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-15.73468pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.04027pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 2}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.1347pt}\pgfsys@lineto{3.62378pt}{-13.1347pt}\pgfsys@lineto{2.7702pt}{-13.8347pt}\pgfsys@lineto{1.06303pt}{-12.43471pt}\pgfsys@lineto{-0.64413pt}{-13.8347pt}\pgfsys@lineto{-2.3513pt}{-12.43471pt}\pgfsys@lineto{-4.05847pt}{-13.8347pt}\pgfsys@lineto{-5.76564pt}{-12.43471pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@lineto{-7.12378pt}{-13.1347pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.1347pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{3}, where \tau_{sp\mathchar 44\relax 2}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{commit}}\ sp_{1}.\mathit{ctr}, , , , and . Consider now . From and , we have that . From this, , and , the configuration obtained as is such that . From this and the well-formedness of , we have that . Hence, we can apply the Se-Rollback rule to and obtain sp_{2}^{\prime}\mathrel{\leavevmode\hbox to14.65pt{\vbox to29.78pt{\pgfpicture\makeatletter\hbox{\hskip 7.32378pt\lower-16.29024pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-5.02934pt}{-11.59583pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\tau_{sp\mathchar 44\relax 2}^{\prime}}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{6.72379pt}{-13.69026pt}\pgfsys@lineto{3.62378pt}{-13.69026pt}\pgfsys@lineto{2.7702pt}{-14.39026pt}\pgfsys@lineto{1.06303pt}{-12.99026pt}\pgfsys@lineto{-0.64413pt}{-14.39026pt}\pgfsys@lineto{-2.3513pt}{-12.99026pt}\pgfsys@lineto{-4.05847pt}{-14.39026pt}\pgfsys@lineto{-5.76564pt}{-12.99026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@lineto{-7.12378pt}{-13.69026pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{6.92378pt}{-13.69026pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}sp_{3}^{\prime}, where \tau_{sp\mathchar 44\relax 2}^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ sp_{1}^{\prime}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma^{\prime}(\mathbf{pc}), , , , and . Therefore, there are sequences of observations such that and , where and . As a result, .
This completes the proof our claim.
Constructing the prediction oracle
Here we prove our claim that there is a prediction oracle with speculative window at most such that (1) \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1} and and , and (2) \langle 0\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}^{\prime} and and , and (3) .
We denote by the set of transaction identifiers that occur . Observe that from and it follows that is also the set of transaction identifiers occurring in . The set identifies which branch instructions we must mispredict to reach the configuration .
We now construct a list of predictions . In the following, we write instead of . We construct the list by analyzing the execution (observe that deriving the list from would result in the same list). The list is iteratively constructed as follows. During the execution, we denote by the position of the configuration in the execution from which we should continue the construction. Initially, . At each iteration, we find the smallest such that and the extended configuration is such that , and and (i.e., the next step in the execution is obtained using the Se-Branch rule). Next, we proceed as follows:
In this case, we mispredict the outcome of the corresponding branch instruction. The prediction associated with the branch instruction is , where if and otherwise. Concretely, we update by appending and setting to (i.e., we continue constructing by analyzing the next step in the execution).
In this case, we correctly predict the outcome of the corresponding branch instruction. The prediction associated with the branch instruction is , where if and otherwise. Concretely, we update by appending and we update the index to where the value is such that am_{0}\xLongrightarrow{\tau_{1}}^{\bm{idx}^{\prime}}am_{\bm{idx}^{\prime}}\xLongrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ am_{\bm{idx}^{\prime}}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}am_{\bm{idx}^{\prime}+1}\xLongrightarrow{\nu}^{k}am_{\bm{idx}^{\prime}+k+1}\xLongrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ am_{\bm{idx}^{\prime}}.\mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}}am_{\bm{idx}^{\prime}+k+2}. That is, we ignore the portion of the execution associated with the speculative transaction and we continue constructing after the transaction has been rolled back. Observe also that (otherwise would have been included into ).
Finally, if the configuration in is such that and , we append to the prediction .
The prediction oracle is defined as follows, where is the number of unique transaction identifiers in :
[TABLE]
Observe that is a prediction oracle as it depends only on the program counter, the program itself, and the length of the history. Moreover, its speculative window is at most (since the predictions contain either or [math] as speculative window). The key property of is that “when the execution starts from (or ), follows the predictions in for the first branch instructions and afterwards always predicts the branch as taken”.
From , , and the way in which we constructed , we have that (1) \langle 0\mathchar 44\relax\sigma\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1} and and , and (2) \langle 0\mathchar 44\relax\sigma^{\prime}\mathchar 44\relax\varepsilon\mathchar 44\relax\varepsilon\rangle\mathrel{\leavevmode\hbox to8.05pt{\vbox to26.6pt{\pgfpicture\makeatletter\hbox{\hskip 4.02336pt\lower-14.70135pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-1.72893pt}{-10.00694pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\nu}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{3.42337pt}{-12.10138pt}\pgfsys@lineto{0.32336pt}{-12.10138pt}\pgfsys@lineto{-0.53021pt}{-12.80138pt}\pgfsys@lineto{-2.23738pt}{-11.40138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@lineto{-3.82336pt}{-12.10138pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{3.62337pt}{-12.10138pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{*}sp_{1}^{\prime} and and , and (3) . The proof of this statement is similar to the proof of Lemma 6. ∎
Appendix I Relating concrete and symbolic always mispredict semantics (Proposition 2)
Below, we provide the proof of Proposition 2, which we restate here for simplicity:
See 2
Proof.
The proposition follows from Propositions 9 (proved in Section I-C) and 10 (proved in Section I-D).
We now prove the two directions:
Let be a run in . From this, it follows that . From Proposition 10 (proved in Section I-D), there is a valuation , a symbolic trace , and a final symbolic configuration such that , , , , and . Hence, and (since ). Therefore, . From this and , , , we have .
Let be a run in . From this, it follows that there is a symbolic run and a valuation such that and , , and . From , we have that . From Proposition 9 (proved in Section I-C) and , we have that . Therefore, . From this and , , and , we have .
This completes the proof of our claim. ∎
I-A Auxiliary definitions
Given a symbolic speculative state , its next-step mispredict path condition is the symbolic expression such that and (if such a does not exists, then ). Given a sequence of symbolic speculative states , its next-step mispredict path condition .
We say that a concrete speculative state is next-step mispredict well-formed, written , if and . We say that a sequence of speculative states is next-step mispredict well-formed, written , if .
I-B Auxiliary lemmas
Lemma 7 provides some useful helping facts, which we will use throughout the soundness proof.
Lemma 7**.**
The following facts hold:
Given a symbolic assignment and a valuation , then for all . 2. 2.
Given a symbolic memory and a valuation , then for all . 3. 3.
Given a symbolic assignment , an expression , and a valuation , then .
Proof.
Below we prove all our claims.
Proof of (1)
Let be a symbolic assignment and . Then, is defined as . Hence, .
Proof of (2)
Identical to (1).
Proof of (3)
Let be a symbolic assignment, be an expression, and . We show, by structural induction on , that . For the base case, there are two possibilities. If is a value , then , , and . Hence, . If is a register identifier , then and . From this and (1), we get . For the induction step, there two cases. If is of the form , then , whereas is either if or otherwise. In the first case, (since we are dealing only with concrete values) and since . Therefore, . In the second case, . By applying the induction hypothesis (), we obtain . Hence, . The proof for the second case (i.e., ) is similar. ∎
I-C Soundness
In Lemma 8, we prove the soundness of the symbolic non-speculative semantics.
Lemma 8**.**
Let be a program. Whenever , then for all mappings such that , .
Proof.
Let be a program. Assume that holds. We proceed by case distinction on the rules defining .
- Rule Skip.
Assume that has been derived using the Skip rule in the symbolic semantics. Then, , , , and . Let be an arbitrary valuation satisfying (since is all valuations are models of ). Observe that since the program counter is always concrete. Hence, . Thus, we can apply the rule Skip of the concrete semantics starting from . Hence, . From this, (since ), and , we have that .
- Rule Barrier.
The proof of this case is analogous to that of Skip.
- Rule Assign.
Assume that has been derived using the Assign rule in the symbolic semantics. Then, , , , , and . Let be an arbitrary valuation (since is all valuations are models of ). Observe that since the program counter is always concrete. Hence, . Thus, we can apply the rule Assign of the concrete semantics starting from . Hence, . From this, Lemma 7, (since ), and , we have that .
- Rule ConditionalUpdate-Concr-Sat.
Assume that has been derived using the ConditionalUpdate-Concr-Sat rule in the symbolic semantics. Then, , , , , , and . Let be an arbitrary valuation (since is all valuations are models of ). Observe that since the program counter is always concrete. Hence, . Thus, we can apply one of the rules ConditionalUpdate-Sat or ConditionalUpdate-Unsat of the concrete semantics starting from . We claim that . Therefore, we can apply the rule ConditionalUpdate-Sat. Hence, . From this, Lemma 7, (since ), and , we have that .
We now show that is indeed [math]. Since , the value of depends only on registers in whose value is concrete. Hence, for all these registers , . Thus, .
- Rule ConditionalUpdate-Concr-Unsat.
The proof of this case is analogous to that of ConditionalUpdate-Concr-Unsat.
- Rule ConditionalUpdate-Symb.
Assume that has been derived using the ConditionalUpdate-Symb rule in the symbolic semantics. Then, , , , , , , and . Let be an arbitrary valuation (since is all valuations are models of ). Observe that since the program counter is always concrete. Hence, .
There are two cases:
- :
Then, and therefore . Hence, we can apply the rule ConditionalUpdate-Sat starting from . Therefore, we get . To prove our claim, we have to show that . From , it is enough to show that . Since , is equivalent to . From this and Lemma 7, . Hence, we have that .
- :
Then, and therefore . Hence, we can apply the rule ConditionalUpdate-Unsat starting from . Therefore, we get . To prove our claim, we have to show that . From , it is enough to show that . Since , is equivalent to . From this and Lemma 7, . Hence, we have that .
This completes the proof of this case.
- Rule Load-Symb.
Assume that has been derived using the Load-Symb rule in the symbolic semantics. Then, , , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ se, and . Let be an arbitrary valuation (since all valuations are valid models). Observe that since the program counter is always concrete. Hence, and . Thus, we can apply the rule Load of the concrete semantics starting from . Hence, \langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(\mu(sa))}\langle\mu(sm)\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\mu(sa)(\mathbf{pc})+1\mathchar 44\relax x\mapsto\mu(sm)(\llbracket e\rrbracket(\mu(sa)))]\rangle.
Observe that (from Lemma 7), and therefore \mu({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(sa))={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(\mu(sa)). We claim that . From this, . Therefore, .
We now show that . From the evaluation of symbolic expressions, we have that is equivalent to . From this and , we have . From this and Lemma 7, we get .
- Rule Store-Symb.
Assume that has been derived using the Store-Symb rule in the symbolic semantics. Then, , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ se, and . Let be an arbitrary valuation (since all valuations are valid models). Observe that since the program counter is always concrete. Hence, . Thus, we can apply the rule Store of the concrete semantics starting from . Hence, \langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(\mu(sa))}\langle\mu(sm)[\llbracket e\rrbracket(\mu(sa))\mapsto\mu(sa)(x)]\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\mu(sa)(\mathbf{pc})+1]\rangle. Observe that (1) (from Lemma 7) and therefore \mu({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(sa))={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(\mu(sa)), and (2) . Moreover, we claim that . Therefore, .
We now prove our claim that . From the evaluation of symbolic expressions, we have that is equivalent to . From , we have . From Lemma 7, we have .
- Rule Beqz-Concr-Sat.
Assume that has been derived using the Beqz-Concr-1 rule in the symbolic semantics. Then, , , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, and . Let be an arbitrary valuation (since all valuations are valid models). Observe that since the program counter is always concrete. Hence, . Thus, we can apply one of the rules Beqz-Sat or Beqz-Unsat of the concrete semantics starting from . We claim that . Therefore, we can apply the Beqz-Sat rule. Hence, \langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle\mu(sm)\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\ell]\rangle. Therefore, (since \mu(\tau)=\mu({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell)={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell).
We now prove our claim that . We know that . Hence, (since is a concrete value). From this and Lemma 7, .
- Rule Beqz-Symb-Sat.
Assume that has been derived using the Beqz-Symb-Sat rule in the symbolic semantics. Then, , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(sa(x)=0)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, and . Let be an arbitrary valuation satisfying . Observe that since the program counter is always concrete. Hence, . Thus, we can apply one of the rules Beqz-Sat or Beqz-Unsat of the concrete semantics starting from . We claim that . Therefore, we can apply the Beqz-Sat rule. Hence, \langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle\mu(sm)\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\ell]\rangle. Therefore, (since \mu(\tau)=\mu({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(sa(x)=0)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell)={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell).
We now prove our claim that . We know that and . Hence, . Therefore, . From this and Lemma 7, we have .
- Rule Beqz-Concr-Unsat.
The proof of this case is similar to that of the Beqz-Concr-Sat rule.
- Rule Beqz-Symb-Unsat.
The proof of this case is similar to that of the Beqz-Symb-Sat rule.
- Rule Jmp-Concr.
Assume that has been derived using the Jmp-Concr rule in the symbolic semantics. Then, , , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, and . Let be an arbitrary valuation (since all valuations are valid models). Observe that since the program counter is always concrete. Hence, . Thus, we can apply the Jmp rule of the concrete semantics starting from . Observe that . Hence, \langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle\mu(sm)\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\ell]\rangle. Therefore, (since \mu(\tau)=\mu({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell)={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell).
- Rule Jmp-Symb.
Assume that has been derived using the Jmp-Symb rule in the symbolic semantics. Then, , , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\llbracket e\rrbracket(sa)=\ell)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, and . Let be an arbitrary valuation satisfying , that is, . Observe that since the program counter is always concrete. Hence, . Thus, we can apply the Jmp rule of the concrete semantics starting from . We claim . Hence, \langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell}\langle\mu(sm)\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\ell]\rangle. Therefore, (since \mu(\tau)=\mu({\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\llbracket e\rrbracket(sa)=\ell)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell)={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell).
We now prove our claim that . We know that and . Hence, . From this and Lemma 7, we have .
- Rule Terminate.
The proof of this case is similar to that of the Skip rule.
This completes the proof of our claim. ∎
In Lemma 9, we prove the soundness of a single step of the symbolic always mispredict semantics.
Lemma 9**.**
Let be a program. Whenever , then for all mappings such that , .
Proof.
Let be a program. Moreover, assume that . We proceed by case distinction on the rules defining .
- Rule Am-NoBranch.
Assume that has been derived using the Se-NoBranch rule in the symbolic semantics. Then, , , , , and . Let be an arbitrary valuation that satisfies . Observe that also satisfies . Therefore, we can apply Lemma 8 to to derive . Moreover, we immediately have that iff and , iff ,. Thus, we can apply the rule Am-NoBranch of the concrete semantics starting from . Therefore, .
- Rule Am-Branch.
Assume that has been derived using the Se-Branch rule in the symbolic semantics. Then, , , \langle sm\mathchar 44\relax sa\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime}, , , , , , and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell. Let be an arbitrary valuation satisfying . Observe that also satisfies , i.e., . We can apply Lemma 8 to \langle sm\mathchar 44\relax sa\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime} to derive . Observe that and holds iff does. Therefore, we can apply the rule Am-Branch of the concrete semantics starting from . We have \langle\mathit{ctr}\mathchar 44\relax\langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\mathchar 44\relax\mu(s)\rangle\xLongrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime\prime}}\langle\mathit{ctr}+1\mathchar 44\relax\langle\mu(sm)\mathchar 44\relax\mu(sa)[\mathbf{pc}\mapsto\ell^{\prime\prime\prime}]\rangle\mathchar 44\relax\mu(s)\cdot\langle\langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\mathchar 44\relax\mathit{ctr}\mathchar 44\relax\mathit{min}(w\mathchar 44\relax\mathit{wndw}(\mu(s))-1)\mathchar 44\relax\ell^{\prime\prime\prime}\rangle\rangle. We claim that . Hence, .
We now show that . There are two cases:
Then, . There are two cases:
The step \langle sm\mathchar 44\relax sa\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime} has been derived using the Beqz-Concr-Sat rule from the symbolic non-speculative semantics. Then, . Therefore, and by construction. Hence, .
- *
The step \langle sm\mathchar 44\relax sa\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime} has been derived using the Beqz-Symb-Sat rule from the symbolic non-speculative semantics. Then, is . From this and , we have that and, therefore, by construction. Hence, .
This completes the proof of this case.
Then, . There are two cases:
The step \langle sm\mathchar 44\relax sa\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime} has been derived using the Beqz-Concr-Unsat rule from the symbolic non-speculative semantics. Then, . Therefore, and by construction. Hence, .
- *
The step \langle sm\mathchar 44\relax sa\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime} has been derived using the Beqz-Symb-Unsat rule from the symbolic non-speculative semantics. Then, is . From this and , we have that and, therefore, by construction. Hence, .
This completes the proof of this case.
This completes the proof of our claim.
- Rule Am-Rollback.
Assume that has been derived using the Se-Rollback rule in the symbolic semantics. Then, , , , , , , and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma^{\prime}(\mathbf{pc}). Let be an arbitrary valuation satisfying . We claim that . Therefore, Lemma 8 to to derive . By applying the rule Am-Rollback of the concrete semantics starting from , we obtain \langle\mathit{ctr}\mathchar 44\relax\langle\mu(sm)\mathchar 44\relax\mu(sa)\rangle\mathchar 44\relax\mu(s_{B})\cdot\langle\sigma\mathchar 44\relax\mathit{id}\mathchar 44\relax 0\mathchar 44\relax\ell\rangle\rangle\xLongrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \sigma^{\prime}(\mathbf{pc})}\langle\mathit{ctr}\mathchar 44\relax\mu(\sigma^{\prime})\mathchar 44\relax\mu(s_{B})\rangle. Since (since the program counter is always concrete), we have that .
We now prove our claim that . There are four cases:
- –
The step has been derived using the Beqz-Concr-Sat rule from the symbolic non-speculative semantics. Then, and the claim trivially holds.
- –
The step has been derived using the Beqz-Concr-Unsat rule from the symbolic non-speculative semantics. Then, and the claim trivially holds.
- –
The step has been derived using the Beqz-Symb-Sat rule from the symbolic non-speculative semantics. Then, is . Observe that is one of the conjuncts of by construction. Therefore, since .
- –
The step has been derived using the Beqz-Symb-Unsat rule from the symbolic non-speculative semantics. Then, is . Observe that is one of the conjuncts of by construction. Therefore, since .
This completes the proof of our claim.
This completes the proof of our claim. ∎
In Proposition 9, we finally prove the soundness of the symbolic semantics.
Proposition 9**.**
Let be a program and be a valuation. Whenever , , and , then .
Proof.
Let be a program and be a valuation. Assume that, for some , , where , , and . Finally, assume that . We claim that, for all , . We can obtain the concrete execution \langle\mathit{ctr}_{0}\mathchar 44\relax\langle\mu(sm_{0})\mathchar 44\relax\mu(sa_{0})\rangle\mathchar 44\relax\mu(s_{0})\rangle\mathrel{\leavevmode\hbox to45.36pt{\vbox to30.59pt{\pgfpicture\makeatletter\hbox{\hskip 22.68pt\lower-16.69441pt\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ }\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\pgfsys@setlinewidth{0.4pt}\pgfsys@invoke{ }\nullfont\hbox to0.0pt{\pgfsys@beginscope\pgfsys@invoke{ } {{}}\hbox{\hbox{{\pgfsys@beginscope\pgfsys@invoke{ }{{}{}{{ {}{}}}{ {}{}} {{}{{}}}{{}{}}{}{{}{}} { }{{{{}}\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{-20.38556pt}{-12.0pt}\pgfsys@invoke{ }\hbox{{\definecolor{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@rgb@stroke{0}{0}{0}\pgfsys@invoke{ }\pgfsys@color@rgb@fill{0}{0}{0}\pgfsys@invoke{ }\hbox{{\vbox{\halign{\hfil#\hfil\cr\cr\vskip 17.0pt\cr\hbox{{\scriptstyle\mu(\tau_{0}\cdot\tau_{1}\cdot\ldots\cdot\tau_{n})}}\cr}}}} }}\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}} { {}}{}{{}}{}{{}} {}{} {}{{}{}}{}{}{}{{}}{{}}{{}{}}{{}{}} {{{{}{}{{}} }}{{}} }{{{{}{}{{}} }}{{}}}{{{{}{}{{}} }}{{}}{{}}} {{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {} }{{{{}{}{{}} }}{{}} {{}} } {{{{}{}{{}} }}{{}}{{}}} {}{}{}{}{{}}\pgfsys@moveto{22.08pt}{-14.09444pt}\pgfsys@lineto{18.98pt}{-14.09444pt}\pgfsys@lineto{18.12642pt}{-14.79443pt}\pgfsys@lineto{16.41925pt}{-13.39444pt}\pgfsys@lineto{14.71208pt}{-14.79443pt}\pgfsys@lineto{13.00491pt}{-13.39444pt}\pgfsys@lineto{11.29774pt}{-14.79443pt}\pgfsys@lineto{9.59058pt}{-13.39444pt}\pgfsys@lineto{7.8834pt}{-14.79443pt}\pgfsys@lineto{6.17624pt}{-13.39444pt}\pgfsys@lineto{4.46907pt}{-14.79443pt}\pgfsys@lineto{2.7619pt}{-13.39444pt}\pgfsys@lineto{1.05473pt}{-14.79443pt}\pgfsys@lineto{-0.65244pt}{-13.39444pt}\pgfsys@lineto{-2.3596pt}{-14.79443pt}\pgfsys@lineto{-4.06677pt}{-13.39444pt}\pgfsys@lineto{-5.77394pt}{-14.79443pt}\pgfsys@lineto{-7.48111pt}{-13.39444pt}\pgfsys@lineto{-9.18828pt}{-14.79443pt}\pgfsys@lineto{-10.89545pt}{-13.39444pt}\pgfsys@lineto{-12.60262pt}{-14.79443pt}\pgfsys@lineto{-14.30978pt}{-13.39444pt}\pgfsys@lineto{-16.01695pt}{-14.79443pt}\pgfsys@lineto{-17.72412pt}{-13.39444pt}\pgfsys@lineto{-19.43129pt}{-14.79443pt}\pgfsys@lineto{-21.13846pt}{-13.39444pt}\pgfsys@lineto{-22.48pt}{-14.09444pt}\pgfsys@lineto{-22.48pt}{-14.09444pt}\pgfsys@stroke\pgfsys@invoke{ }{{}{{}}{}{}{{}}{{{}}{{{}}{\pgfsys@beginscope\pgfsys@invoke{ }\pgfsys@transformcm{1.0}{0.0}{0.0}{1.0}{22.28pt}{-14.09444pt}\pgfsys@invoke{ }\pgfsys@invoke{ \lxSVG@closescope }\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope}}{{}}}} \pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope{{ {}{}{}{}{}}}{}{}\hss}\pgfsys@discardpath\pgfsys@invoke{\lxSVG@closescope }\pgfsys@endscope\hss}}\lxSVG@closescope\endpgfpicture}}}^{n}\langle\mathit{ctr}_{n+1}\mathchar 44\relax\langle\mu(sm_{n+1})\mathchar 44\relax\mu(sa_{n+1})\rangle\mathchar 44\relax\mu(s_{n+1})\rangle by repeatedly applying Lemma 9 (since for all , ).
We now show that for all , . We prove this by induction. For the base case of , the claim trivially holds since and therefore . For the induction step, assume that the claim holds for all . We now show that it holds for as well. There are three cases:
- •
The -th configuration has been derived using the Se-NoBranch rule. Then, and only differ in the length of the remaining speculation windows. Therefore, . From the induction hypothesis, . Therefore, .
- •
The -th configuration has been derived using the Se-Branch rule. Then, , where , \langle sm_{i-1}\mathchar 44\relax sa_{i-1}\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}_{\mathit{s}}\sigma^{\prime}, , and . From this, it follows that . From this, , and , we have that . Moreover, from , , and the induction hypothesis, we have .
- •
The -th configuration has been derived using the Se-Rollback rule. Then, for some , , and . Therefore, for some . From the induction hypothesis, . From this and for some , we have .
This completes the proof of our claim. ∎
I-D Completeness
In Lemma 10, we prove the completeness of the non-speculative symbolic semantics.
Lemma 10**.**
Let be a program, be a symbolic assignment, and be a symbolic memory. Whenever , then for all assignments such that and , then there exist such that , , , , and .
Proof.
Let be a program, be a symbolic assignment, and be a symbolic memory. Moreover, assume that holds. Finally, let be an arbitrary assignment such that and . We proceed by case distinction on the rules defining .
- Rule Skip.
Assume that has been derived using the Skip rule in the concrete semantics. Then, , , , and . From , , and being always concrete, we have that . Thus, we can apply the rule Skip of the symbolic semantics starting from . Hence, , where , , , and . From , , and , we have that . From Lemma 7, , , and , we have that . From and , we have that . Finally, from , we have that .
- Rule Barrier.
The proof of this case is similar to that of Rule Skip.
- Rule Assign.
Assume that has been derived using the Assign rule in the concrete semantics. Then, , , , , and . From , , and being always concrete, we have that . Thus, we can apply the rule Assign of the symbolic semantics starting from . Hence, , where , , and . From , , and , we have that . From Lemma 7, , , and , we have that . From and , we have that . Finally, from , we have that .
- Rule ConditionalUpdate-Sat.
Assume that has been derived using the ConditionalUpdate-Sat rule in the concrete semantics. Then, , , , , , and . From , , and being always concrete, we have that . There are two cases:
We claim that . Therefore, we can apply the rule ConditionalUpdate-Concr-Sat of the symbolic semantics starting from . Hence, , where , , and . From , , and , we have that . From Lemma 7, , , and , we have that . From and , we have that . Finally, from , we have that .
We now show that . From , it follows that all variables defining have concrete values in . From this and , we have that all these variables agree in and . Hence, .
We can apply the rule ConditionalUpdate-Symb of the symbolic semantics starting from . Hence, , where , , and . From , , and , we have that . From and , we have that . Finally, from , we have that . Finally, to show that , we need to show that is equivalent to . From the evaluation of symbolic expressions, is if , i.e., if , and otherwise. We now show that , from this we immediately get that . From Lemma 7, we have . From this and , we have . From this and , we finally get .
This concludes the proof of this case.
- Rule ConditionalUpdate-Unsat.
The proof of this case is similar to that of Rule ConditionalUpdate-Sat.
- Rule Load.
Assume that has been derived using the Load rule in the concrete semantics. Then, , , , , and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(a). From , , and being always concrete, we have that . We proceed by applying the Load-Symb rule of the symbolic semantics starting from . Hence, , where , , \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ se, , and . We claim that . From , , and , we have that . From , , and , we have that (by relying on , , our claim that , and Lemma 7). From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(a) and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(sa), we have that \mu(\tau^{\prime})={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \mu(\llbracket e\rrbracket(sa))={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(\mu(sa))={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{load}}\ \llbracket e\rrbracket(a)=\tau (by applying Lemma 7 and relying on ). Finally, from , we have that .
We now prove our claim that . From , we have that (from the evaluation of symbolic expressions). From this and , we have that . From , (from and Lemma 7). Therefore, .
- Rule Store.
Assume that has been derived using the Store rule in the concrete semantics. Then, , , , and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(a). From , , and being always concrete, we have that . We proceed by applying the Store-Symb rule of the symbolic semantics starting from . Hence, , where , \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ se, , and . For showing that , we proceed as follows. From the evaluation of symbolic expressions, . From this, , , and Lemma 7, we have . From this, , , and Lemma 7, we have . Therefore, . Since , we proved that . From and , we have that (by relying on and Lemma 7). From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(a) and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(sa), we have that \mu(\tau^{\prime})={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \mu(\llbracket e\rrbracket(sa))={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(\mu(sa))={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{store}}\ \llbracket e\rrbracket(a)=\tau (by applying Lemma 7 and relying on ). Finally, from , we have .
We now prove our claim that . From , we have that . Hence, (by relying on the semantics of ). From this and , we have that . By applying Lemma 7, we have . From this, , and , we have .
- Rule Beqz-Sat.
Assume that has been derived using the Beqz-Sat rule in the concrete semantics. Then, , , , , and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell. From , , and being always concrete, we have that . There are two cases:
- –
Assume that . From and , we have that . Hence, we proceed by applying the Beqz-Concr-Sat rule of the symbolic semantics starting from . Hence, , where \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, , and . From , , and , we have that . From and , we have that (by relying on and Lemma 7). From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, we have that . Finally, from , we have that .
- –
Assume that and let . We proceed by applying the Beqz-Symb-Sat rule of the symbolic semantics starting from . Hence, , where \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(sa(x)=0)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, , and . From , , and , we have that . From and , we have that (by relying on and Lemma 7). From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(sa(x)=0)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, we have that . We now show that . Since is , we need to show that . From Lemma 7, . From this and , . Therefore, since . Hence, , i.e., .
- Rule Beqz-Unsat.
The proof of this case is similar to that of Rule Beqz-Unsat.
- Rule Jmp.
Assume that has been derived using the Jmp rule in the concrete semantics. Then, , , , , and \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell. From , , and being always concrete, we have that . There are two cases:
- –
Assume that . We proceed by applying the Jmp-Concr rule of the symbolic semantics starting from . Hence, , where , \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}, , and . Observe that (since and ). From , , and , we have that . From , , and , we have that (by relying on and Lemma 7). From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\top)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}, and , we have that . Finally, from , we have that .
- –
Assume that and let . We proceed by applying the Jmp-Symb rule of the symbolic semantics starting from , where we pick as target label. Hence, , where \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\llbracket e\rrbracket(sa)=\ell)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, , and . From , , and , we have that . From and , we have that (by relying on and Lemma 7). From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\llbracket e\rrbracket(sa)=\ell)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, we have that . We now show that . Since is , we need to show that . From Lemma 7, . From this and , . Therefore, since . Hence, , i.e., .
- Rule Terminate.
The proof of this case is similar to that of Rule Skip.
This completes the proof of our claim. ∎
In Lemma 11, we prove the completeness of one step of the symbolic semantics.
Lemma 11**.**
Let be a program, be a symbolic assignment, be a symbolic memory, and be a sequence of symbolic speculative states. Whenever and , then for all valuations such that , , and , then there are such that , , , , , and .
Proof.
Let be a program, be a symbolic assignment, be a symbolic memory, be a symbolic speculative state. Moreover, assume that holds and . Finally, let be an arbitrary valuation such that , , and . We proceed by case distinction on the rules defining .
- Rule Am-NoBranch.
Assume that has been derived using the Se-NoBranch rule in the concrete semantics. Then, , , , , and . Observe that , and immediately follow from and respectively. We can apply Lemma 10 to . Therefore, for all valuation such that and , there are such that , , , , and . Since is a valuation for which and , we therefore have that , , , , and . Hence, we can apply the Am-NoBranch rule in the symbolic semantics to . Thus, , where . We have already established that , , and , and (which all follow from the application of Lemma 10). We still have to show . This immediately follows from , , , and .
- Rule Am-Branch.
Assume that has been derived using the Se-Branch rule in the concrete semantics. Then, , , , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, , , , and . Observe that directly follows from and and follows from being always concrete and . Observe also that \langle m\mathchar 44\relax a\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}}\langle m\mathchar 44\relax a[\mathbf{pc}\mapsto\ell^{\prime\prime}]\rangle holds where . We can apply Lemma 10 to \langle m\mathchar 44\relax a\rangle\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}}\langle m\mathchar 44\relax a[\mathbf{pc}\mapsto\ell^{\prime\prime}]\rangle. Therefore, for all valuations such that and , , , , \mu(\tau^{\prime})={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}, and . Since and , we thus have that , , , \mu(\tau^{\prime\prime})={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}, and . Observe that, since , is of the form {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}. Therefore, we can apply the Am-Branch-Symb rule in the symbolic semantics to to derive , where \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime\prime}, , , , , and . We claim that . From and , we get that . From , , , and , we have that . From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{ctr}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell, \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime\prime}, and , we have . From , , , , , and , we have . Finally, immediately follows from \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{start}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime\prime}, \tau^{\prime\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(se)\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime\prime}, and .
We now prove our claim that . There are two cases:
Then, . Therefore, . From this and ’s well-formedness, it follows that (since we consider only Asm programs such that and ). Hence, . From this and , we have that .
Then, . Therefore, . From this and ’s well-formedness, . Hence, .
- Rule Am-Rollback.
Assume that has been derived using the Am-Rollback rule in the concrete semantics. Then, , \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ a^{\prime}(\mathbf{pc}), , , , , and . From and , it follows that and and . Since and , we can apply Lemma 10 to . We, therefore, obtain that there are such that , , , , and . We claim that . Hence, we can apply the Am-Rollback rule in the symbolic semantics to . Thus, , where , , , and . From and , we have . From , , and , we have . From , , and , we have . From \tau={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ a^{\prime}(\mathbf{pc}) and \tau^{\prime}={\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{rollback}}\ \mathit{id}\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ sa^{\prime}(\mathbf{pc}), we have and . Finally, from and , we have (thanks to ) and (thanks to .
We now prove our claim that . From , , and , we immediately have that . From this and , we have .
This completes the proof of our claim. ∎
In Proposition 10 we finally prove the completeness of our symbolic semantics.
Proposition 10**.**
Let be a program. Whenever , , and , then there is a valuation , a symbolic trace , and a final symbolic configuration such that , , , , and .
Proof.
Let be a program and be a concrete execution, where , , , and . We claim that holds for all . Furthermore, let be a valuation such that . We can construct the symbolic execution by repeatedly applying Lemma 11. From the same Lemma, we also obtain that , , , and .
We prove by induction that holds for all . For the base case , and holds trivially. For the induction step, we assume that holds for all and we show that it holds also for . There are three cases:
- •
The -th configuration has been derived using the Am-NoBranch rule. Then, and only differ in the length of the remaining speculation windows. Therefore, holds iff does. From the induction hypothesis, holds and therefore holds.
- •
The -th configuration has been derived using the Am-Branch rule. Then, , where , \sigma_{i-1}\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}\sigma^{\prime}, and . From this, holds iff both and hold. The former follows from the induction hypothesis, the latter follows from \sigma_{i-1}\xrightarrow{{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ \ell^{\prime}}\sigma^{\prime} and .
- •
The -th configuration has been derived using the Am-Rollback rule. Then, for some , , and , i.e., if holds, then holds as well. From the induction hypothesis, holds and, thus, holds.
This completes the proof of our claim.
∎
Appendix J Spectector’s soundness and completeness (Theorem 2)
Below, we provide the proof of Theorem 2, which we restate here for simplicity: See 2
Proof.
Theorem 2 immediately follows from Spectector’s soundness (see Lemma 12) and completeness (see Lemma 13). ∎
Lemma 12 states that if Spectector determines a program to be secure, the program is speculatively non-interferent.
Lemma 12**.**
Whenever , the program satisfies speculative non-interference w.r.t. the policy and any oracle with speculative window at most .
Proof.
If , then for all symbolic traces , and . Let and be two arbitrary -indistinguishable initial configurations producing the same concrete non-speculative trace . From Proposition 3, and result in two concrete speculative traces and with the same non-speculative projection. From Propositions 2, and correspond to two symbolic traces and . Since , , and , speculatively executed control-flow instructions produce the same outcome in and . Hence, the same code is executed in both traces and . From , the observations produced by speculatively executed and instructions are the same. Thus, . Hence, whenever two initial configurations result in the same non-speculative traces, then they produce the same speculative traces. Therefore, satisfies speculative non-interference w.r.t. the always-mispredict semantics with speculative window . From this and Theorem 1, satisfies speculative non-interference w.r.t. any prediction oracle with speculative window at most . ∎
Lemma 13 states that the leaks found by Spectector are valid counterexamples to speculative non-interference.
Lemma 13**.**
Whenever , there is an oracle with speculative window at most such that program does not satisfy speculative non-interference w.r.t. and the policy .
Proof.
If , there is a symbolic trace for which either or . In the first case, is satisfiable. Then, there are two models for the symbolic trace that (1) satisfy the path condition encoded in , (2) agree on the non-sensitive registers and memory locations in , (3) produce the same non-speculative projection, and (4) the speculative projections differ on a or observation. From Proposition 2, the two concretizations correspond to two concrete runs, with different traces, whose non-speculative projection are the same. By combining this with Proposition 3, there are two configurations that produce the same non-speculative trace but different speculative traces. This is a violation of speculative non-interference.
In the second case, there is a prefix \nu\cdot{\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{symPc}}(\mathit{se}) of such that is satisfiable. Hence, there are two symbolic traces and that produce the same non-speculative observations but differ on a program counter observation {\color[rgb]{0,0,0.8046875}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0.8046875}\mathtt{pc}}\ n in their speculative projections. Again, this implies, through Propositions 2 and 3, that there are two -indistinguishable initial configurations producing the same non-speculative traces but distinct speculative traces, leading to a violation of speculative non-interference.
In both cases, does not satisfy speculative non-interference w.r.t. the always-mispredict semantics with speculative window . From this and Theorem 1, there is a prediction oracle with speculative window at most such that does not satisfy speculative non-interference w.r.t. . ∎
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] G. Maisuradze and C. Rossow, “Ret 2Spec: Speculative Execution Using Return Stack Buffers,” in Proceedings of the 25th ACM SIGSAC Conference on Computer and Communications Security , ser. CCS ’18. ACM, 2018.
- 2[2] P. Kocher, J. Horn, A. Fogh, D. Genkin, D. Gruss, W. Haas, M. Hamburg, M. Lipp, S. Mangard, T. Prescher, M. Schwarz, and Y. Yarom, “Spectre Attacks: Exploiting Speculative Execution,” in Proceedings of the 40th IEEE Symposium on Security and Privacy , ser. S&P ’19. IEEE, 2019.
- 3[3] M. Schwarz, M. Schwarzl, M. Lipp, and D. Gruss, “Netspectre: Read arbitrary memory over network,” Co RR , vol. abs/1807.10535, 2018.
- 4[4] E. M. Koruyeh, K. N. Khasawneh, C. Song, and N. Abu-Ghazaleh, “Spectre returns! speculation attacks using the return stack buffer,” in Proceedings of the 12th USENIX Workshop on Offensive Technologies , ser. WOOT ’18. USENIX Association, 2018.
- 5[5] V. Kiriansky and C. Waldspurger, “Speculative Buffer Overflows: Attacks and Defenses,” Co RR , vol. abs/1807.03757, 2018.
- 6[6] Intel, “Intel Analysis of Speculative Execution Side Channels,” https://software.intel.com/sites/default/files/managed/b 9/f 9/336983-Intel-Analysis-of-Speculative-Execution-Side-Channels-White-Paper.pdf , 2018.
- 7[7] F. Pizlo, “What Spectre and Meltdown mean for Web Kit,” https://webkit.org/blog/8048/what-spectre-and-meltdown-mean-for-webkit/ , 2018.
- 8[8] C. Carruth, “Speculative load hardening,” https://llvm.org/docs/Speculative Load Hardening.html , 2018.