Static analysis for optimizing reference counting

Young Park, Benjamin Goldberg

Research output: Contribution to journalArticle

Abstract

In reference counting schemes for automatically reclaiming storage, each time a reference to a heap-allocated object is created or destroyed, the reference count of the object needs to be updated. This may involve expensive inter-processor message exchanges in distributed environments. This overhead can be reduced by analyzing the lifetimes of references to avoid unnecessary updatings. We present a compile-time analysis for higher-order functional languages that determines whether the lifetime of a reference exceeds the lifetime of the environment in which the reference was created. Using this statically inferred information, a method for optimizing reference counting schemes is described. Our method can be applied to reference counting schemes in both uniprocessor and multiprocessor environments.

Original languageEnglish (US)
Pages (from-to)229-234
Number of pages6
JournalInformation Processing Letters
Volume55
Issue number4
DOIs
StatePublished - Aug 25 1995

Fingerprint

Static analysis
Static Analysis
Counting
Lifetime
Heap
Distributed Environment
Multiprocessor
Updating
Exceed
Count
Higher Order
Object

Keywords

  • Distributed systems
  • Formal semantics
  • Functional programming
  • Garbage collection
  • Language processors
  • Programming languages
  • Reference count
  • Static analysis

ASJC Scopus subject areas

  • Computer Science Applications
  • Information Systems
  • Signal Processing
  • Theoretical Computer Science
  • Computational Theory and Mathematics

Cite this

Static analysis for optimizing reference counting. / Park, Young; Goldberg, Benjamin.

In: Information Processing Letters, Vol. 55, No. 4, 25.08.1995, p. 229-234.

Research output: Contribution to journalArticle

@article{6dfa1d35f4a74ef6bd600a71fa33df82,
title = "Static analysis for optimizing reference counting",
abstract = "In reference counting schemes for automatically reclaiming storage, each time a reference to a heap-allocated object is created or destroyed, the reference count of the object needs to be updated. This may involve expensive inter-processor message exchanges in distributed environments. This overhead can be reduced by analyzing the lifetimes of references to avoid unnecessary updatings. We present a compile-time analysis for higher-order functional languages that determines whether the lifetime of a reference exceeds the lifetime of the environment in which the reference was created. Using this statically inferred information, a method for optimizing reference counting schemes is described. Our method can be applied to reference counting schemes in both uniprocessor and multiprocessor environments.",
keywords = "Distributed systems, Formal semantics, Functional programming, Garbage collection, Language processors, Programming languages, Reference count, Static analysis",
author = "Young Park and Benjamin Goldberg",
year = "1995",
month = "8",
day = "25",
doi = "10.1016/0020-0190(95)00096-U",
language = "English (US)",
volume = "55",
pages = "229--234",
journal = "Information Processing Letters",
issn = "0020-0190",
publisher = "Elsevier",
number = "4",

}

TY - JOUR

T1 - Static analysis for optimizing reference counting

AU - Park, Young

AU - Goldberg, Benjamin

PY - 1995/8/25

Y1 - 1995/8/25

N2 - In reference counting schemes for automatically reclaiming storage, each time a reference to a heap-allocated object is created or destroyed, the reference count of the object needs to be updated. This may involve expensive inter-processor message exchanges in distributed environments. This overhead can be reduced by analyzing the lifetimes of references to avoid unnecessary updatings. We present a compile-time analysis for higher-order functional languages that determines whether the lifetime of a reference exceeds the lifetime of the environment in which the reference was created. Using this statically inferred information, a method for optimizing reference counting schemes is described. Our method can be applied to reference counting schemes in both uniprocessor and multiprocessor environments.

AB - In reference counting schemes for automatically reclaiming storage, each time a reference to a heap-allocated object is created or destroyed, the reference count of the object needs to be updated. This may involve expensive inter-processor message exchanges in distributed environments. This overhead can be reduced by analyzing the lifetimes of references to avoid unnecessary updatings. We present a compile-time analysis for higher-order functional languages that determines whether the lifetime of a reference exceeds the lifetime of the environment in which the reference was created. Using this statically inferred information, a method for optimizing reference counting schemes is described. Our method can be applied to reference counting schemes in both uniprocessor and multiprocessor environments.

KW - Distributed systems

KW - Formal semantics

KW - Functional programming

KW - Garbage collection

KW - Language processors

KW - Programming languages

KW - Reference count

KW - Static analysis

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

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

U2 - 10.1016/0020-0190(95)00096-U

DO - 10.1016/0020-0190(95)00096-U

M3 - Article

VL - 55

SP - 229

EP - 234

JO - Information Processing Letters

JF - Information Processing Letters

SN - 0020-0190

IS - 4

ER -