Efficient Synchronized-by-Default Concurrency

The Synchronized-By-Default (SBD) concurrency model synchronizes all accesses to shared memory by default. Synchronization takes place by ensuring that all program code runs inside atomic sections even if this program code has external side effects. Threads are mapped to atomic sections by default. A programmer must explicitly break this atomicity to increase concurrency by splitting an atomic section. The SBD concurrency model differs from explicit synchronization where a programmer must add atomicity where needed. Under explicit synchronization, missing atomicity causes data races and race conditions, while under the SBD concurrency model missing atomicity breaks cause serialization. A naive implementation of this approach incurs a large amount of overhead. Previous work on similar approaches concentrated on simulated hardware transactional memory to reduce the overhead and on the formal semantics of such a concurrency model. In the thesis, we show how to reduce the overhead to make the approach suitable for realistic application programs on existing hardware using software transactional memory (STM). For this reason, we present an explicit semantics for SBD and novel STM techniques that in combination with a corresponding programming discipline reduce the overhead of the SBD approach in terms of performance and memory overhead. At the core of SBD lies an explicit semantics. This semantics allows a programmer to avoid performance overhead by reducing the amount of speculation typically found in transactional memory. We show that exploiting the combination of these explicit semantics, large atomic sections, properties of managed, object-oriented programming languages, intraprocedural static analyses, and transactional I/O results in good scaling properties and moderate sequential overhead