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.
Compact Debugging Traces with Binary Code Analysis and Instrumentation
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
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
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
We are building a prototype inliner for Phoenix that includes an adaptive control mechanism to find a good program-specific inlining strategy.
Efficient Design-Rule Checking
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
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
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
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
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.
Using Traces of Software Behavior
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
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
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.