The advent of multicore processors characterized by shared memory accelerates the requirement on fleetly developing shared-resouse-based parallel software. Synchronization is one of the key problems in building shared-resouce-based parallel software. At the source-language level shared resources are mostly shared variables, while at the machine-language level they are registers, memory cells and status flags, etc. To improve the productivity and the confidence of parallel softwares, source languages should provide high-level abstractions for synchronization to ease parallel programming ( rather than simply providing low-level locks, etc.); and compilers and runtime systems are required to provide accurate and efficient implementation for such abstractions.
Most of the prevalent parallel programming paradigms use low-level synchronized facilities such as locks for
synchronizing shared variables, which makes parallel programming difficult and error prone and limits benefits
from programming on multi-core rocessors. The ongoing research on high productivity languages such as
X10, Chapel,
Fortress introduce a high-level construct
"atomic{C}" for synchronization so as to eliminate the explicit low-level synchronization operations
in parallel programming. However, there still exist some unresolved research problems on design and implementation
to be taken account into.
On the way of implementing the shared variable access control, except using low-level locks, there has been a recent flurry of interest in transactional memory (TM), which is another programming paradigm using transactions to simplify parallel programming. A transaction is a sequence of grouped instructions that execute atomically and in isolation. The transactional concurrent control mechanism which is derived from database allows the transactions to be executed speculatively and partially rolled back to the original state while conflicting. Although it is easy to define the atomicity and isolation of transactions, we must consider the interface between TM and complex open world including existing operating systems, programming languages and library code etc. Hence, the situation calls for works towards resolving the related problems.
Some special shared variable access control can be implemented with the lock-free programming. The major hardware primitives
for writing lock-free algorithms include CAS (compare and swap) instruction or LL/SC
(Load-Link/Store-Conditional) instruction, the lock-free algorithms provide high efficiency but hard to write and maintain.
The project focuses on the design, implementation and verification of synchronization mechanisms in shared-resource-based high-productive and high-confidence parallel programming. We carry out our research works in the following three sub-projects: