Sapha: Static Approximate Phase Analysis.

These pages describe work carried out on design implementation, and applications of a technique that we call static approximate phase analysis. The PI is Hridesh Rajan and much of the work is carried out by Tyler Sondag.


March 2011: Invited talk on phase-based tuning at SMART '11.

December 2010: Paper on Frances-A tool accepted for CCSC 2011.

November 2010: Paper on phase-guided tuning accepted for CGO 2011.

August 2010: Paper on cache analysis accepted for RTSS 2010.

January 2010: Tutorial on Frances tool accepted for CCSC 2010.

October 2009: Paper on Frances tool accepted for SIGCSE 2010.

What is SAPHA?

The goal of the SAPHA project is to design and implement automatic thread-to-core assignment techniques for performance asymmetric multi-core processors that will improve the overall utilization of these processors.


As multi-core processors are becoming common, vendors are starting to explore trade offs between die size, number of cores on a die, and power consumption leading to performance asymmetry among cores on a single chip. For efficient utilization of these performance asymmetric multi-core processors, application threads must be assigned to cores such that the resource needs of a thread closely matches resource availability at the assigned core. Figure 1 illustrates this problem for a CPU consisting of three different core types and applications which vary in resource requirements. Current methods of thread-to-core assignment often require an application's execution trace to determine it's runtime properties. These traces are obtained by running the application on some representative input. A problem is that developing these representative input sets is time consuming, and requires expertise that the user of a general-purpose processor may not have. Other techniques for thread-to-core assignment require monitoring throughout the entire execution of a program. Reducing the amount of monitoring, we are likely to see improved performance. Furthermore, these techniques base decisions for future thread-to-core assignment based on past execution behavior.

In this project, we are designing, implementing, and evaluating automatic thread-to-core assignment techniques for performance asymmetric multi-core processors that will enhance the utilization of these processors. The first step of our approach is to group together code segments that are likely to exhibit similar runtime behavior. The key idea is that the actual runtime characteristics of a small number of code segments gives insight into the behavior of all similar code segments. Figure 1 illustrates the basic ideas behind our approach which we call phase-based tuning.

Figure 1: Overview of phase-based tuning

Key Advantages of SAPHA

  • Programmer oblivious: Programmer does not need to understand the underlying performance asymmetry or the characteristics of their application.
  • Architecture independent: Does not need to be re-run for different architectures.
  • Transparent deployment: No OS or compiler modification is required.
  • Improved utilization: Improved utilization of performance asymmetric multicore processors.
  • Negligible overhead