Code Compression

Jens Ernst, William Evans, Christopher W. Fraser, Steven Lucco, Todd A Proebsting

Research output: Contribution to journalArticle

21 Citations (Scopus)

Abstract

Current research in compiler optimization counts mainly CPU time and perhaps the first cache level or two. This view has been important but is becoming myopic, at least from a system-wide viewpoint, as the ratio of network and disk speeds to CPU speeds grows exponentially. For example, we have seen the CPU idle for most of the time during paging, so compressing pages can increase total performance even though the CPU must decompress or interpret the page contents. Another profile shows that many functions are called just once, so reduced paging could pay for their interpretation overhead. This paper describes: • Measurements that show how code compression can save space and total time in some important real-world scenarios. • A compressed executable representation that is roughly the same size as gzipped x86 programs and can be interpreted without decompression. It can also be compiled to high-quality machine code at 2.5 megabytes per second on a 120MHz Pentium processor • A compressed "wire" representation that must be decompressed before execution but is, for example, roughly 21% the size of SPARC code when compressing gcc.

Original languageEnglish (US)
Pages (from-to)358-365
Number of pages8
JournalSIGPLAN Notices (ACM Special Interest Group on Programming Languages)
Volume32
Issue number5
StatePublished - May 1997
Externally publishedYes

Fingerprint

Program processors
Wire

ASJC Scopus subject areas

  • Computer Graphics and Computer-Aided Design
  • Software

Cite this

Ernst, J., Evans, W., Fraser, C. W., Lucco, S., & Proebsting, T. A. (1997). Code Compression. SIGPLAN Notices (ACM Special Interest Group on Programming Languages), 32(5), 358-365.

Code Compression. / Ernst, Jens; Evans, William; Fraser, Christopher W.; Lucco, Steven; Proebsting, Todd A.

In: SIGPLAN Notices (ACM Special Interest Group on Programming Languages), Vol. 32, No. 5, 05.1997, p. 358-365.

Research output: Contribution to journalArticle

Ernst, J, Evans, W, Fraser, CW, Lucco, S & Proebsting, TA 1997, 'Code Compression', SIGPLAN Notices (ACM Special Interest Group on Programming Languages), vol. 32, no. 5, pp. 358-365.
Ernst, Jens ; Evans, William ; Fraser, Christopher W. ; Lucco, Steven ; Proebsting, Todd A. / Code Compression. In: SIGPLAN Notices (ACM Special Interest Group on Programming Languages). 1997 ; Vol. 32, No. 5. pp. 358-365.
@article{43e5aa2d69f54399814a7eb4cb57226c,
title = "Code Compression",
abstract = "Current research in compiler optimization counts mainly CPU time and perhaps the first cache level or two. This view has been important but is becoming myopic, at least from a system-wide viewpoint, as the ratio of network and disk speeds to CPU speeds grows exponentially. For example, we have seen the CPU idle for most of the time during paging, so compressing pages can increase total performance even though the CPU must decompress or interpret the page contents. Another profile shows that many functions are called just once, so reduced paging could pay for their interpretation overhead. This paper describes: • Measurements that show how code compression can save space and total time in some important real-world scenarios. • A compressed executable representation that is roughly the same size as gzipped x86 programs and can be interpreted without decompression. It can also be compiled to high-quality machine code at 2.5 megabytes per second on a 120MHz Pentium processor • A compressed {"}wire{"} representation that must be decompressed before execution but is, for example, roughly 21{\%} the size of SPARC code when compressing gcc.",
author = "Jens Ernst and William Evans and Fraser, {Christopher W.} and Steven Lucco and Proebsting, {Todd A}",
year = "1997",
month = "5",
language = "English (US)",
volume = "32",
pages = "358--365",
journal = "ACM SIGPLAN Notices",
issn = "1523-2867",
publisher = "Association for Computing Machinery (ACM)",
number = "5",

}

TY - JOUR

T1 - Code Compression

AU - Ernst, Jens

AU - Evans, William

AU - Fraser, Christopher W.

AU - Lucco, Steven

AU - Proebsting, Todd A

PY - 1997/5

Y1 - 1997/5

N2 - Current research in compiler optimization counts mainly CPU time and perhaps the first cache level or two. This view has been important but is becoming myopic, at least from a system-wide viewpoint, as the ratio of network and disk speeds to CPU speeds grows exponentially. For example, we have seen the CPU idle for most of the time during paging, so compressing pages can increase total performance even though the CPU must decompress or interpret the page contents. Another profile shows that many functions are called just once, so reduced paging could pay for their interpretation overhead. This paper describes: • Measurements that show how code compression can save space and total time in some important real-world scenarios. • A compressed executable representation that is roughly the same size as gzipped x86 programs and can be interpreted without decompression. It can also be compiled to high-quality machine code at 2.5 megabytes per second on a 120MHz Pentium processor • A compressed "wire" representation that must be decompressed before execution but is, for example, roughly 21% the size of SPARC code when compressing gcc.

AB - Current research in compiler optimization counts mainly CPU time and perhaps the first cache level or two. This view has been important but is becoming myopic, at least from a system-wide viewpoint, as the ratio of network and disk speeds to CPU speeds grows exponentially. For example, we have seen the CPU idle for most of the time during paging, so compressing pages can increase total performance even though the CPU must decompress or interpret the page contents. Another profile shows that many functions are called just once, so reduced paging could pay for their interpretation overhead. This paper describes: • Measurements that show how code compression can save space and total time in some important real-world scenarios. • A compressed executable representation that is roughly the same size as gzipped x86 programs and can be interpreted without decompression. It can also be compiled to high-quality machine code at 2.5 megabytes per second on a 120MHz Pentium processor • A compressed "wire" representation that must be decompressed before execution but is, for example, roughly 21% the size of SPARC code when compressing gcc.

UR - http://www.scopus.com/inward/record.url?scp=0347934833&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=0347934833&partnerID=8YFLogxK

M3 - Article

AN - SCOPUS:0347934833

VL - 32

SP - 358

EP - 365

JO - ACM SIGPLAN Notices

JF - ACM SIGPLAN Notices

SN - 1523-2867

IS - 5

ER -