Safe and Scalable Multicore Computing Microsoft Research is pleased to announce the recipients of the Safe and Scalable Multicore Computing RFP awards, totaling $1,500,000 in funding over three years. The objective of this RFP is to stimulate and enable bold, substantial, and impactful research in multicore software, breakthrough research that rethinks the relationships between computer architecture, operating systems, runtimes, compilers, and applications, and which proposes new mechanisms and paradigms that will lead to safe and scalable concurrent systems and applications, focusing on mainstream “client” platforms. Multicore Computing RFP Award Recipients
 Sensible Transactional Memory via Dynamic Public/Private Memory
Dan Grossman
University of Washington, USA
Integrating transactions into the design and implementation of modern programming languages has a surprising number of difficulties. The broad goal of our research is to remove such difficulties via work in language semantics, compilers, run-time systems, and performance evaluation. Toward that end, we will research programming-language techniques for eliminating semantic anomalies in weakly-atomic transactional memory systems. While the basic notion of explicitly public/private memory is straightforward, we identify five open research questions—sub-object granularity, super-object granularity, parallelism within transactions, inference tools, and ordering constraints—that will help make the idea a practical part of programming languages with transactional memory.
 Supporting Scalable Multicore Systems Through Run-Time Adaptation
Kim Hazelwood
University of Virginia, USA
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, run-time adaptation. This research will focus on the Run-Time 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, since 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 run-time 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. Thus, we believe a companion dynamic compilation layer must be provided to complement the static parallelization layer, and this run-time system is the focus of our research.
    Language and Runtime Support for Safe and Scalable Programs
Antony Hosking, Jan Vitek, Suresh Jagannathan, and Ananth Grama
Purdue University, USA
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. We will develop novel constructs that fundamentally enhance the performance and programmability of applications using transaction-based approaches. We 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.
 Multicore-Optimal Divide-and-Conquer Programming
Paul Hudak
Yale University, USA
Divide-and-conquer is a natural, expressive, and efficient model for specifying parallel algorithms. We cast divide-and-conquer as an algebraic functional form, that we call DC, much like the more popular map, reduce, and scan functional forms. As such, DC subsumes the more popular forms, and its modularity permits application to a variety of problems and architectural details. We will tailor DC to multicore architectures, and develop a notion of multicore-optimal divide-and-conquer programming. Expressing an algorithm in this framework will not only ensure maximal parallelism, but will also guarantee minimal communication costs, thus achieving a high degree of efficiency.
 Geospatial-based Resource Modeling and Management in Multi/Many-Core Era
Tao Li
University of Florida, USA
To ensure that multi-core performance will scale with the increasing number of cores, innovative processor architectures (e.g., distributed shared caches, on-chip-networks) are increasingly being deployed in the hardware design. We will explore novel techniques for geospatial-based on-chip resource utilization analysis, management and optimization focusing on (1) accurate and scalable methods to model the geospatial resource utilization patterns across a large number of cores/components; (2) architecture and OS support for efficient mining of geospatial-based resource utilization at large scales; and (3) studying the enabled geospatial-aware cooperative resource management for multi-/many-core processors.
 Reliable and Efficient Concurrent Object-Oriented Programs (RECOOP)
Bertrand Meyer
ETH Zurich, Switzerland
The goal of the project, starting from the 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. Specifically, to enable precise reasoning on concurrent programs, at a level of abstraction comparable to what is possible on sequential programs using modern languages and programming techniques, and to enable formal reasoning and proofs. .
 Runtime Packaging of Fine-Grained Parallelism and Locality
David Penry
Brigham Young University, USA
Scalable multicore environments will require the exploitation of fine-grained parallelism to achieve superior performance. To overcome both the overhead of task synchronization and variability in system architectures and runtime environments, packaging of parallelism and locality should be performed by the runtime environment. Current packaging algorithms suffer from a number of limitations. We will develop new packaging algorithms which can take into account both parallelism and locality, are aware of critical sections, can be re-run as the runtime environment changes, can incorporate runtime feedback, and are highly scalable. Safe and Scalable Multicore Computing RFP
|
