We describe the design and implementation of Dynamo, a software dynamic optimization system that is capable of transparently improving the performance of a native instruction stream as it executes on the processor. The input native instruction stream to Dynamo can be dynamically generated (by a JIT for example), or it can come from the execution of a statically compiled native binary. This paper evaluates the Dynamo system in the latter, more challenging situation, in order to emphasize the limits, rather than the potential, of the system. Our experiments demonstrate that even statically optimized native binaries can be accelerated Dynamo, and often by a significant degree. For example, the average performance of -O optimized SpecInt95 benchmark binaries created by the HP product C compiler is improved to a level comparable to their -O4 optimized version running without Dynamo. Dynamo achieves this by focusing its efforts on optimization opportunities that tend to manifest only at runtime, and hence opportunities that might be difficult for a static compiler to exploit. Dynamo's operation is transparent in the sense that it does not depend on any user annotations or binary instrumentation, and does not require multiple runs, or any special compiler, operating system or hardware support. The Dynamo prototype presented here is a realistic implementation running on an HP PA-8000 workstation under the HPUX 10.20 operating system.
%0 Conference Paper
%1 Bala:2000:DTD
%A Bala, Vasanth
%A Duesterwald, Evelyn
%A Banerjia, Sanjeev
%B Proceedings of the ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation
%D 2000
%I ACM
%K Compilation JIT NativeCode Optimization Trace Tracing
%P 1--12
%R 10.1145/358438.349303
%T Dynamo: A Transparent Dynamic Optimization System
%X We describe the design and implementation of Dynamo, a software dynamic optimization system that is capable of transparently improving the performance of a native instruction stream as it executes on the processor. The input native instruction stream to Dynamo can be dynamically generated (by a JIT for example), or it can come from the execution of a statically compiled native binary. This paper evaluates the Dynamo system in the latter, more challenging situation, in order to emphasize the limits, rather than the potential, of the system. Our experiments demonstrate that even statically optimized native binaries can be accelerated Dynamo, and often by a significant degree. For example, the average performance of -O optimized SpecInt95 benchmark binaries created by the HP product C compiler is improved to a level comparable to their -O4 optimized version running without Dynamo. Dynamo achieves this by focusing its efforts on optimization opportunities that tend to manifest only at runtime, and hence opportunities that might be difficult for a static compiler to exploit. Dynamo's operation is transparent in the sense that it does not depend on any user annotations or binary instrumentation, and does not require multiple runs, or any special compiler, operating system or hardware support. The Dynamo prototype presented here is a realistic implementation running on an HP PA-8000 workstation under the HPUX 10.20 operating system.
%@ 1-58113-199-2
@inproceedings{Bala:2000:DTD,
abstract = {We describe the design and implementation of Dynamo, a software dynamic optimization system that is capable of transparently improving the performance of a native instruction stream as it executes on the processor. The input native instruction stream to Dynamo can be dynamically generated (by a JIT for example), or it can come from the execution of a statically compiled native binary. This paper evaluates the Dynamo system in the latter, more challenging situation, in order to emphasize the limits, rather than the potential, of the system. Our experiments demonstrate that even statically optimized native binaries can be accelerated Dynamo, and often by a significant degree. For example, the average performance of -O optimized SpecInt95 benchmark binaries created by the HP product C compiler is improved to a level comparable to their -O4 optimized version running without Dynamo. Dynamo achieves this by focusing its efforts on optimization opportunities that tend to manifest only at runtime, and hence opportunities that might be difficult for a static compiler to exploit. Dynamo's operation is transparent in the sense that it does not depend on any user annotations or binary instrumentation, and does not require multiple runs, or any special compiler, operating system or hardware support. The Dynamo prototype presented here is a realistic implementation running on an HP PA-8000 workstation under the HPUX 10.20 operating system.},
acmid = {349303},
added-at = {2014-11-09T13:05:53.000+0100},
author = {Bala, Vasanth and Duesterwald, Evelyn and Banerjia, Sanjeev},
biburl = {https://www.bibsonomy.org/bibtex/206b8e73030524ad384a6e3ff2ddd089d/gron},
booktitle = {{Proceedings of the ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation}},
description = {Dynamo},
doi = {10.1145/358438.349303},
interhash = {fc30269a772ed7900c28a2a5bd6f17f0},
intrahash = {06b8e73030524ad384a6e3ff2ddd089d},
isbn = {1-58113-199-2},
keywords = {Compilation JIT NativeCode Optimization Trace Tracing},
location = {Vancouver, British Columbia, Canada},
month = may,
numpages = {12},
pages = {1--12},
publisher = {{ACM}},
series = {PLDI '00},
timestamp = {2023-04-08T20:04:10.000+0200},
title = {{Dynamo: A Transparent Dynamic Optimization System}},
year = 2000
}