The advent of shared-memory multi-core microprocessors has created an immense opportunity to exploit thread level parallelism. In most applications, the parallel execution of threads requires ordering mechanisms when accessing to shared data. Traditional multithreaded programming models usually offer a set of low-level primitives, such as locks, to guarantee mutual exclusion: access to shared data is protected through ownership of one or more locks. Locks are complex to use and error prone – especially when trying to avoid deadlock situations or when trying to use fine-grain locking to achieve better scalability on highly parallel hardware. Transactional Memory (TM) is a promising mechanism to tackle this problem by abstracting some of the complexities associated with concurrent access to shared data. With TM, multiple threads can simultaneously try to access multiple shared memory locations within the scope of what is called an atomic “transaction”.

In classical implementations of TM, Transactions replace locking with atomic execution units, so that the programmer can focus on determining where atomicity is necessary, rather than the mechanisms used to enforce it. With this abstraction, the programmer identifies which operations form a critical section, while the TM implementation determines how to run that critical section in isolation from other threads.

We think that TM provides a rich toolset which could be applied to other as-yet unexplored areas. In this proposal, we will investigate how the basic concepts of TM can be applied to other domains of interest that could benefit future computing systems. In particular, we will concentrate in covering those areas which would require minimal hardware changes for a classical TM implementation. Very soon those implementations will start appearing in processors such as Rock from SUN. The idea is then to make use of existing TM hardware to apply it to other domains. One such domain is synchronization. Another prospective area is speculative multithreading. Still another important domain is dataflow computing. In particular, we intend to extend the SDF (Scheduled Data-Flow) execution paradigm to handle TM. The atomic execution model of TM is ideally suited to be paired to SDF. Another idea in the same direction is to using TM mechanisms like retry to provide a dataflow-like execution environment.

In this project, the partners are experienced in TM and SDF. In collaboration, we will explore the above topics. The expected benefits are providing a much improved programming environment through TM hardware support. UPC/BSC will contribute with TM and UNISI with SDF expertise.

2 fellowships are requested. One will be to cover the TM aspect of the project and the other the SDF task. The collaborating students will not receive any funding but they will supervise with the integration of TM with SDF.

We will not ask for any travel funding.

2 PhD students to be supported through the collaboration
Milos Milovanovic (collaborating student, no funding requested)
Zdravko Popovic (collaborating PhD, no funding requested)
Nicola Puzovic (collaborating student, no funding requested)