Share this page
    Project Tuva Enhanced Video Player
    Project Tuva Enhanced Video Player
    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.