Despite the growth of multi-core technology, a large subset of programmers still have neither the tools nor the language features to write concurrent programs e ectively. When many programmers are simultaneously working on large, complex code bases with unknown bugs and insu cient documentation, they are unlikely to be very productive unless the programming language a ords them the power to create abstractions and modularise their code. Applications are formed by composing independent modules. However, concurrent algorithms do not compose well. Using classical language features such as locks and compare-and-swap operations, one either has to rewrite the algorithm from scratch or expose its internal implementation to the client. Atomic sections have simple semantics and allow programmers to compose concurrent algorithms. However, atomic sections are typically implemented using transactions. Thus, they lack performance and are restrictive to programmers. Here, we explore the implementation of atomic sections using locks instead of transactions. Firstly, we give a type system that uses universe type annotations (a form of ownership

Atomicity is an important property for concurrent software, as it provides a stronger guarantee against errors caused by unanticipated thread interactions than race-freedom does. However, concurrency control in general is tricky to get right because current techniques are too low-level and error-prone. With the introduction of multicore processors, the problems are compounded. Consequently, a new software abstraction is gaining popularity to take care of concurrency control and the enforcing of atomicity properties, called atomic sections. One possible implementation of their semantics is to acquire a global lock upon entry to each atomic section, ensuring that they execute in mutual exclusion. However, this cripples concurrency, as non-interfering atomic sections cannot run in parallel. Therefore, from a language designer’s point of view, the challenge is to implement atomic sections without compromising performance. This thesis explores the technique of lock inference, which infers a set of locks that attempt to balance the requirements of maximal concurrency, minimal locking overhead and freedom from deadlock. In particular, we look to improve upon the current state-of-the-art as well as consider newer territory such as parallelism within an atomic section to exploit multicore processors and a hybrid implementation with transactional memory. 2Contents