Adoption of multi-core architectures brings a shift to parallel programming as the default model for mainstream software development. Industry and academia alike are designing and implementing languages, runtime systems, and architectures to enable and leverage this shift. One of the foremost technologies to emerge from this effort is transactional memory (TM). Transactional memory offers a new paradigm for expressing general-purpose multithreaded applications safely and efficiently. Although much research effort has focused on implementing transactions, relatively less emphasis has been placed on the problem of defining appropriate programming models for transactional memory. This is a research problem of great practical interest, but also significant difficulty, as its interconnected components span the traditional areas of language implementation (compilers), language design, and software engineering.
This research explores the issue of programming models for transactional memory. First, the investigators evaluate and refine a programming model for allowing a transaction to perform irreversible operations and to coordinate with other threads. The main concept is that of "transaction punctuation" and supports controlled relaxation of transactional guarantees and local reasoning about the effects of other threads. Second, the research examines a hybrid programming model, where a transactional implementation is fitted on a lock-like interface. This approach is suitable both for existing lock-based applications, and for new ones where the programmer has the ability to label critical sections with specific locks. The result is an adaptive combination of the performance advantages of both locks and transactions. Finally, the inestigators study "open-nesting" transactional programming models. Open-nesting is a TM model offering high performance, but at the expense of significant programmer effort. The research evolves and generalizes guidelines for correct open-nesting usage, avoiding counter-intuitive behavior.
