SINOF: A dynamic-static combined framework for dynamic binary translation

Abstract

Dynamic binary translation (DBT) is an important technique in virtualization, and in migrating legacy binaries to platforms based on a new architecture. However, poor profile information limits the process of optimization at runtime, so the DBT system may suffer from substantial overhead. In this paper, we design and implement a static-integrated optimization framework (SINOF) to improve the runtime performance for DBT. Combining static and dynamic approaches can greatly reduce the overhead of optimizing, profiling and translating for any program that runs repeatedly. Under this framework, once the source image has been executed, the profile information and target code will be saved in a software cache, and will be available for future runs. In the static phase, the saved code is analyzed and optimized based on the information collected in the previous run. Especially, we reorganize the code layout of the software cache. Experimental results show that the proposed framework can reduce run time by more than 30% on average compared to the original versions of DBT that the framework is based on.

Introduction

Dynamic binary translation is the process of translating and optimizing one binary executable into a different executable at runtime, and the target code will be executed right after the conversion. It has been proved an increasingly useful technique in many fields. One common usage is to avoid rewriting legacy programs when we want to port programs among different generations or different kinds of architectures [1]. It is also used to reduce the hardware complexity, increase the power efficiency [2], optimize native binaries to improve performance [3], and provide runtime instrumentation of applications [4], [5]. Many dynamic binary translation systems been developed. UQDBT [6], [23] is a machine-adaptable dynamic binary translator supporting different source and target ISAs. Daisy [7] can translate PowerPC instructions to VLIW instructions with the support of hardware. Aries [8] can migrate HP-PA binaries to the IA-64 architecture. DEC FX!32 [9], [10], [11] can make numerous IA-32 applications available on the DEC Alpha Platform. However, dynamic binary translation systems usually suffer from significant overhead. Generally speaking, the overhead incurred in the system can be divided into two parts: the overhead of translating and the overhead of executing target code. Many optimization systems have been proposed to reduce these overheads. As a matter of fact, most of the present DBT systems can reduce the translating costs into an acceptable range. Hence, the main attention is on reducing the execution time of the target code.

In order to reduce the time for executing the target code, many optimization methods have been proposed, such as translation block chaining, forming large translation blocks (superblocks), reordering translated instructions to improve pipeline performance, and borrowing optimization techniques from conventional compilers. In fact, many binary-code-specific optimization methods are seriously dependent on the profile information gathered at runtime. And the richness and correctness of profile information can directly determine which optimization can be implemented and the extent of its efficiency.

Profiling is a process for dynamically collecting program information (instructions and data statistics) that is used to guide optimization during the translation process. The main way to obtain profile information is to inject a few instructions into target code. However, this inevitably leads to performance loss, and complex profile mechanisms are not suitable at runtime. Actually, it is also not practical to perform a complex optimization algorithm at runtime, because the cost of these algorithms cannot be endured in a dynamic environment. Hence, in order to generate more nearly optimal binary target code using complex profile information and optimization algorithms, it is necessary to construct a binary translation framework different from conventional ones.

Generally speaking, combining dynamic translation with static analysis has the following merits:

• Reducing Translation time: The process of translating source code to target code consumes a substantial amount of time. Once the source code is translated for the first run, the target code will be saved in a file which can be directly loaded for future runs;

• Eliminating profiling overhead: Profiling will be eliminated except for the first run. If all optimizations are performed statically, the profiling process is not necessary anymore;

• Performing complex optimizations: Because some optimizations can be carried out statically instead of at runtime, complex optimization algorithms which are not appropriate dynamically are now available without worrying about overhead.

The approach of using a profiling phase to aid dynamic binary translation assumes that the execution of each block in the profiling phase (initial run) is representative of the block throughout its lifetime. In particular, a region is selected for optimization under the assumption that it rarely takes its side exits. If the assumption above does not hold, and the optimized regions often take their side exits, the program performance will suffer [12].

In order to explore new optimization opportunities and use the detailed profile information, we design and implement a new a DBT framework, named static-integrated optimization framework for DBT (SINOF). The framework is based on Crossbit [1] which is a multi-source and multi-target DBT aiming at quickly migrating existing executable code from one platform to an alien target platform at low cost.

In this paper, we make the following contributions:

• A new dynamic-static combined DBT framework (SINOF): Generally speaking, this framework can be divided into three phases: gathering profile information during the first run, performing optimization in the static phase and loading the target code that has been optimized offline for the subsequent execution.

• Inter-edge profiling: The inter-edge profile tracks the relationship of two adjacent edges. In fact, the inter-edge profile is a particular case of a path profile, with only two edges in each path.

• A new approach to reframe code layout of a software cache: Reorganizing the code layout in the software cache can greatly improve the performance of a binary translator since the execution stream will be closer to its control flow graph after reframing. The process of reorganizing code layout is performed in the static analysis and optimization phase.

This paper is a continuation of the work in [13], which described the construction of the framework (SINOF), but without static optimization. The rest of the paper is organized as follows: Section 2 introduces the DBT system that our framework is based on Crossbit. Section 3 describes the details of the implementation of SINOF. Section 4 describes the performance evaluation. Section 5 gives some related work. The conclusion and discussion of future work are in the last section.