PHOENIX RFP AWARDS – 2005

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
The work involves 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
This project aims to leverage tools and technologies available in the Phoenix and .NET framework to study compiler extensibility and analyses. First by using MLton, an optimizing compiler for StandardML. We will target MLton’s first-order IL to Phoenix and leverage existing tools to more easily support retargetability, profiling, and improved backend optimizations. Conversely, we will port many of MLton’s current optimizations to the Phoenix environment, to allow these optimizations to be applied elsewhere as appropriate. In particular, we will integrate compiler optimizations available in MLton to F#, and will leverage F# utilities and interoperability features to improve MLton, by retargeting the F# front-end to generate a MLton-readable IR. Second, we propose to implement necessary compiler support using Phoenix. By using the Phoenix and .NET framework, we believe a lightweight transactional model for C# is feasible. Such an implementation would be especially valuable in scalable multiprocessor environments. We would also explore opportunities to investigate the interaction of lightweight transactional models with C# extensions such as Polyphonic C# that provide asynchronous methods and synchronization patterns.

Adaptive Inline Substitution in Phoenix
Keith Cooper
Rice University
Inline substitution is a simple and powerful code transformation that has the potential to improve program performance in a variety of circumstances. The mechanism of inline substitution is straightforward. The compiler replaces a procedure call (a “call site”) with the body of the called procedure (the “callee”). The resulting code often has properties that lead the compiler to produce more efficient code than it would for the original code that used separate procedures and a call.
We have an ongoing investigation into the use of adaptive techniques to choose specific call sites to inline. We propose to move this work into Phoenix, where it can capitalize on the stable infrastructure of the Phoenix system. A critical part of this work involves experimenting with different static and dynamic measures of the program. Phoenix’s analysis and profiling capabilities will let us perform a broader set of experiments with less implementation overhead. Finally, by using Phoenix, we can scale our experiments to large-scale systems—a critical part of demonstrating success with inlining since many of the interesting effects of inline substitution only arise in large programs.

Domain-Specific Language for Efficient Design-Rule Checking
Eric Wohlstadter
The University of British Columbia
This project addresses the problem of checking source code against a set of coding conventions, commonly referred to as design rules. Enforcement of design rules is becoming an important practice in industry as evidenced by the release of Microsoft's “Design Guidelines for .NET Class Library Developers”. Design rules are not (and should not) be directly part of a programming language semantics. This is because design rules can be highly project or task specific. For this reason Microsoft has released a tool, FxCop, for design-rule checking. FxCop is extensible through an API that exposes an intermediate representation of code to design-rule developers. However, programming design rules can be difficult and error prone even when a programmer is familiar with the details of the intermediate representation. This project addresses this problem by building a domain-specific language tailored for the purpose of specifying design rules. We intend to make use the domain-specific language analysis to optimize sets of design-rule checks over code. Our approach is based on our prior work with the JQuery program database. 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
We propose an innovative approach to attain the two basic constituents of AOSD: quantification and obliviousness. This approach consists in 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. Traditional AOP frameworks impose rigid syntactic conventions to the source code or require ad-hoc artifacts to adapt generic aspects to particular applications. We firmly believe that replacing these restrictions and adapters with explicit semantics will remove the main obstacle that keeps AOP technologies from becoming a massively adopted resource for systems development. Phoenix will allow us to integrate the so-called preweaving and semantication processes into the environment, maintaining SetPoint implementation isolated from IL management internals. This synergy will be achieved in a natural way, inserting these processes as phases in program generation. Phoenix will help us explore another semantic AOP need as well: semantic contracts.

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. We have shown in prior work that programs commonly do not behave randomly but instead, execute as a series of phases. During a particular phase, the behavior of the program is relatively stable for some amount of time, after which the behavior may drastically switch. Furthermore, these same phases may then re-occur at some point later in time. We propose to exploit this phase behavior within the Phoenix system to improve the efficiency and efficacy of remote profiling. To enable this, we will develop intelligent sampling techniques that sample each phase of a remotely executing program instead of continuously sampling (randomly, periodically, or otherwise) over the lifetime of the program.

Using Call Graph Analyses to Guide Selective Specialization in Phoenix
Cormac Flanagan
University of California at Santa Cruz
This projects plans to extend the Phoenix compiler framework and run-time system to provide support for lightweight abortable transactions. The run-time system will provide a transaction API through which the source program can indicate the dynamic scope of transactions. (This approach avoids the need for syntactic changes in the source language.) If a transaction encounters an error or other unexpected event, it can abort via an appropriate call to the transaction API. In this case, the modified Phoenix run-time system is responsible for rolling-back the program to its consistent, pre-transaction state. Where possible, external events such as file system operations, are also rolled-back.

Program Visualization with Fulcra and Phoenix
Wen-Mei Hwu
University of Illinois at Urbana-Champaign
We propose to create a suite of safe, accurate, scalable and intuitive program understanding tools in Phoenix. Critical to the fulfillment of this goal are safe, high resolution pointer analysis tools—tools conventionally assumed not to scale to the size of typical commercial applications. Having developed Fulcra, an accurate and efficient pointer analysis system, and demonstrated its safety, accuracy and scalability on SPEC and other benchmark applications, we are now ready to address a larger scope of programs. This project will interface Fulcra with Phoenix to enable accurate analysis and visualization of large-scale production software. By performing online summary compaction and local adaptation in a flexible constraint framework, Fulcra is the first pointer analysis system to provide context sensitivity, truly safe field sensitivity, heap object cloning, and inclusion (subtyping) together in a scalable implementation. Among the SPEC CPU benchmarks, we have shown the system to provide much higher accuracy than traditional unification-based approaches while maintaining a developer-friendly run time. Phoenix integration will allow the evaluation of Fulcra’s accuracy and scalability on Microsoft’s large, production software and will facilitate rapid development of a practical application of Fulcra in a source-level visualization tool. We expect this project will ultimately demonstrate the practical applicability of “deep” static analysis in the construction of useful code understanding tools.

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. Software robustness and software support are crucial problems today and the state of the art is disappointing. Navel is a project set to improve life for end users and companies that provide software support. When software fails, end users often have no recourse but to contact a call center. Call center employees often rely on nothing more than responses to a small set of pre-planned questions. This form of support works only for a limited class of failures, and results in great frustration when problems are not resolved. Recently, crash diagnosis systems that gather information at the end user’s machine and send it to the vendor are an improved direction for software support. However, these systems are not yet making sophisticated choices about what data to send. As a system, Navel will broaden the scope of system behavior which generates feedback, it will enrich the information collected and sent, and it will include algorithms to interpret that information. The information that Navel collects will enable call center employees to make more accurate diagnoses, or it might automate diagnosis for some issues. Information tracked by Navel could also be fed back to program developers who can focus bug fixing on problems that occur in the field. Navel will insure that more useful information is sent when software malfunctions, and that more can be done with that information by support staff and developers.

Techniques and Tools for Software Assurance
Jack Davidson
University of Virginia, USA
The primary goal of our research is to develop robust, affordable, scalable techniques for providing higher levels of software assurance. The expected outcomes, using the Phoenix infrastructure, include: a set of synthetic test cases for gauging the effectiveness of techniques at countering malicious code attacks, experiments to understand how and what types of malicious code can be inserted into Windows binaries, robust binary security transformations for protecting Windows binaries against attacks, a security testing framework and tool that enables testing for vulnerabilities before deployment, and experimental evaluations that demonstrate the effectiveness and efficiency of the testing framework.

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.