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.

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.

Motivation

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.

This material is based upon work supported by the
National Science Foundation under Grant No.
CCF-11-17937.
Any opinions, findings, and conclusions or recommendations
expressed in this material are those of the author(s)
and do not necessarily reflect the views of the
National Science Foundation.