Simple approach to supporting untagged objects in dynamically typed languages

Peter A. Bigot, Saumya K Debray

Research output: Contribution to journalArticle

Abstract

In many modern high-level programming languages, the exact low-level representation of data objects cannot always be predicted at compile-time. Implementations usually get around this problem using descriptors ('tags') and/or indirect ('boxed') representations. However, the flexibility so gained can come at the cost of significant performance overheads. The problem is especially acute in dynamically typed languages, where both tagging and boxing are necessary in general. This paper discusses a straightforward approach to using untagged and unboxed values in dynamically typed languages. An implementation of our algorithms allows a dynamically typed language to attain performance close to that of highly optimized C code on a variety of benchmarks (including many floating-point intensive computations) and dramatically reduces heap usage.

Original languageEnglish (US)
Pages (from-to)25-47
Number of pages23
JournalJournal of Logic Programming
Volume32
Issue number1
DOIs
StatePublished - Jul 1997

Fingerprint

Computer programming languages
Representation of data
Heap
Tagging
Floating point
Acute
Descriptors
Programming Languages
Flexibility
Benchmark
Necessary
Object
Language

ASJC Scopus subject areas

  • Logic

Cite this

Simple approach to supporting untagged objects in dynamically typed languages. / Bigot, Peter A.; Debray, Saumya K.

In: Journal of Logic Programming, Vol. 32, No. 1, 07.1997, p. 25-47.

Research output: Contribution to journalArticle

@article{20727f3d5734440eb31348dc49f8cda9,
title = "Simple approach to supporting untagged objects in dynamically typed languages",
abstract = "In many modern high-level programming languages, the exact low-level representation of data objects cannot always be predicted at compile-time. Implementations usually get around this problem using descriptors ('tags') and/or indirect ('boxed') representations. However, the flexibility so gained can come at the cost of significant performance overheads. The problem is especially acute in dynamically typed languages, where both tagging and boxing are necessary in general. This paper discusses a straightforward approach to using untagged and unboxed values in dynamically typed languages. An implementation of our algorithms allows a dynamically typed language to attain performance close to that of highly optimized C code on a variety of benchmarks (including many floating-point intensive computations) and dramatically reduces heap usage.",
author = "Bigot, {Peter A.} and Debray, {Saumya K}",
year = "1997",
month = "7",
doi = "10.1016/S0743-1066(96)00108-2",
language = "English (US)",
volume = "32",
pages = "25--47",
journal = "Journal of Logic Programming",
issn = "1567-8326",
publisher = "Elsevier Inc.",
number = "1",

}

TY - JOUR

T1 - Simple approach to supporting untagged objects in dynamically typed languages

AU - Bigot, Peter A.

AU - Debray, Saumya K

PY - 1997/7

Y1 - 1997/7

N2 - In many modern high-level programming languages, the exact low-level representation of data objects cannot always be predicted at compile-time. Implementations usually get around this problem using descriptors ('tags') and/or indirect ('boxed') representations. However, the flexibility so gained can come at the cost of significant performance overheads. The problem is especially acute in dynamically typed languages, where both tagging and boxing are necessary in general. This paper discusses a straightforward approach to using untagged and unboxed values in dynamically typed languages. An implementation of our algorithms allows a dynamically typed language to attain performance close to that of highly optimized C code on a variety of benchmarks (including many floating-point intensive computations) and dramatically reduces heap usage.

AB - In many modern high-level programming languages, the exact low-level representation of data objects cannot always be predicted at compile-time. Implementations usually get around this problem using descriptors ('tags') and/or indirect ('boxed') representations. However, the flexibility so gained can come at the cost of significant performance overheads. The problem is especially acute in dynamically typed languages, where both tagging and boxing are necessary in general. This paper discusses a straightforward approach to using untagged and unboxed values in dynamically typed languages. An implementation of our algorithms allows a dynamically typed language to attain performance close to that of highly optimized C code on a variety of benchmarks (including many floating-point intensive computations) and dramatically reduces heap usage.

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

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

U2 - 10.1016/S0743-1066(96)00108-2

DO - 10.1016/S0743-1066(96)00108-2

M3 - Article

AN - SCOPUS:0031185544

VL - 32

SP - 25

EP - 47

JO - Journal of Logic Programming

JF - Journal of Logic Programming

SN - 1567-8326

IS - 1

ER -