Snapshot Isolation Does Not Scale Either

Transactional memory (TM) [11, 15] allows concurrent processes to execute operations on data items within atomic blocks of instructions, called transactions. A transaction may either commit in which case all its updates become visible to other transactions, or abort in which case all its updates are discarded. The paradigm is appealing for its simplicity but implementing it efficiently is challenging. Ideally, the TM system should not introduce any contention between transactions beyond that inherently due to the actual code of the transactions. In other words, if two transactions access disjoint sets of data items (i.e. if they do not conflict), then none of these transactions should delay the other one, i.e., these transactions should not contend on any base object. This requirement has been called strict disjoint-access-parallelism. Base objects are low-level objects, which provide atomic primitives like read/write, load linked/store conditional, compare-and-swap, used to implement the TM system. Two transactions contend on some base object if both access that object during their executions and one of them performs a non-trivial operation on that object, i.e. an operation which may update its state. Disjoint-access-parallelism was introduced in [12]. Later variants [1, 2, 6] employed the concept of a conflict graph. A conflict graph is a graph whose vertices represent transactions (or operations) performed in an execution α and an edge exists between two nodes if the corresponding transactions (operations) conflict in α. In most of these definitions, disjoint-access-parallelism requires any two transactions to contend on a base object only if there is a path in the conflict graph of the minimal execution interval that contains both transactions. Different variants are met in the literature with the names disjoint-access-parallelism or weak disjoint-access-parallelism (most of them use different properties to restrict access to base objects). Stronger versions of disjoint-access-parallelism like strict disjoint-access-parallelism, result in more parallelism (and promote scalability) and therefore they are highly desirable when designing TM implementations: strict disjoint-access-parallelism is indeed ensured by blocking TM algorithms like TL [4]. Nevertheless, a transaction that locks a data item and gets paged out might block all other transactions for a long amount of time. One might require a liveness property that prevents such blocking. It was shown however in [8] that a TM cannot ensure strict disjoint-access-parallelism if it also needs to ensure serializability [13] and obstruction-freedom [7, 5]. Obstruction-freedom ensures that a transaction can be aborted only when step contention is encountered during the course of its execution. Obstruction-freedom is weaker than lock-freedom or wait-freedom. It allows for designing simpler TM algorithms and therefore it has been given special attention in TM computing [9]. We study the following question: can we ensure strict disjoint-access-parallelism and obstruction