Micrsoft External Research says the aim of this RFP is to stimulate and enable bold, substantial research in multicore software that rethinks the relationships among computer architecture, operating systems, runtimes, compilers and applications. The goal of the research is to propose new mechanisms and paradigms that will lead to safe and scalable concurrent systems and applications, focusing on mainstream client platforms.

The Reliable and Efficient Concurrent Object-Oriented Programs (RECOOP) being run by Bertrand Meyer at ETH Zurich is the only non-U.S. project to receive a grant.

The goal of the project, starting with the simple concurrent object-oriented programming (SCOOP) model of concurrent computation, is to develop a practical formal semantics and proof mechanism, enabling programmers to reason abstractly about concurrent programs and allowing proofs of formal properties of these programs.

The team aims to enable precise reasoning on concurrent programs at a level of abstraction comparable with what is possible on sequential programs using modern languages and programming techniques.

Other winning projects include a project called Sensible Transactional Memory via Dynamic Public or Private Memory lead by Dan Grossman of the University of Washington.

Microsft says integrating transactions into the design and implementation of modern programming languages is surprisingly difficult. The broad goal of this research is to remove such difficulties via work in language semantics, compilers, runtime systems and performance evaluation. The researchers at the University of Washington will investigate programming-language techniques for eliminating semantic anomalies in weakly atomic transactional memory systems.

Kim Hazelwood's project at the University of Virginia is called Supporting Scalable Multicore Systems Through Runtime Adaptation. The Paradox Compiler Project aims to develop the means to build scalable software that executes efficiently on multicore and manycore systems via a unique combination of static analyses and compiler-inserted hints and speculation, combined with dynamic, runtime adaptation. This research will focus on the runtime adaptation portion of the Paradox system. Future parallelization systems must be capable of dynamically adapting a compiled application to the underlying hardware and the execution environment because the specific hardware configuration (number of cores, number of function units per core, cache sizes) will not  and should not  be known by the compiler.

Meanwhile, the system utilization changes at runtime, enabling the application to use more or fewer cores. Finally, the behavior of the application itself changes over time, which should result in regular re-evaluation of parallelism decisions. The focus of this teams research is to develop a runtime system that requires a companion dynamic compilation layer to complement the static parallelization layer.

Antony Hosking, Jan Vitek, Suresh Jagannathan and Ananth Grama at Purdue University are looking at Language and Runtime Support for Safe and Scalable Programs. Expressing and managing concurrency at each layer of the software stack, with support across layers, as necessary, to reduce programmer effort in developing safe applications while ensuring scalable performance is a critical challenge.

This team will develop novel constructs that fundamentally enhance the performance and programmability of applications using transaction-based approaches. The researchers will build tools grounded in the C# language, by extending technologies including Phoenix, Bartok and Singularity, building support for specification, analysis, compilation, execution and benchmarking of high-level transaction-based abstractions for concurrent programming.