Towards Causal-Consistent Reversibility of Imperative Concurrent Programs

Abstract

We describe an ongoing work of defining and implementing a form of reversibility of concurrent programs where causally independent steps can be undone out of backtracking order. We introduce a notion of causal independence between steps of reverse execution and adjust the previously developed method for backtracking reversibility to move towards obtaining causal-consistent reversibility.

Appendices

A Causally Independent Interleavings

The backtracking reversal execution sequence from Example 2 is shown in Fig. 2 as the path from IP$_{11}$ via IP$_{8}^{18}$ and IP$_{7}$, then all the way down to IP$_{2}$ before finishing at IP$_{0}^{14}$. The alternative reversal shown in Example 4 is the path described above but with the detour from IP$_{4}^{16}$ to IP$_{1}$. As seen from the rest of the diagram, any full path is a valid execution that can be gotten from the main execution by changing order of causally independent transitions.

There are many possible executions of the forward program from Example 1. For each such execution, there is a particular inverted program which will have a backtracking execution sequence. Moreover, there will be potentially many other execution sequences originating from that backtracking sequence that preserve causal independence. This is illustrated in the next example.

Example 5

Consider a different execution of the program from Example 1, where one full iteration of the while loop is executed first. Then we perform the entire conditional statement (executing the false branch), and follow it by doing the second loop iteration, producing the following execution sequence.

Fig. 2.

All possible executions of the inverted program from Example 2 preserving causal independence. To improve presentation of transition labels we have only retained bracketed identifiers or skip numbers omitting the names of statements. For example instead of X=4[11] we write [11] as the label of the first transition, and we write (19) instead of skip(19) in the second transition.

Under backtracking reversal, the second while loop iteration must be reversed first. This would produce the following execution sequence.

By Definition 2, we have that the opening/closing of a conditional statement is independent of any statements of the loop (no re-evaluation of the expression). The false branch statement Z=3 is independent of any statements of the loop. The entire conditional statement can be reversed prior to any reversal of the loop. This causally consistent reversal produces the following execution sequence.

B Local Variables

The programming language used throughout this work supports global and local variables. A global variable is uniquely named and assumed to exist prior to the execution. At an implementation level, each global variable is associated with a unique memory location. Global variables are accessible from any point within the program, with each use referring to the same memory location.

The syntax shown in Fig. 1 introduces block statements of the form DV; P; RV, where DV is a sequence of local variable declaration statements, P is a program and RV is a sequence of local variable removal statements. A local variable declaration statement (only possible at the beginning of a block) creates a new variable local to the block statement. A unique memory location is associated with this local variable, keeping the value it holds separate to that of the global version. This local variable is only accessible from within the same block statement. If a local variable is named uniquely (including to global variables), then this is treated exactly the same as a global variable. Should a local variable share its name with a global variable, the global variable is no longer accessible within this block statement. Any use of this name within the block statement will refer to the local version (and not the memory location associated with the global version). At the end of a block, each local variable must then be removed via a local variable removal statement. This deletes the final value this variable held and releases the memory location.

Let us first consider whether local variable declaration statements can race. Within a single block, our syntax does not support parallel statements within DV. Therefore two declaration statements within the same block cannot race. Two blocks can be in parallel, meaning declaration statements from different blocks can be executed in parallel. Since each will use a fresh memory location and therefore refer to a different variable (or version if the same name is used), these also cannot race. Similar reasoning can be given for removal statements but is omitted here.

We now consider races between uses of local variables. A parallel statement within a block may contain uses of the same local variable in parallel. Such statements will race according to Definition 1. Two block statements can be in parallel, each of which may declare a local variable with the same name. Any two statements such that each is from a different side of this parallel statement cannot race as this name will refer to a different version of this variable (a different memory location). Two uses of the same variable name on a single side of the parallel will race as explained above.

We conclude that local variable declaration and removal statements cannot race, and are therefore not included in our definition of a data race (Definition 1).