Phoenix—Excellence in Programming 2005 RFP Awards
Microsoft Research announced the 12 recipients of the Phoenix RFP awards, totaling $541,887 in funding. The objective of the
Phoenix RFP is to explore issues in code generation, optimization, program
analysis, binary transformation, and software correctness. Microsoft is focused
on advancing the state of the art in these areas through a common infrastructure
designed expressly for extensibility, modularity, performance, and
collaboration—the Phoenix framework.
Phoenix RFP Award Recipients
 Constructing
Compact Debugging Traces with Binary Code Analysis and Instrumentation
Yinong Chen
Arizona State University
We will use Phoenix to apply novel slicing techniques to automatically generate compact effect-cause traces, which have wide applications to debugging, profiling, and monitoring.
Phoenix-Based Compiler Course
Development
Regeti Govindarajulu
Indian Institute of Information Technology, Hyderabad
Enhancing an undergraduate compiler curriculum to include more sophisticated
backend and optimization content using Phoenix as the backend framework.
Compiler Backend Experimentation
and Extensibility Using Phoenix
Suresh Jagannathan
Purdue University
Use Phoenix as the code generation engine to decrease overhead and
improve the safety for concurrent execution in multi-core processors
thus leveraging the new architectural trends maintaining simplified
program structure.
 Adaptive Inline Substitution in
Phoenix
Keith Cooper
Rice University
We are building a prototype inliner for Phoenix that includes an
adaptive
control mechanism to find a good program-specific inlining strategy.
Domain-Specific
Language for
Efficient Design-Rule Checking
Eric Wohlstadter
The University of British Columbia
Develop a domain-specific language to allow developers to express
“Design Rules for Modularity.” The language allows the expression of
patterns that generally constitute symptoms of bad modularity “code
smells” and scoping rules that describe the desired modular structure of
a software system.
Setpoint: An Aspect Oriented
Framework Based on Semantic Pointcuts
Victor Braberman
Universidad de Buenos Aires
Setpoint involves annotating source code with semantic information
through metadata, which can later be used in the construction of
semantically rich pointcuts to guide aspect weaving: setpoints.
 Phase Aware Profiling with Phoenix
Chandra Krintz
University of California at Santa Barbara
The goal of our research is to use the Microsoft Phoenix Framework to
enable transparent, software-based, post-deployment, program
optimization, bug isolation, and coverage testing. The key to our
approach is our exploitation of repeating patterns in program behavior,
that is, phases, to reduce the overhead of accurate program sampling.
Using Call Graph Analyses to Guide
Selective Specialization in Phoenix
Cormac Flanagan
University of California at Santa Cruz
Use the control flow and data flow analysis capabilities of Phoenix
to identify opportunities for specialization in code generation.
Program Visualization with Fulcra
and Phoenix
Wen-Mei Hwu
University of Illinois at Urbana-Champaign
Build an analysis and visualization framework using Phoenix and
Fulcra to enable analysis and programmer feedback to identify
parallelism in the programming model. The accurate context sensitive
pointer analysis in Fulcra provides accurate discovery of call graphs
and present information to the programmer to identify and alleviate
performance bottlenecks.
Navel: Automating
Software Support
Using Traces of Software Behavior
Emmett Witchel
University of Texas at Austin
Use Phoenix as the instrumentation engine for large, real-world
client or server applications to insert probes that identify program
behavior and provide a fingerprint to classify and identify software
failures.
Techniques and Tools for Software
Assurance
Jack Davidson
University of Virginia
Create a Phoenix based framework that can be used to identify and
test for security vulnerabilities. This framework will automate test
case generation and provide for regression testing.
 Type-Checking the Intermediate
Languages in the Phoenix JIT Compiler
Zhong Shao
Yale University
Our project is to design and implement a sound type system for the
intermediate representation of Phoenix. A sound type system will allow a
way to automatically check that the result of compilation will not crash
unexpectedly.
|
