An efficient algorithm to synchronize accesses to shared data

The concept of atomic transaction has been widely used not only lo achieve modularity and fault-tolerance, but also to control accesses to shared objects. In order to preserve serializability among transactions, many current proposals strongly limit parallelism. To avoid cascading aborts, almost all locking protocols in use require that object locks are kept until transaction completion. The prolongation of the lock retaining period is not however essential for synchronization purposes. Making available information on the updated objects while transaction outcome is still uncertain requires a more expensive book-keeping, but can improve concurrency among running transactions. We believe that with this approach higher efficiency can be achieved. In this paper, an efficient synchronization mechanism is proposed to regulate accesses to shared objects. The well-known two-phase lock protocol is followed. We suggest an explicit unlock operation, which can be invoked within the body of a transaction, i.e. before commit phase, and show that the disclosure of as yet uncommitted objects implies that different versions of an object may exist at the same time thus imposing some additional constraints on transaction management. In particular, a transaction using a so far uncommitted work copy of an object becomes dependent on the transaction which previously released it. An algorithm which copes with these problems is presented. The algorithm supplies lock and unlock operations, correctly orders multiple versions of objects and controls transaction dependency relations. The risk of cascading aborts is accepted, but fully controlled.