Microsoft Research
Microsoft Translator |
External Research: Phoenix—Excellence in Programming Awards

Phoenix—Excellence in Programming 2005 Awards

Microsoft Research announced the 12 recipients of the Phoenix awards, totaling $541,887 in funding. The objective of the Phoenix Award 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 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.

 > Collaboration > Opportunities