Tag-free garbage collection for strongly typed programming languages

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

Abstract

With the emergence of a number of strongly typed languages with very dynamic storage allocation, efficient methods of storage reclamation have become especially important. Even though no type tags are required for type checking programs written in these languages, current implementations do use tags to support run time garbage collection. This often inflicts a high time and space overhead on program execution. Since the early days of LISP (and Algol68 later on), there have been schemes for performing tag-free garbage collection. In this paper, we describe an improvement of existing methods that leads to more effective storage reclamation in the absence of tags. Garbage collection has also traditionally been viewed as being independent of the particular program being executed. This means that results of compile-time analyses which could increase the effectiveness of garbage collection cannot be incorporated easily into the garbage collection process. This paper describes a method for performing garbage collection 1) in the absence of tagged data, and 2) using compile-time information. This method relies on compiler-generated garbage collection routines specific to the program being executed and incurs no time overhead during execution other then the cost of the garbage collection process itself. We describe tag-free garbage collection methods for monomorphically typed and polymorphically typed languages, and suggest how they might be extended to support parallel languages.

Original languageEnglish (US)
Title of host publicationProceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)
PublisherAssociation for Computing Machinery
Pages165-176
Number of pages12
VolumePart F129844
ISBN (Print)0897914287
StatePublished - May 1 1991
Event1991 ACM SIGPLAN 1991 Conference on Programming Language Design and Implementation, PLDI 1991 - Ottawa, Canada
Duration: Jun 24 1991Jun 28 1991

Other

Other1991 ACM SIGPLAN 1991 Conference on Programming Language Design and Implementation, PLDI 1991
CountryCanada
CityOttawa
Period6/24/916/28/91

Fingerprint

Reclamation
Computer programming languages
Costs

ASJC Scopus subject areas

  • Software

Cite this

Goldberg, B. (1991). Tag-free garbage collection for strongly typed programming languages. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI) (Vol. Part F129844, pp. 165-176). Association for Computing Machinery.

Tag-free garbage collection for strongly typed programming languages. / Goldberg, Benjamin.

Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). Vol. Part F129844 Association for Computing Machinery, 1991. p. 165-176.

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

Goldberg, B 1991, Tag-free garbage collection for strongly typed programming languages. in Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). vol. Part F129844, Association for Computing Machinery, pp. 165-176, 1991 ACM SIGPLAN 1991 Conference on Programming Language Design and Implementation, PLDI 1991, Ottawa, Canada, 6/24/91.
Goldberg B. Tag-free garbage collection for strongly typed programming languages. In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). Vol. Part F129844. Association for Computing Machinery. 1991. p. 165-176
Goldberg, Benjamin. / Tag-free garbage collection for strongly typed programming languages. Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI). Vol. Part F129844 Association for Computing Machinery, 1991. pp. 165-176
@inproceedings{c8ec5a39046848af994cdefa57598ade,
title = "Tag-free garbage collection for strongly typed programming languages",
abstract = "With the emergence of a number of strongly typed languages with very dynamic storage allocation, efficient methods of storage reclamation have become especially important. Even though no type tags are required for type checking programs written in these languages, current implementations do use tags to support run time garbage collection. This often inflicts a high time and space overhead on program execution. Since the early days of LISP (and Algol68 later on), there have been schemes for performing tag-free garbage collection. In this paper, we describe an improvement of existing methods that leads to more effective storage reclamation in the absence of tags. Garbage collection has also traditionally been viewed as being independent of the particular program being executed. This means that results of compile-time analyses which could increase the effectiveness of garbage collection cannot be incorporated easily into the garbage collection process. This paper describes a method for performing garbage collection 1) in the absence of tagged data, and 2) using compile-time information. This method relies on compiler-generated garbage collection routines specific to the program being executed and incurs no time overhead during execution other then the cost of the garbage collection process itself. We describe tag-free garbage collection methods for monomorphically typed and polymorphically typed languages, and suggest how they might be extended to support parallel languages.",
author = "Benjamin Goldberg",
year = "1991",
month = "5",
day = "1",
language = "English (US)",
isbn = "0897914287",
volume = "Part F129844",
pages = "165--176",
booktitle = "Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)",
publisher = "Association for Computing Machinery",

}

TY - GEN

T1 - Tag-free garbage collection for strongly typed programming languages

AU - Goldberg, Benjamin

PY - 1991/5/1

Y1 - 1991/5/1

N2 - With the emergence of a number of strongly typed languages with very dynamic storage allocation, efficient methods of storage reclamation have become especially important. Even though no type tags are required for type checking programs written in these languages, current implementations do use tags to support run time garbage collection. This often inflicts a high time and space overhead on program execution. Since the early days of LISP (and Algol68 later on), there have been schemes for performing tag-free garbage collection. In this paper, we describe an improvement of existing methods that leads to more effective storage reclamation in the absence of tags. Garbage collection has also traditionally been viewed as being independent of the particular program being executed. This means that results of compile-time analyses which could increase the effectiveness of garbage collection cannot be incorporated easily into the garbage collection process. This paper describes a method for performing garbage collection 1) in the absence of tagged data, and 2) using compile-time information. This method relies on compiler-generated garbage collection routines specific to the program being executed and incurs no time overhead during execution other then the cost of the garbage collection process itself. We describe tag-free garbage collection methods for monomorphically typed and polymorphically typed languages, and suggest how they might be extended to support parallel languages.

AB - With the emergence of a number of strongly typed languages with very dynamic storage allocation, efficient methods of storage reclamation have become especially important. Even though no type tags are required for type checking programs written in these languages, current implementations do use tags to support run time garbage collection. This often inflicts a high time and space overhead on program execution. Since the early days of LISP (and Algol68 later on), there have been schemes for performing tag-free garbage collection. In this paper, we describe an improvement of existing methods that leads to more effective storage reclamation in the absence of tags. Garbage collection has also traditionally been viewed as being independent of the particular program being executed. This means that results of compile-time analyses which could increase the effectiveness of garbage collection cannot be incorporated easily into the garbage collection process. This paper describes a method for performing garbage collection 1) in the absence of tagged data, and 2) using compile-time information. This method relies on compiler-generated garbage collection routines specific to the program being executed and incurs no time overhead during execution other then the cost of the garbage collection process itself. We describe tag-free garbage collection methods for monomorphically typed and polymorphically typed languages, and suggest how they might be extended to support parallel languages.

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

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

M3 - Conference contribution

SN - 0897914287

VL - Part F129844

SP - 165

EP - 176

BT - Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI)

PB - Association for Computing Machinery

ER -