Consistency anomalies in multi-tier architectures: automatic detection and prevention

Abstract

Modern transaction systems, consisting of an application server tier and a database tier, offer several levels of isolation providing a trade-off between performance and consistency. While it is fairly well known how to identify qualitatively the anomalies that are possible under a certain isolation level, it is much more difficult to detect and quantify such anomalies during run-time of a given application. In this paper, we present a new approach to detect and quantify consistency anomalies for arbitrary multi-tier application running under any isolation levels ensuring at least read committed. In fact, the application can run even under a mixture of isolation levels. Our detection approach can be online or off-line and for each detected anomaly, we identify exactly the transactions and data items involved. Furthermore, we classify the detected anomalies into patterns showing the business methods involved as well as analyzing the types of cycles that occur. Our approach can help designers to either choose an isolation level where the anomalies do not occur or to change the transaction design to avoid the anomalies. Furthermore, we provide an option in which the occurrence of anomalies can be automatically reduced during run-time. To test the effectiveness and efficiency of our approach, we have conducted a set of experiments using a wide range of benchmarks.

Appendices

Correctness of algorithm 1

In this section, we show that for any type of dependency between two transactions $T_i$ and $T_j$, processTx adds the corresponding dependency edge to the dependency graph at the time the second of the two transactions is processed. Assume without loss of generality that there is an edge from $T_i$ to $T_j$ due to entity $x$. We consider several cases:

• 1 $T_i$ is processed before $T_j$

  • a If $T_i - wr \rightarrow T_j$, then the edge is added when processReadEntity, line 3, is executed for $T_j$.

  • b If $T_i - rw \rightarrow T_j$, processReadEntity for $T_i$ adds $T_i$ to the readers of the predecessor of $T_j$ (in regard to $x$) in line 10, and processUpdateEntity for $T_j$ adds the proper $rw$-edge in lines 16–17.

  • c If $T_i - ww \rightarrow T_j$, processUpdateEntity for $T_j$ adds the edge in lines 6–7.

• 2 $T_j$ is processed before $T_i$

  • a If $T_i - wr \rightarrow T_j$, processReadEntity for $T_j$ adds $T_j$ to the readers of $T_i$ (in regard to $x$) in line 5, and processUpdateEntity for $T_i$ adds the proper $wr$-edge at lines 18–19.

  • b If $T_i - rw \rightarrow T_j,$ processUpdateEntity for $T_j$ adds $[(x.key, T_p\_id), T_j\_id)]$ to $successors$ in line 15, and processReadEntity for $T_i$ retrieves $T_j\_id$ in line 6 and adds the $rw$-edge in lines 7–8.

  • c If $T_i - ww \rightarrow T_j$, processUpdateEntity for $T_j$ adds $[(x.key, T_i\_id), T_j\_id)]$ to $successors$ in line 15, and processUpdateEntity for $T_i$ retrieves this information in line 10, and adds the $ww$-edge in lines 11–12.

Each edge is added exactly once. Therefore, all data structures maintained by ProcessReadEntity and ProcessUpdateEntity can be implemented with simple hash functions. Thus, building the dependency graph is linear with the number of operations.

Proofs

For the following proofs, recall that $s_i < c_j$ if $T_i$ starts before $T_j$ commits, and $c_j \le s_i$ if it starts after $T_j$ committed. Obviously, any read/write operation of $T_i$ occurs between its start and its commit, i.e., $s_i < r_i/w_i < c_i$.

1.1 Proof of Theorem 5.2

Lemma 14.1

For any RC+ history, if there is a $wr$- or a $ww$-edge from $T_i$ to $T_j$, then $c_i < c_j$.

Proof

For $T_i - ww \rightarrow T_j$, this is true by definition of this edge type. For $T_i - wr \rightarrow T_j$, RC+ requires a read operation $r_j$ to only read a committed value $x_i$. Thus, $c_i < r_j$, and hence $c_i < c_j$ $\square$

Lemma 14.2

For any RC+ history, if there is a $rw$-edge from $T_i$ to $T_j$ then $s_i < c_j$.

Proof

For $T_i - rw \rightarrow T_j$, then there is a read operation $r_i$ that reads a value written by committed transaction $T_k$ and $T_j$ is the next transaction to write $x$ and commit. As RC+ reads the last committed version as of start of operation, this means the read of $T_i$ must be after the commit of $T_k$ but before the commit of $T_j$, i.e., $c_k < r_i < c_j$. Therefore, $s_i < c_j$. $\square$

Lemma 14.3

Under a RC+ history, if there is an edge (of any type) between $T_i$ and $T_j$ then $s_i < c_j$.

Proof

It is a straightforward conclusion from Lemma 14.1 and Lemma 14.2. $\square$

Proof of Theorem 5.2

We denote by $T_3$ the first committing transaction in a given cycle $C$, and $T_2$ the predecessor of $T_3$ and $T_1$ the predecessor of $T_2$.

We first show that $T_2 \parallel T_3$ and $T_2 \parallel T_1$. Assume that $T_2 \not \parallel T_3$ ($\not \parallel$ means not concurrent), then either (1) $c_2 < s_3$ or (2) $c_3 < s_2$. (1) is not possible, since $c_2 < s_3$ implies $c_2 < s_3 < c_3$, thus $c_2 < c_3$ which contradicts that $T_3$ is the first committer in $C$. Based on Lemma 14.3, since there is an edge from $T_2$ to $T_3$, we have $s_2 < c_3$ and thus (2) is also not possible. As neither (1) nor (2) is possible, $T_2$ and $T_3$ must be concurrent. Now, assume that $T_2 \not \parallel T_1$, meaning either (3) $c_2 < s_1$ or (4) $c_1 < s_2$. (3) is impossible as there is an edge from $T_1$ to $T_2$ which requires $s_1 < c_2$ based on Lemma 14.3. The edge from $T_2$ to $T_3$ requires $s_2 < c_3$. If we assume (4) holds, then we have $c_1 < s_2 < c_3$ which contradicts the fact that $T_3$ is the first committer in $C$. As neither (3) nor (4) are possible, $T_1$ and $T_2$ must be concurrent. $\square$

Finally, assume that the edge from $T_2$ to $T_3$ is not a $rw$-edge but a $wr$- or $ww$-edge. Based on Lemma 14.1, this requires $c_2 < c_3$. But this contradicts the fact that $T_3$ is the first committed in $C$.

1.2 Proof of Lemma 5.1

Given an $edge$ from a transaction $T_i$ to a transaction $T_j$ in a dependency graph generated under RC+, such as $c_j < c_i$ ($T_i$ commits after $T_j$). Let us assume that the edge from $T_i$ to $T_j$ is a $wr$ ow $ww$-edge. Based on Lemma 14.1, we will have $c_i < c_j$ which contradicts the fact that $T_i$ commits after $T_j$ ($c_j < c_i$). Therefore, the edge from $T_i$ to $T_j$ can only be of type $rw$. Based on Lemma 14.2, $T_i - rw \rightarrow T_j$ implies that $s_i < c_j$. And since $c_j < c_i$, we get $s_i < c_j < c_i$ which means $T_i$ is concurrent to $T_j$.