DomLock: a new multi-granularity locking technique for hierarchies

14 minute read


In the paper “DomLock: a new multi-granularity locking technique for hierarchies” the authors present an interesting technique for locking objects that follow a hierarchical structure. Several applications that operate on objects that form a hierarchy suffer from synchronization bottlenecks because of lock contention. When several transactions operate on different parts of the data hierarchy, there is contention which restricts concurrency. Read more

Transactional Boosting: A Methodology for Highly-Concurrent Transactional Objects

5 minute read


Software transactional memory (STM) is an emergent alternative to mutual exclusion. In STM, the activities are organised as transactions which can commit or abort. Most transactional memory systems synchronise on the basis of read/write conflicts. Two transactions are said to be in conflict if they modify at-least one same object. When conflicting transactions need to commit, we need some mechanism to resolve this conflict. This can be done by forcing either transaction to abort. The benefit of this type of conflict detection and resolution is that the overhead of managing conflicts does not fall to the programmer. But at the same time, this method also severely restricts the concurrency for shared objects which come under contention very often. Read more

Lock Coarsening: Eliminating Lock Overhead in Automatically Parallelized Object-Based Programs

6 minute read


Atomic operations are a key primitive in parallel computing. Typically atomic ownership is provided via mutual exclusion which is achieved in the simplest way through locking. A lock is said to be finely grained if it exclusively locks only a small part of the data structure and thus suffers from low contention. The question still remains. What should we lock and how fine can the lock granularity be without sacrificing on performance? At what point does the cost of maintaining locks override the benefit achieved from the finer locking. Read more

Zeus: locality aware distributed transactions

15 minute read


Typical databases have distributed transactions that update multiple objects. These objects are updated by transactions that span multiple shards and require coordination for state reconciliation. Most popular protocol to reconcile the state is the two phase commit protocol. This distribution is an inherent problem since most transactions access multiple replicas and thus the communication latency between those replicas leads to a slowdown. The commit requiring coordination is also blocking. Zeus fetches the objects involved in a transaction’s operations locally and then performs the reads and writes on the local versions of the objects. Read more