Compilation framework for code size reduction using reduced bit-width ISAs (rISAs)

Aviral Shrivastava, Partha Biswas, Ashok Halambi, Nikil Dutt, Alex Nicolau

Research output: Contribution to journalArticle

11 Citations (Scopus)

Abstract

For many embedded applications, program code size is a critical design factor. One promising approach for reducing code size is to employ a "dual instruction set", where processor architectures support a normal (usually 32-bit) Instruction Set, and a narrow, space-efficient (usually 16-bit) Instruction Set with a limited set of opcodes and access to a limited set of registers. This feature however, requires compilers that can reduce code size by compiling for both Instruction Sets. Existing compiler techniques operate at the routine-level granularity and are unable to make the trade-off between increased register pressure (resulting in more spills) and decreased code size. We present a compilation framework for such dual instruction sets, which uses a profitability based compiler heuristic that operates at the instruction-level granularity and is able to effectively take advantage of both Instruction Sets. We demonstrate consistent and improved code size reduction (on average 22%), for the MIPS 32/16 bit ISA. We also show that the code compression obtained by this "dual instruction set" technique is heavily dependent on the application characteristics and the narrow Instruction Set itself.

Original languageEnglish (US)
Pages (from-to)123-146
Number of pages24
JournalACM Transactions on Design Automation of Electronic Systems
Volume11
Issue number1
StatePublished - 2006
Externally publishedYes

Fingerprint

Hazardous materials spills
Application programs
Profitability

Keywords

  • Code compression
  • Code generation
  • Codesize reduction
  • Compilers
  • Dual instruction set
  • Narrow bit-width instruction set
  • Optimization
  • Register pressure-based code generation
  • Retargetable compilers
  • rISA
  • Thumb

ASJC Scopus subject areas

  • Hardware and Architecture
  • Computer Graphics and Computer-Aided Design
  • Software

Cite this

Compilation framework for code size reduction using reduced bit-width ISAs (rISAs). / Shrivastava, Aviral; Biswas, Partha; Halambi, Ashok; Dutt, Nikil; Nicolau, Alex.

In: ACM Transactions on Design Automation of Electronic Systems, Vol. 11, No. 1, 2006, p. 123-146.

Research output: Contribution to journalArticle

Shrivastava, Aviral ; Biswas, Partha ; Halambi, Ashok ; Dutt, Nikil ; Nicolau, Alex. / Compilation framework for code size reduction using reduced bit-width ISAs (rISAs). In: ACM Transactions on Design Automation of Electronic Systems. 2006 ; Vol. 11, No. 1. pp. 123-146.
@article{ccd84e32d125464aba5edda95dbacbb7,
title = "Compilation framework for code size reduction using reduced bit-width ISAs (rISAs)",
abstract = "For many embedded applications, program code size is a critical design factor. One promising approach for reducing code size is to employ a {"}dual instruction set{"}, where processor architectures support a normal (usually 32-bit) Instruction Set, and a narrow, space-efficient (usually 16-bit) Instruction Set with a limited set of opcodes and access to a limited set of registers. This feature however, requires compilers that can reduce code size by compiling for both Instruction Sets. Existing compiler techniques operate at the routine-level granularity and are unable to make the trade-off between increased register pressure (resulting in more spills) and decreased code size. We present a compilation framework for such dual instruction sets, which uses a profitability based compiler heuristic that operates at the instruction-level granularity and is able to effectively take advantage of both Instruction Sets. We demonstrate consistent and improved code size reduction (on average 22{\%}), for the MIPS 32/16 bit ISA. We also show that the code compression obtained by this {"}dual instruction set{"} technique is heavily dependent on the application characteristics and the narrow Instruction Set itself.",
keywords = "Code compression, Code generation, Codesize reduction, Compilers, Dual instruction set, Narrow bit-width instruction set, Optimization, Register pressure-based code generation, Retargetable compilers, rISA, Thumb",
author = "Aviral Shrivastava and Partha Biswas and Ashok Halambi and Nikil Dutt and Alex Nicolau",
year = "2006",
language = "English (US)",
volume = "11",
pages = "123--146",
journal = "ACM Transactions on Design Automation of Electronic Systems",
issn = "1084-4309",
publisher = "Association for Computing Machinery (ACM)",
number = "1",

}

TY - JOUR

T1 - Compilation framework for code size reduction using reduced bit-width ISAs (rISAs)

AU - Shrivastava, Aviral

AU - Biswas, Partha

AU - Halambi, Ashok

AU - Dutt, Nikil

AU - Nicolau, Alex

PY - 2006

Y1 - 2006

N2 - For many embedded applications, program code size is a critical design factor. One promising approach for reducing code size is to employ a "dual instruction set", where processor architectures support a normal (usually 32-bit) Instruction Set, and a narrow, space-efficient (usually 16-bit) Instruction Set with a limited set of opcodes and access to a limited set of registers. This feature however, requires compilers that can reduce code size by compiling for both Instruction Sets. Existing compiler techniques operate at the routine-level granularity and are unable to make the trade-off between increased register pressure (resulting in more spills) and decreased code size. We present a compilation framework for such dual instruction sets, which uses a profitability based compiler heuristic that operates at the instruction-level granularity and is able to effectively take advantage of both Instruction Sets. We demonstrate consistent and improved code size reduction (on average 22%), for the MIPS 32/16 bit ISA. We also show that the code compression obtained by this "dual instruction set" technique is heavily dependent on the application characteristics and the narrow Instruction Set itself.

AB - For many embedded applications, program code size is a critical design factor. One promising approach for reducing code size is to employ a "dual instruction set", where processor architectures support a normal (usually 32-bit) Instruction Set, and a narrow, space-efficient (usually 16-bit) Instruction Set with a limited set of opcodes and access to a limited set of registers. This feature however, requires compilers that can reduce code size by compiling for both Instruction Sets. Existing compiler techniques operate at the routine-level granularity and are unable to make the trade-off between increased register pressure (resulting in more spills) and decreased code size. We present a compilation framework for such dual instruction sets, which uses a profitability based compiler heuristic that operates at the instruction-level granularity and is able to effectively take advantage of both Instruction Sets. We demonstrate consistent and improved code size reduction (on average 22%), for the MIPS 32/16 bit ISA. We also show that the code compression obtained by this "dual instruction set" technique is heavily dependent on the application characteristics and the narrow Instruction Set itself.

KW - Code compression

KW - Code generation

KW - Codesize reduction

KW - Compilers

KW - Dual instruction set

KW - Narrow bit-width instruction set

KW - Optimization

KW - Register pressure-based code generation

KW - Retargetable compilers

KW - rISA

KW - Thumb

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

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

M3 - Article

VL - 11

SP - 123

EP - 146

JO - ACM Transactions on Design Automation of Electronic Systems

JF - ACM Transactions on Design Automation of Electronic Systems

SN - 1084-4309

IS - 1

ER -