Reference escape analysis: Optimizing reference counting based on the lifetime of references

Young Gil Park, Benjamin Goldberg

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

In reference counting schemes for automatically reclaiming storage, each time a reference to an 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. This paper describes a technique for reducing the runtime reference counting overhead through compile-time optimization. We present a compile-time analysis called reference escape 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)
Title of host publicationProceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation
PublisherAssociation for Computing Machinery
Pages178-189
Number of pages12
ISBN (Print)0897914333
StatePublished - May 1 1991
Event1991 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, PEPM 1991 - New Haven, United States
Duration: Jun 17 1991Jun 19 1991

Other

Other1991 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, PEPM 1991
CountryUnited States
CityNew Haven
Period6/17/916/19/91

ASJC Scopus subject areas

  • Software

Cite this

Park, Y. G., & Goldberg, B. (1991). Reference escape analysis: Optimizing reference counting based on the lifetime of references. In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (pp. 178-189). Association for Computing Machinery.

Reference escape analysis : Optimizing reference counting based on the lifetime of references. / Park, Young Gil; Goldberg, Benjamin.

Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation. Association for Computing Machinery, 1991. p. 178-189.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Park, YG & Goldberg, B 1991, Reference escape analysis: Optimizing reference counting based on the lifetime of references. in Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation. Association for Computing Machinery, pp. 178-189, 1991 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation, PEPM 1991, New Haven, United States, 6/17/91.
Park YG, Goldberg B. Reference escape analysis: Optimizing reference counting based on the lifetime of references. In Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation. Association for Computing Machinery. 1991. p. 178-189
Park, Young Gil ; Goldberg, Benjamin. / Reference escape analysis : Optimizing reference counting based on the lifetime of references. Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation. Association for Computing Machinery, 1991. pp. 178-189
@inproceedings{b81d53a9a7ed4c37adaa32a85db40a63,
title = "Reference escape analysis: Optimizing reference counting based on the lifetime of references",
abstract = "In reference counting schemes for automatically reclaiming storage, each time a reference to an 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. This paper describes a technique for reducing the runtime reference counting overhead through compile-time optimization. We present a compile-time analysis called reference escape 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.",
author = "Park, {Young Gil} and Benjamin Goldberg",
year = "1991",
month = "5",
day = "1",
language = "English (US)",
isbn = "0897914333",
pages = "178--189",
booktitle = "Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation",
publisher = "Association for Computing Machinery",

}

TY - GEN

T1 - Reference escape analysis

T2 - Optimizing reference counting based on the lifetime of references

AU - Park, Young Gil

AU - Goldberg, Benjamin

PY - 1991/5/1

Y1 - 1991/5/1

N2 - In reference counting schemes for automatically reclaiming storage, each time a reference to an 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. This paper describes a technique for reducing the runtime reference counting overhead through compile-time optimization. We present a compile-time analysis called reference escape 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 an 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. This paper describes a technique for reducing the runtime reference counting overhead through compile-time optimization. We present a compile-time analysis called reference escape 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.

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

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

M3 - Conference contribution

SN - 0897914333

SP - 178

EP - 189

BT - Proceedings of the ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation

PB - Association for Computing Machinery

ER -