language support for lightweight transactions
Concurrent programming is notoriously difficult. Current abstractions are intricate and make it hard to design computer systems that are reliable and scalable. We argue that these problems can be addressed by moving to a declarative style of concurrency control in which programmers directly indicate the safety properties that they require. In our scheme the programmer demarks sections of code which execute within lightweight software-based transactions that commit atomically and exactly once. These transactions can update shared data, instantiate objects, invoke library features and so on. They can also block, waiting for arbitrary boolean conditions to become true. Transactions which do not access the same shared memory locations can commit concurrently. Furthermore, in general, no performance penalty is incurred for memory accesses outside transactions.We present a detailed design of this proposal along with an implementation and evaluation. We argue that the resulting system ( i ) is easier for mainstream programmers to use, ( ii ) prevents lock-based priority-inversion and deadlock problems and ( iii ) can offer performance advantages.
language support transactions concurrent program concurrency abstraction design computation systems reliability scalability concurrency control programmer scheme code commit update sharing data object libraries feature blocking access shared memory memorialized locatability general performance implementation evaluation use deadlock software conditional critical regions non-blocking systems locking priorities