Garbage Collecting the Internet: A Survey of Distributed Garbage Collection

ACM Computing Surveys

Volumn 30, Issue 3, 1998, Pages 330-373

  Abdullahi, Saleh E ^a   Ringwood, Graem A ^a  

^a QUEEN MARY UNIVERSITY OF LONDON   (United Kingdom)

Author keywords

C.2.4 Computer Communications Networks : Distributed Systems; D.1.3 Programming Techniques : Concurrent Programming, Distributed Programming, Parallel Programming; D.4.2 Operating Systems : Storage Management; D.4.3 File Systems Management

Indexed keywords

COMPUTER SYSTEMS PROGRAMMING; DATA ACQUISITION; DATA COMMUNICATION SYSTEMS; DATA STRUCTURES; DATABASE SYSTEMS; INTERNET; JAVA PROGRAMMING LANGUAGE; OBJECT ORIENTED PROGRAMMING; STORAGE ALLOCATION (COMPUTER);

DISTRIBUTED FILE SYSTEMS;

DISTRIBUTED COMPUTER SYSTEMS;

EID: 0032156882     PISSN: 03600300     EISSN: None     Source Type: Journal    
DOI: 10.1145/292469.292471     Document Type: Review

References (215)

1. ABDULLAHI, S. E. 1992. Managing computer memory: Dynamic allocation and deallocation strategies. In Proceedings of the 2nd Conference on Information Technology and its Applications (Leicester UK, Dec. 19-20), 25-40.
2. _. 1994. Recycling garbage. In Proceedings of the 3rd Conference on Information Technology and its Applications (Leicester, UK, April 2-3), 192-197.
3. _. 1995. Empirical studies of distributed garbage collection. Ph.D. thesis, Dec. 1995. Univ. of London.
4. ABDULLAHI, S. E. AND EDEMENANG, E. J. A. 1993. A comparative study of dynamic memory management techniques. Advances in Model. Anal. 15, 2, 17-31.
5. ABDULLAHI, S. E. AND RINGWOOD, G. A. 1996. Empirical studies of distributed garbage collection parts I, II, and III. TR, Dept. of Computer Science, QMW College, Univ. of London.
6. ABDULLAHI, S. E., MIRANDA, E. E., AND RINGWOOD, G. A. 1992. Collection schemes for distributed garbage. In Proceedings of the International Workshop on Memory Management (St. Malo, France). LNCS 637, Springer-Verlag, 43-81.
7. AGHA, G. 1986. Actors: A Model of Concurrent Computation in Distributed Systems, MIT Press, Cambridge, MA.
8. ALMES, G., BORNING, A., AND MESSINGER, E. 1983. Implementing a Smalltalk-80 system on the Intel 432: A feasibility study. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, 175-187.
9. AMSALEG, L., GRUBER, O., AND FRANKLIN, M. 1995. Efficient incremental garbage collection for workstation-server database systems. In Proceedings of the 21st International Conference on Very Large Data Bases (Zurich, Switzerland).
10. ANDREWS, G. R. 1991. Concurrent Programming - Principles and Practice. Benjamin/ Cummings.
11. APPLEBY, K., CARLSSON, M., HARIDI, S., AND SAHLIN, D. 1983. Garbage collection for Prolog based on WAM. Commun. ACM 31, 6, 719-741.
12. ARNBORG, S. 1974. Optimal memory management in a system with garbage collection. BIT 14, 375-381.
13. ARVIND, V. K. AND IANNUCCI, R. A. 1987. Two fundamental issues in multiprogramming. In Proceedings of the Conference on Parallel Processing in Science and Engineering (Bonn-Bad Godesberg), 61-68.
14. ATKINSON, M. P., BAILEY, P. J., CHISHOLM, K. J., COCKSHOTT, P. W., AND MORRISON, R. 1983. An approach to persistent programming. Computer J. 26, 4, 360-365.
15. AUGUSTEIJN, L. 1987. Garbage collection in a distributed environment. In PARLE'87 - Parallel Architectures and Languages Europe. LNCS 259, Springer-Verlag, 75-93.
16. BABAOGLU, O. AND MARZULLO, K. 1993. Consistent global states of distributed systems: Fundamental concepts and mechanisms. In Distributed Systems, Addison-Wesley.
17. BADEN, S. B. 1983. Low-overhead storage reclamation in the Smalltalk-80 virtual machine. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, 331-342.
18. BAECKER, H. D. 1972. Garbage collection for virtual memory computer systems. Commun. ACM 15, 11, 981-986.
19. BAKER, H. G. 1978. List processing in real-time on a serial computer. Commun. ACM 21, 4, 280-294.
20. _ 1992. The treadmill: Real-time garbage collection without motion sickness. ACM SIGPLAN Not. 27, 3 (March), 66-70.
21. BAL, H. 1990. Programming Distributed Systems, Prentice Hall, Englewood Cliffs, NJ.
22. BALLARD, S. AND SHIRRON, S. 1983. The design and implementation of VAX/Smalltalk-80. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, 127-150.
23. BARACH, D. R., TAENZER, D. H., AND WELLS, R. E. 1982. A technique for finding storage allocation errors in C-language programs. ACM SIGPLAN Not. 17, 5 (March), 16-23.
24. BARTBARA, L. AND RIRKA, L. 1986. Highly-available distributed services and fault-tolerant distributed garbage collection. In Proceedings of the 5th Symposium on the Principles of Distributed Computing (Aug.), ACM, 29-39.
25. BARTLETT, J. F. 1990. A generational, compacting garbage collector for C++. Position paper, ECOOP/OOPSLA '90 Workshop on Garbage Collection.
26. BATES, R. L., DYER, D., AND KOOMEN, J. A. G. M. 1982. Implementation of Interlisp on the VAX. In Proceedings of the ACM Symposium on Lisp and Functional Programming (Pittsburgh, PA, Aug. 15-18, 81-87.
27. BEKKERS, Y. AND COHEN, J. 1992. General discussions. In Proceedings of the International Workshop on Memory Management (St. Malo, France). LNCS 637, Springer-Verlag.
28. BEKKERS, Y., RIDOUX, O., AND UNGARO, L. 1992. Dynamic memory management for sequential logic programming languages. In Proceedings of the International Workshop on Memory Management (St. Malo, France). LNCS 637, Springer-Verlag, 82-102.
29. BEN-ARI, M. 1984. Algorithms for on-the-fly garbage collection. ACM Trans. Program. Lang. Syst. 6, 333-344.
30. BENNETT, J. K. 1987. The design and implementation of distributed Smalltalk. OOPSLA '87. ACM SIGPLAN Not. 22, 12, 318-330.
31. BENGTSSON, M. AND MAGNUSSON, B. 1990. Real-time compacting garbage collection. Position paper. In Proceedings of the ECOOPI OOPSLA '90 Workshop on Garbage Collection.
32. BEVAN, D. I. 1987. Distributed garbage collection using reference counting. In PARLE '87 -Parallel Architectures and Languages Europe. LNCS 259, Springer-Verlag, 176-187.
33. BLACK, A., HUTCHINSON, N., JUL, E., LEVY, H., AND CARTER, L. 1987. Distribution and abstract types in Emerald. ACM Trans. Softw. Eng. 13, 1, 65-76.
34. BIRRELL, A., EVERS, D., NELSON, G., OWICKI, S., AND WOBBER, E. 1993. Distributed garbage, collection for network objects. TR 116, Digital Equipment Corp. Research Center.
35. BISHOP, B. 1977. Computer systems with very large address space and garbage collection, Ph.D. thesis, MIT, Cambridge, MA.
36. BOBROW, D. G. 1980. Managing reentrant structures using reference counts. ACM Trans. Program. Lang. Syst. 2, 3, 269-273.
37. BOEHM, J. AND WEISER, M. 1988. Garbage collection in an uncooperative environment. Softw. Pract. Exper. 18, 9, 807-820.
38. BROOKS, R. A., GABRIEL, R. P., AND STEELE, G. L. 1982. S-1 common Lisp implementation. In Proceedings of the ACM Symposium on Lisp and Functional Programming (Pittsburgh, PA, Aug. 15-18), 108-113.
39. BROWNBRIDGE, D. R. 1985. Cyclic reference counting for combinator machines. In Functional Programming Languages and Computer Architecture. LNCS 201, Springer-Verlag, 273-288.
40. CARLSSON, S., MATTSSON, C., AND BENGTSSON, M. 1990. A fast expected-time compacting garbage collection algorithm. Position paper. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection.
41. CHAMBERS, C., UNGAR, D., AND LEE, E. 1989. An efficient implementation of SELF: A dynamically-typed object-oriented language based on prototypes. OOPSLA '89, ACM SIGPLAN Not. 24, 10, 49-70.
42. CHAMBERS, F. B., DUCE, D. A., AND JONES, G. P., EDS. 1984. Distributed Computing, Academic Press. London.
43. CHENEY, C. J. 1970. A non-recursive list compacting algorithm. Commun. ACM 13, 11, 677-678.
44. CHIKAYAMA, T. AND KIMURA, Y. 1987. Multiple reference management. In Flat GHC, ICLP, MIT Press, 276-293.
45. CLARK, D. W. AND GREEN, C. C. 1977. An empirical study of list structure in Lisp. Commun. ACM 20, 2, 78-86.
46. CLARK, D. W. AND GREEN, C. C. 1977. A note on shared list structure in Lisp. Inf. Process. Lett. 7, 6, 312-314.
47. COHEN, J. 1981. Garbage collection of linked data structures. ACM Comput. Surv. 13, 3, 341-367.
48. COHEN, J. AND NICOLAU, A. 1983. Comparison of compacting algorithms for garbage collection. ACM Trans. Program. Lang. Syst. 5, 4, 532-553.
49. COHEN, J. AND TRILLING, L. 1967. Remarks on garbage collection using a two level storage. BIT 7, 1, 22-30.
50. COLLINS, G. E. 1960. A method for overlapping and erasure of lists. Commun. ACM 3, 12, 655-657.
51. COULOURIS, G. F., DOLLIMORE, J., AND KINDBERG, T. 1994. Distributed Systems: Concepts and Design 2nd ed., Addison-Wesley.
52. COURTS, R. 1988. Improving locality of reference in a garbage-collecting memory management system. Commun. ACM 31, 9, 1128-1138.
53. CRICHLOW, J. M. 1988. An Introduction to Distributed and Parallel Computing. Prentice Hall, Englewood Cliffs, NJ.
54. DAVIES, D. J. M. 1984. Memory occupancy patterns in garbage collection systems. Commun. ACM 27, 8, 819-825.
55. DAWSON, J. L. 1982. Improved effectiveness from a real-time Lisp garbage collector. In Proceedings of the ACM Symposium on Lisp and Functional Programming (Pittsburgh, PA, Aug. 15-18), 159-167.
56. DEHNEN, F. AND LINS, R. D. 1994. Distributed cyclic reference counting. In Parallel and Distributed Computing (Theory and Practice). LNCS 805, Springer-Verlag, 95-100.
57. DELLAR, C. N. R. 1980. Removing backing store administration from the CAP operating system. Oper. Syst. Rev. 14, 4, 9-41.
58. DELOBEL, C., LECLUSE, C., AND RICHARD, P. 1995. Databases: from Relational to Object-Oriented Systems. ITP.
59. DENNING, P. J. 1968. Thrashing: its causes and prevention. In Proceedings of the AFIPS National Computer Conference, 915-922.
60. DERBYSHIRE, M. H. 1990. Mark-scan garbage collection on a distributed architecture. Lisp and Symbolic Comput. 3, 2, 135-170.
61. DETLEFS, D. L. 1990a. Concurrent garbage collection for C++. Tech. Rep. CMU-CS-90-119, School of Computer Science, Carnegie Mellon Univ., Pittsburgh, PA.
62. _. 1990b. Concurrent, atomic garbage collection. Position paper. ECOOP/OOPSLA '90 Workshop on Garbage Collection.
63. _. 1991. Concurrent, atomic garbage collection. Ph.D. thesis, Tech. Rep. CMU-CS-90-177, Dept. of Computer Science, Carnegie Mellon Univ., Pittsburgh, PA.
64. DEMERS, A., WEISER, M., HAYES, B., BOEHM, H., BOBROW, D., AND SHENKER, S. 1990. Combining generational and conservative garbage collection: framework and implementations. In Proceedings of the ACM Symposium on Principles of Programming Languages, 261-269.
65. DETREVILLE, J. 1990. Experience with garbage collection for Modula-2+ in the Topaz environment. In Proceedings of the ECOOP/ OOPSLA '90 Workshop on Garbage Collection, position paper.
66. DEUTSCH, L. P. 1983. The Dorado Smalltalk-80 implementation: Hardware architecture's impact on software architecture. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, Reading, MA, 113-125.
67. DEUTSCH, L. P. AND BOBROW, D. G. 1976. An efficient, incremental, automatic garbage collector. Commun. ACM 19, 9, 522-526.
68. DICKMAN, P. 1991. Distributed object management in a non-small graph of autonomous networks with few failures. Ph.D. thesis, University of Cambridge.
69. DIJKSTRA, E. W. AND SCHÖLTEN, C. S. 1989. Termination detection for diffusing computations. Inf. Process. Lett., 11.
70. DIJKSTRA, E. W., LAMPORT, L., MARTIN, A. J., AND STEFFENS, E. F. M. 1978. On-the-fly garbage collection: An exercise in cooperation. Commun. ACM 21, 11, 966-975.
71. DOLEY, D., DWORK, C., AND STOCKMEYER, L. 1987. On the minimal synchronism needed for diatributed consensus. J. ACM 34, 1, 77-97.
72. EDELSON, D. AND POHL, I. 1990. The case for garbage collector in C++. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
73. EL-HABBASH, A., HORN, C., AND HARRIS, M. 1990. Garbage collection in an object oriented, distributed, persistent environment. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
74. FALCONE, J. R. AND STINGER, J. R. 1983. The Smalltalk-80 implementation at Hewlett-Packard. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, Reading, MA, 79-112.
75. FENICHEL, R. R. AND YOCHELSON, J. C. 1969. A LISP garbage-collector for virtual-memory computer systems. Commun. ACM 12, 11, 611-612.
76. FERREIRA, P. 1990. Storage reclamation. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
77. FERREIRA, P. AND SHAPIRO, M. 1994. Garbage collection and DSM consistency. In Proceedings of the First Symposium on Operating Systems Design and Implementation, 229-241.
78. FISCHER, M. J., LYNCH, N. A., AND PATERSON, M. S. 1985. Impossibility of distributed consensus with one faulty process. J. ACM 32, 2, 374-382.
79. FISHER, D. A. 1974. Bounded workspace garbage collection in an address-order preserving list processing environment. Inf. Process. Lett. 3, 1, 29-32.
80. FODERARO, J. K. AND FATEMAN, R. J. 1981. Characterization of VAX Macsyma. In Proceedings of the 1981 ACM Symposium on Symbolic and Algebraic Computation, 14-19.
81. FOWLER, R. J. 1986. The complexity of using forwarding addresses for decentralized object finding. In Proceedings of the Fifth Annual ACM Symposium on Principles of Distributed Computing, 108-120.
82. FRIEDMAN, D. P. AND WISE, D. S. 1976. Garbage collecting a heap which includes a scatter table. Inf. Process. Lett. 5, 6, 161-164.
83. FRIEDMAN, D. P. AND WISE, D. S. 1977. The one-bit reference count. BIT 17, 351-359.
84. FRIEDMAN, D. P. AND WISE, D. S. 1979. Reference counting can manage the circular environments of mutual recursion. Inf. Process. Lett. 8, 1, 41-45.
85. FUCHS, M. 1995. Garbage collection on an open network. In Memory Management, Proceedings of the IWMM95, LNCS 986, H. G. Baker, Ed., Springer-Verlag, New York, 251-265.
86. GABRIEL, R. P. AND MANSINTER, L. M. 1982. Performance of Lisp systems. In Proceedings of the ACM Symposium on Lisp and Functional Programming (Pittsburgh, PA, August 15-18), 123-142.
87. GARNETT, N. H. AND NEEDHAM, R. M. 1980. An asynchronous garbage collector for the Cambridge file server. Oper. Syst. Rev. 14, 4, 36-40.
88. GELERNTER, H., HANSEN, J. R., AND GERBERRICH, C. L. 1960. A FORTRAN-compiled list processing language. J. ACM 7, 2, 87-101.
89. GLASER, H. W. AND THOMPSON, P. 1985. Lazy garbage collection. Softw. Pract. Exper. 17, 1, 1-4.
90. GOLDBERG, A. AND ROBSON, D. 1983. Smalltalk-80, The Language and its Implementation. Addison-Wesley, Reading, MA, 674-681.
91. GOLDBERG, B. 1989. Generational reference counting: A reduced communication distributed storage reclamation scheme. In Programming Languages Design and Implementation, ACM SIGPLAN Not. 24, 313-321.
92. HANSEN, W. J. 1969. Compact list representation: Definition, garbage collection, and system implementation. Commun. ACM 12, 9, 499.
93. HAYES, B. 1990a. Open systems require conservative garbage collectors. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
94. _. 1990b. Using key object opportunism to collect old objects. OOPSLA '91, ACM SIGPLAN Not. 26, 11, 33-46.
95. HICKEY, T. AND COHEN, J. 1984. Performance analysis of on-the-fly garbage collection. Commun. ACM 27, 11, 341-367.
96. HOARE, C. A. R. 1974. Optimization of store size for garbage collection. Inf. Process. Lett. 2, 6, 165-166.
97. HUDAK, P. 1982. Object and task reclamation in distributed applicative processing systems. Ph.D. Thesis, University of Utah.
98. _. 1986. A semantic model of reference counting and its abstraction (detailed summary). In Proceedings of the 1986 ACM Conference on Lisp and Functional Programming (MIT), 351-363.
99. HUDAK, P. AND KELLER, R. M. 1982. Garbage collection and task deletion in distributed applicative processing systems. In Proceedings of the ACM Symposium on Lisp and Functional Programming (Pittsburgh, PA, August), 168-178.
100. HUDSON, R. AND DIWAN, A. 1990. Adaptive garbage collection for Modula-3 and Smalltalk. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
101. HUGHES, J. 1984. Reference counting with circular structures in virtual memory, applicative systems. Tech. Rep., Programming Research Group, Oxford University.
102. _. 1985. A distributed garbage collection algorithm. In Functional Programming Languages and Computer Architecture, LNCS 201, Springer-Verlag, New York, 256-272.
103. INMOS LIMITED 1984. Occam Programming Manual, Prentice-Hall, Englewood Cliffs, NJ.
104. JOHNSON, D. 1991. The case for a real barrier. ACM SIGPLAN Not. 26, 4, 279-281.
105. JONES, R. E. 1996. http://www.ukc.ac.uk/computer_science/Html/Jones/gc.html.
106. JONES, R. E. AND LINS, R. D. 1992. Cyclic weighted reference counting without delay. Tech. Rep. TR 28-92, UKC Computing Lab, University of Kent at Canterbury.
107. JONES, R. E. AND LINS, R. D. 1993. Cyclic weighted reference counting without delay. In Proceedings of PARLE'93 - Parallel Architectures and Languages Europe, LNCS 694, Springer-Verlag, New York, 712-715.
108. JONES, R. E. AND LINS, R. D. 1996. Garbage Collection: Algorithms for Automatic Dynamic Memory Management. Wiley, New York.
109. JONKERS, H. B. M. 1979. A fast garbage compaction algorithm. Inf. Process. Lett. 9, 1, 26-30.
110. JUL, E., LEVY, H., HUTCHINSON, N., AND BLACK, A. 1988. Fine-grained mobility in the Emerald system. ACM Trans. Comput. Syst. 6, 1, 109-133.
111. JUUL, N. C. 1990. Report. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection in Object-Oriented Systems.
112. JUUL, N. C. AND JUL, E. 1992. Comprehensive and robust garbage collection in a distributed system. In Proceedings of the International Workshop on Memory Management (St. Malo, France), LNCS 637, Springer-Verlag, New York, 103-115.
113. KAFURA, D., WASHABAUGH, D., AND NELSON, J. 1990. Garbage collection of actors. In ECOOP/OOPSLA '90 Proceedings of Workshop on Garbage Collection, 126-134.
114. KAIN, R. Y. 1969. Block structures, indirect addressing and garbage collection. Commun. ACM 12, 7, 395-398.
115. KNOWLTON, K. C. 1965. A fast storage allocator. Commun. ACM 8, 10, 623-625.
116. KNUTH, D. E. 1973. The Art of Computer Programming; Vol 1: Fundamental Algorithms. Addison-Wesley, Reading, MA.
117. KOLODNER, E. 1991. Atomic incremental garbage collection and recovery for large stable heap, implementing persistent object bases: Principles and practice. In Proceedings of the Fourth International Workshop on Persistent Object Systems, Morgan-Kaufmann, San Mateo, CA.
118. KOLODNER, E., LISKOV, B., AND WEIHL, W. 1989. Atomic garbage collection: Managing a stable heap. In Proceedings of the 1989 ACM SIGMOD International Conference on the Management of Data, 15-25.
119. KRASNER, G., ED. 1983. Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, Reading, MA.
120. LADIN, R. AND LISKOV, B. 1992. Garbage collection of a distributed heap. In Proceedings of the International Conference on Distributed Computing Systems, 708-715.
121. LAMB, C., LANDIS, G., ORENSTEIN, J., AND WEINREB, D. 1991. The Object Store database system. Commun. ACM 34, 10, 50-63.
122. LAMPORT, L. 1978. Time, clocks and the ordering of events in a distributed system. Commun. ACM 21, 7, 558-565.
123. LANG, B. AND DUPONT, F. 1987. Incremental incrementally compacting garbage collection. In SIGPLAN '87 - Symposium on Interpreters and Interpretive Techniques, 253-263.
124. LANG, B., QUEINNEC, C., AND PIQUER, J. 1992. Garbage collecting the world. In Proceedings of the Nineteenth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL '92).
125. LERMEN, C. W. AND MAURER, D. 1986. A protocol for distributed reference counting. In Proceedings of the 1986 ACM Conference on Lisp and Functional Programming (MIT), 343-350.
126. LI, K. 1988. Real-time concurrent collection in user mode. In Proceedings of the ECOOP/ OOPSLA '90 Workshop on Garbage Collection.
127. LI, K., APPEL, A. W., AND ELLIS, J. R. 1988. Real-time concurrent collection on stock multiprocessors. In Proceedings of the ACM SIGPLAN '88 Conference on Programming Language Design and Implementation, 11-20.
128. LIEBERMAN, H. AND HEWITT, C. 1983. A realtime garbage collector based on the lifetimes of objects. Commun. ACM 26, 6, 419-429.
129. LINDSTROM, G. 1974. Copying list structures using bounded workspace. Commun. ACM 17, 4, 198-202.
130. LINS, R. D. 1992a. Cyclic reference counting with lazy mark-scan. Inf. Process. Lett. 44, 215-220.
131. _. 1992b. Generational cyclic reference counting. Tech. Rep. TR 22-92 UKC Computing Lab, University of Kent at Canterbury.
132. LINS, R. D. AND VASQUES, M. A. 1991. A comparative study of algorithms for cyclic reference counting. TR 92 UKC Computing Lab, University of Kent at Canterbury, August.
133. LINS, R. D. AND JONES, R. E. 1991. Cyclic weighted reference counting. TR 95, UKC Computing Lab. Tech. Rep., University of Kent at Canterbury, December.
134. LISKOV, B. AND LADIN, R. 1986. Highly-available distributed services and fault-tolerant distributed garbage collection. In Proceedings of the Fifth Symposium on the Principles of Distributed Computing, ACM, New York, 29-39.
135. MARTIN, J. J. 1982. An efficient garbage compaction algorithm. Commun. ACM 25, 8, 571-581.
136. MARTINER, A. D., WACHENCHAUZER, R., AND LINS, R. D. 1990. Cyclic reference counting with local mark-scan. Inf. Process. Lett. 34, 31-35.
137. MARTINEZ, A. D., WACHENCHAUER, R., AND LINS, R. D. 1990. Cyclic reference counting with local mark-scan. Inf. Process. Lett. 34, 31-35.
138. MCCARTHY, J. 1960. Recursive functions of symbolic expressions and their computation by machine: Part I. Commun. ACM 3, 4, 184-195.
139. _. 1981. History of Lisp. In History of Programming Languages, R. L. Wexelblat, Ed., Academic Press, 173-183.
140. MCCULLOUGH, P. L. 1983. Implementing the Smalltalk-80 system: The Tektronix experience. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, Reading, MA, 59-78.
141. MEYERS, R. AND CASSERES, D. 1983. An MC68000-based Smalltalk-80 system. In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley, Reading, MA, 175-187.
142. MIRANDA, E. 1987. BrouHaHa - a portable Smalltalk interpreter. OOPSLA '87, ACM SIGPLAN Not. 22, 12, 354-365.
143. MOHAMMED-ALI, K. A. 1984a,b,c. Object-oriented storage management and garbage collection in distributed processing systems. Academic Dissertation, Royal Institute of Technology, Dept. of Computer Systems, Stockholm, Sweden.
144. MOON, D. 1984. Garbage collection in a large Lisp system. In Proceedings of the 1984 ACM Symposium on Lisp and Functional Programming, 235-246.
145. MORRIS, F. L. 1978. A time- and space-efficient garbage compaction algorithm. Commun. ACM 21, 8, 662-665.
146. _. 1979. On a comparison of garbage collection techniques. Commun. ACM 22, 10, 571.
147. MOSS, J. E. B. 1990. Garbage collecting persistent object stores. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
148. NEWELL, A. AND TONGE, F. M. 1960. An introduction to IPL-V. Commun. ACM 3, 205-211.
149. NEWMAN, I. A. AND WOODWARD, M. C. 1982. Alternative approaches to multiprocessor garbage collection. In Proceedings of the 1982 International Conference on Parallel Processing (Ohio State University, Columbus, OH, August), 205-210.
150. NEWMAN, I. A., STALLARD, R. P., AND WOODWARD, M. C. 1982. Performance of parallel garbage collection algorithms. Comput. Stud. 166 (Sept.).
151. NILSEN, K. 1988. Garbage collection of strings and linked data structures in real time. Softw. Pract. Exper. 18, 7, 613-640.
152. NILSEN, K. AND SCHMIDT, W. J. 1990. Hardware support for garbage collection of linked objects and arrays in real time. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
153. NORI, A. K. 1979. A storage reclamation scheme for applicative multiprocessor systems. Masters Thesis, Department of Computer Science, University of Utah.
154. NORTH, S. C. AND REPPY, J. H. 1987. Concurrent garbage collection on stock hardware. In Functional Programming Languages and Computer Architecture, LNCS 274, Springer-Verlag, New York, 113-133.
155. OZAWA, T., HOSOI, A., AND HATTORI, A. 1990. Generation type garbage collection for parallel logic languages. NACLP, MIT Press, Cambridge, MA, 291-305.
156. PARC-PLACE 1991. Objectworks/ Smalltalk Release 4 User's Guide. Memory Management, 229-237.
157. PETERSON, L. L. AND DAVIE, B. S. 1996. Computer Networks: A Systems Approach. Morgan-Kaufmann, San Mateo, CA.
158. PEYTON-JONES, S. L. 1987. The Implementation of Functional Programming Languages. Prentice-Hall, Englewood Cliffs, NJ.
159. PIQUER, J. M. 1991. Indirect reference counting: A distributed garbage collection algorithm. In Proceedings of PARLE '91 - Parallel Architectures and Languages Europe, LNCS 505, Springer-Verlag, New York, 150-165.
160. _. 1995. Indirect mark and sweep. In Memory Management. Proceedings of IWMM95, H. G. Baker, Ed., LNCS 986, Springer-Verlag, New York, 268-282.
161. PLAINFOSSÉ, D. 1994. Distributed garbage collection and reference management in the Soul object support system. Ph.D. Thesis, Université Paris.
162. PLAINFOSSÉ, D. AND SHAPIRO, M. 1992. Experience with fault-tolerant garbage collection in a distributed Lisp system. In Proceedings of the International Workshop on Memory Management (St. Malo, France), LNCS 637, Springer-Verlag, New York, 116-133.
163. PLAINFOSSÉ, D. AND SHAPIRO, M. 1995. A survey of distributed garbage collection techniques. In Proceedings of the International Workshop on Memory Management (Kinross, UK), LNCS 986, Springer-Verlag, New York, 211-249.
164. QUEINNEC, C., BEAUDOING, B., AND QUEILLE, J. 1989. Mark DURING sweep rather than mark THEN sweep. In Proceedings of PARLE '89 - Parallel Architectures and Languages Europe, LNCS 365, Springer-Verlag, New York.
165. RANA, S. P. 1983. A distributed solution to the distributed termination problem. Inf. Process. Lett. 17, 43-46.
166. ROSENBLUM, M. AND OUSTERHOUT, J. K. 1992. The design and implementation of a log-structured file system. ACM Trans. Comput. Syst. 10, 1, 26-52.
167. RUDALICS, M. 1986. Distributed copying garbage collection. In Proceedings of the 1986 ACM Conference on Lisp and Functional Programming, MIT, Cambridge, MA, 364-372.
168. _. 1990. Correctness of distributed garbage collection algorithms. TR 90-40.0, Johannes Kepler Universität, Linz.
169. SCHELVIS, M. 1989. Incremental distribution of timestamp packets: A new approach to distributed garbage collection. OOPSLA '89, ACM SIGPLAN Not. 24, 10, 37-48.
170. SCHELVIS, M. AND BLEDOEG, E. 1988. The implementation of a distributed Smalltalk. In ECOOP Proceedings (August), LNCS 322, Springer-Verlag, New York, 212-232.
171. SCHORR, H. AND WAITE, W. M. 1967. An efficient machine-independent procedure for garbage collection in various list structures. Commun. ACM 10, 8, 501-506.
172. SHAPIRO, M., DICKMAN, P., AND PLAINFOSSÉ, D. 1992a. Robust, distributed references and acyclic garbage collection. In ACM Symposium on Principles of Distributed Computing (Vancouver).
173. SHAPIRO, M., DICKMAN, P., AND PLAINFOSSÉ, D. 1992b. SSP chains: Robust, distributed references and acyclic garbage collection. Tech. Rep. TR INRIA.
174. SHAPIRO, M., PLAINFOSSÉ, D., AND GRUBER, O. 1990. A garbage detection protocol for a realistic distributed object-support system. Tech. Rep. TR INRIA 1320.
175. SHAPIRO, M., PLAINFOSSÉ, D., FERREIRA, P., AND AMSALEG, L. 1994. Some key issues in the design of distributed garbage collection and references. Tech. Rep. TR INRIA.
176. SHARMA, R. AND SOFFA, M. L. 1991. Parallel generational garbage collection. OOPSLA 91, ACM SIGPLAN Not. 26, 11, 16-32.
177. SHAW, R. A. 1987. Empirical analysis of a Lisp system. Ph.D. Thesis, Stanford University, Stanford, CA. February, 1988.
178. STANDISH, T. A. 1980. Data Structures Techniques. Addison-Wesley, Reading, MA.
179. STEELE, G. L. 1975. Multiprocessing compactifying garbage collection. Commun. ACM 18, 9, 495-508.
180. STEENKISTE, P. 1987. Lisp on a reduced-instruction-set processor: Characterization and optimization. Ph.D. Dissertation. TR CSL-TR-87-324, Stanford University, March.
181. SUN 1997. [http://java.sun.com/products/jdk/ 1.1/docs/guide/rmi/index.html.
182. TANENBAUM, A. S. 1989. Computer Networks. Prentice-Hall, Englewood Cliffs, NJ.
183. TEL, G. AND MATTERN, F. 1993. The derivation of distributed termination detection algorithms from garbage collection schemes. ACM Trans. Program. Lang. Syst. 15, 1, 1-35.
184. TERESHIMA, M. AND GOTO, E. 1978. Genetic order and compactifying garbage collector. Inf. Process. Lett. 7, 1, 27-32.
185. TICK, E. 1988. Memory Performance of Prolog Architectures. Kluwer, Norwell, MA.
186. TUCK, B. 1990. OSI and Library Services. Library and Information Briefings, University of Westminster.
187. UNGAR, D. M. 1984. Generation scavenging: A non-disruptive high performance storage reclamation algorithm. In Proceedings of the ACM SIGSOFTISIGPLAN Software Engineering Symposium on Practical Software Development Environments (April), 157-167.
188. _. 1987. The Design and Evaluation of a High Performance Smalltalk System. An ACM Distinguished Dissertation 1986, MIT Press, Cambridge, MA.
189. UNGAR, D. M. AND JACKSON, F. 1988. Tenuring policies for generation-based storage reclamation. OOPSLA '88 ACM SIGPLAN Not. 23, 11, 1-17.
190. UNGAR, D. M. AND JACKSON, F. 1992. An adaptive tenuring policy for generation scavengers. ACM Trans. Program. Lang. Syst. 14, 1, 1-27.
191. UNGAR, D. M. AND PATTERSON, D. A. 1983. Berkeley Smalltalk: Who knows where the time goes? In Smalltalk-80: Bits of History, Words of Advice, Addison-Wesley Reading, MA, 189-206.
192. VESTAL, S. C. 1987. Garbage collection: An exercise in distributed, fault-tolerant programming. Ph.D. Thesis, Department of Computer Science, University of Washington, Seattle, WA, January.
193. WADLER, P. L. 1976. Analysis of an algorithm for real-time garbage collection. Commun. ACM 19, 9, 491-500.
194. WATSON, I. 1986. An analysis of garbage collection for distributed systems. TR Department of Computer Science, University of Manchester.
195. WATSON, P. AND WATSON, I. 1987. An efficient garbage collection scheme for parallel computer architecture. In Proceedings of PARLE '87 - Parallel Architectures and Languages Europe, LNCS 259, Springer, 432-443.
196. WEGBREIT, B. 1972. A generalized compacting garbage collector. Comput. J. 15, 3, 204-208.
197. WEIZENBAUM, J. 1962. Knotted list structures. Commun. ACM 5, 3, 161-165.
198. _. 1963. Symmetric list processor. Commun. ACM 6, 9, 524-544.
199. WENG, J. 1979. An abstract implementation for a generalized data-flow language. TR MIT/ LCS/228, MIT Laboratory for Computer Seience.
200. WHITE, J. L. 1980. Address/memory management for a gigantic Lisp environment or GC considered harmful. In Record of the 1980 Lisp Conference, 119-127.
201. WILSON, P. R. 1990. Some issues and strategies in heap management and memory hierarchies. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
202. _. 1992. Uniprocessor garbage collection techniques. In Proceedings of the International Workshop on Memory Management (St. Malo, France), LNCS 637, Springer-Verlag New York, 1-42.
203. WILSON, P. R. AND MOHER, T. G. 1989. Design of the opportunistic garbage collector. OOPSLA '89, ACM SIGPLAN Not. 24, 10, 23-35.
204. WILSON, P. R., JOHNSTONE, M. S., NEELY, M., AND BOLES, D. 1995. Dynamic storage allocation: A survey and critical review. In Proceedings of the International Workshop on Memory Management (Kinross, UK), LNCS 986, Springer-Verlag, New York, 1-116.
205. WILSON, P. R., LAM, M. S., AND MOHER, T. G. 1990. Caching considerations for generational garbage collection: A case for large and set-associative caches. TR UIC-EECS-90-5, December.
206. WILSON, P. R., LAM, M. S., AND MOHER, T. G. 1991. Effective "static-graph" reorganization to improve locality in garbage-collected systems. In Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design and Implementation (Toronto), 177-191.
207. WOLCZKO, M. AND WILLIAMS, I. 1990. Garbage collection in high-performance system. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
208. WOODWARD, M. C. 1981. Multiprocessor garbage collection - a new solution. Comput. Stud. 115.
209. ZAVE, D. A. 1975. A fast compacting garbage collector. Inf. Process. Lett. 3, 167-169.
210. ZORN, B. 1989. Comparative performance evaluation of garbage collection algorithms. Ph.D. Thesis, EECS Department, University of California, Berkeley.
211. _. 1990. Designing systems for evaluation: A case study of garbage collection. In Proceedings of the ECOOP/OOPSLA '90 Workshop on Garbage Collection, position paper.
212. _. 1992a. The measured cost of conservative garbage collection. TR CU-CS-573-92. Department of Computer Science, University of Colorado, Boulder, April.
213. _. 1992b. Evaluating models of memory allocation. TR CU-CS-603-92, Department of Computer Science, University of Colorado, Boulder, July.
214. ZORN, B. AND GRUNWALD, D. 1992. Empirical measurements of six allocation-intensive C programs. ACM SIGPLAN Not. 27, 12 (Dec.), 71-80.
215. ZORN, B. AND HILFINGER, P. 1988. A memory allocation profiler for C and Lisp programs. In Proceedings of Summer 1988 USENIX Conference (San Francisco, June).