[9]
Hans-Juergen Boehm.
Space efficient conservative garbage collection.
In Proceedings of the ACM SIGPLAN'93 Conference on Programming
Language Design and Implementation, pages 197-206, 1993.
[10]
Hans-Juergen Boehm and Mark Weiser.
Garbage collection in an uncooperative environment.
Software Practice and Experience, 18(9):807-820, 1988.
[11]
K. Mani Chandy and Carl Kesselman.
CC++: A declarative concurrent object-oriented programming
notation.
In Gul Agha, Peter Wegner, and Akinori Yonezawa, editors,
Research Directions in Concurrent Object-Oriented Programming, chapter 11,
pages 281-313. The MIT Press, 1993.
[12]
Andrew A. Chien.
Concurrent Aggregates (CA).
PhD thesis, MIT, 1991.
[13]
Andrew. A. Chien, U. S. Reddy, J. Plevyak, and J. Dolby.
ICC++ - a C++ dialect for high performance parallel computing.
In Proceedings of the Second International Symposium on Object
Technologies for Advanced Software, 1996.
[14]
Eric C. Cooper.
Adding threads to standard ML.
Technical Report 90-186, Carnegie Mellon University, Pittsburgh,
December 1990.
[15]
Eric C. Cooper and Richard P. Draves.
C Threads.
Department of Computer Science, Carnegie Mellon University, 1987.
[16]
David E. Culler, Anurag Sah, Klaus Erik Schauser, Thorsten von Eicken, and John
Wawrzynek.
Fine-grain parallelism with minimal hardware support: A
compiler-controlled threaded abstract machine.
In Proceedings of the Fourth International Conference on
Architectural Support for Programming Languages and Operating Systems,
volume 26, pages 166-175, Snata Clara, California, April 1991.
[17]
Marc Feeley.
Lazy remote procedure call and its implementation in a parallel
variant of c.
In Takayasu Ito, Robert H. Halstead, Jr., and Christian Queinnec,
editors, Proceedings of International Workshop on Parallel Symbolic
Languages and Systems, number 1068 in Lecture Notes in Computer Science,
pages 3-21. Springer-Verlag, 1995.
[18]
Mark Feeley.
An Efficient and General Implementation of Futures on Large
Scale Shared-Memory Multiprocessors.
PhD thesis, Brandeis University, 1993.
[19]
Benjamin Goldberg.
Generational reference counting: A reduced-communication distributed
strage reclamation scheme.
In Proceedings of the ACM SIGPLAN'89 Conference on Programming
Language Design and Implementation, pages 313-321, 1989.
[20]
Seth Copen Goldstein, Klaus Erik Schauser, and David Culler.
Enabling primitives for compiling parallel languages.
In Workshop on Languages, Compilers and Run-Time Systems for
Scalable Computers, 1995.
[21]
Robert H. Halstead, Jr.
Multilisp: A language for concurrent symbolic computation.
ACM Transactions on Programming Languages and Systems,
7(4):501-538, April 1985.
[22]
Kenichi Hayashi, Tunehisa Doi, Takeshi Horie, Yoichi Koyanagi, Osamu Shiraki,
Nobutaka Imamura, Toshiyuki Shimizu, Hiroaki Ishihata, and Tatsuya Shindo.
AP1000+: Architectural support of put/get interface for
parallelizing compiler.
In Proceedings of Architectural Support for Programming
Languages and Operating Systems, pages 196-207, 1994.
[23]
John Hughes.
A distributed garbage collection algorithm.
In Proceedings of the ACM Conference on Functional Programming
Languages and Computer Architecture, number 201 in Lecture Notes in Computer
Science, pages 256-272. Springer-Verlag, 1985.
[24]
Nobuyuki Ichiyoshi, Kazuaki Rokusawa, Katsuto Nakajima, and Yu Inamura.
A new external reference management and distributed unificatin for
KL1.
In New Generation Computing, pages 159-177, 1990.
[25]
Nobuyuki Ichiyoshi, Kazuaki Rokusawa, Katsuto Nakajima, and Yu Inamura.
A new external reference management and distributed unification for
KL1.
In New Generation Computing, volume 7, pages 159-177.
Springer-Verlag, 1990.
[26]
Richard Jones and Rafael Lins.
Garbage Collection, Algorithms for Automatic Dynamic Memory
Management.
John Wiley & Sons, 1996.
[27]
Niels Christian Juul and Eric Jul.
Comprehensive and robust garbage collection in a distributed system.
In Yves Bekkers and Jacques Cohen, editors, Proceedings of
International Workshop on Memory Management, volume 637 of Lecture
Notes in Computer Science, pages 103-115. Springer-Verlag, 1992.
[28]
Tomio Kamada, Satoshi Matsuoka, and Akinori Yonezawa.
Efficient parallel global garbage collection on massively parallel
computers.
In Proceedings of Supercomputing '94, pages 79-88, 1994.
[29]
Gerry Kane and Joe Heinrich.
MIPS RISC Architecture.
Prentice Hall, 1992.
[30]
Steve Kleiman, Devang Shah, and Bart Smaalders.
Programming with Threads.
SunSoft Press, 1996.
[31]
Bernard Lang, Christian Queinnec, and Jose Piquer.
Garbage collecting the world.
In Conference Record of the Nineteenth Annual ACM
SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages
39-58, Albuquerque, New Mexico, January 1992.
[32]
Eric Mohr, David A. Kranz, and Robert H. Halstead, Jr.
Lazy task creation: A techinque for increasing the granularity of
parallel programs.
IEEE Transactions on Parallel and Distributed Systems,
2(3):264-280, July 1991.
[33]
R. S. Nikhil and Arvind.
Id: a language with implicit parallelism.
Technical report, Massachusetts Instituted of Technology, Cambridge,
1990.
[34]
Rishiyur S. Nikhil.
Parallel symbolic computing in Cid.
In Takayasu Ito, Robert H. Halstead, Jr., and Christian Queinnec,
editors, Proceedings of International Workshop on Parallel Symbolic
Languages and Systems, number 1068 in Lecture Notes in Computer Science,
pages 217-242. Springer-Verlag, 1995.
[35]
Jose‾M. Piquer.
Indirect reference counting: A distributed garbage collection
algorithm.
In Proceedings of Parallel Architectures and Languages Europe,
number 505, 506 in Lecture Notes in Computer Science, pages 150-165.
Springer-Verlag, 1991.
[36]
Plainfosse and Shapiro.
A survey of distributed garbage collection techniques.
In Henry Baker, editor, Proceedings of International Workshop on
Memory Management, number 986 in Lecture Notes in Computer Science.
Springer-Verlag, 1995.
[37]
John Plevyak, Vijay Karamcheti, Xingbin Zhang, and Andrew A. Chien.
A hybrid execution model for fine-grained languages on distributed
memory multicomputers.
In Supercomputing '95, 1995.
[38]
A. Rogers, M. Carlisle, J. Reppy, and L. Hendren.
Supporting dynamic data structures on distributed memory machines.
ACM Transactions on Programming Languages and Systems,
17(2):233-263, 1995.
[39]
Kazuaki Rokusawa and Nobuyuki Ichiyoshi.
Evaluation of remote reference management in a distributed KL1
implementation.
In IPSJ SIG Notes 96-PRO-8 (Proceedings of Summer Workshop on
Parallel Processing), pages 13-18, 1996.
(in Japanese).
[40]
Klaus Erik Schauser, David E. Culler, and Thorsten von Eicken.
Compiler-controlled multithreading for lenient parallel languages.
In Proceedings of 5th ACM Conference on Functional Programming
Languages and Computer Architecture, volume 523 of Lecture Notes in
Computer Science, pages 50-72, Cambridge, MA, August 1991.
[41]
SPARC International Inc.
The SPARC Architecture Manual, 1992.
[42]
Kenjiro Taura, Satoshi Matsuoka, and Akinori Yonezawa.
An efficient implementation scheme of concurrent object-oriented
languages on stock multicomputers (extended abstract).
In Proceedings of US/Japan Workshop on Parallel and Symbolic
Computing: Languages, Systems, and Applications, volume 748 of Lecture
Notes in Computer Science, pages 402-407, 1992.
[43]
Kenjiro Taura, Satoshi Matsuoka, and Akinori Yonezawa.
An efficient implementation scheme of concurrent object-oriented
languages on stock multicomputers.
In Proceedings of the ACM SIGPLAN Symposium on Principles &
Practice of Parallel Programming (PPOPP), pages 218-228, 1993.
[44]
Kenjiro Taura, Satoshi Matsuoka, and Akinori Yonezawa.
ABCL/f: A future-based polymorphic typed concurrent
object-oriented language - its design and implementation -.
In G. Blelloch, M. Chandy, and S. Jagannathan, editors,
Proceedings of the DIMACS workshop on Specification of Parallel
Algorithms, number 18 in Dimacs Series in Discrete Mathematics and
Theoretical Computer Science, pages 275-292. American Mathematical Society,
1994.
[45]
Kenjiro Taura, Satoshi Matsuoka, and Akinori Yonezawa.
StackThreads: An abstract machine for scheduling fine-grain
threads on stock CPUs.
In Joint Symposium on Parallel Processing, pages 25-32, 1994.
[46]
Kenjiro Taura and Akinori Yonezawa.
An effective garbage collection strategy for parallel programming
languages on large scale distributed-memory machines.
In Proceedings of ACM SIGPLAN Symposium on Principles &
Practice of Parallel Programming PPOPP, 1997.
(to appear).
[47]
Kenjiro Taura and Akinori Yonezawa.
Fine-grain multithreading with minimal compiler support--a cost
effective approach to implementing efficient multithreading languages.
In Proceedings of the 1997 ACM SIGPLAN Conference on Programming
Language Design and Implementation, 1997.
(to appear).
[48]
David B. Wagner and Bradley G. Calder.
Leapfrogging: A portable technique for implementing efficient
futures.
In Proceedings of the ACM SIGPLAN Symposium on Principles &
Practice of Parallel Programming PPoPP, pages 208-217, 1993.
[49]
Paul Watson and Ian Watson.
An efficient garbage collection scheme for parallel computer
architectures.
In W. Jacobus Bakker, L. Nijman, and Philip C. Treleaven, editors,
Proceedings of Parallel Architectures and Languages Europe, number 258,
259 in Lecture Notes in Computer Science, pages 432-443, Springer-Verlag,
1987.
[50]
William Weihl, Eric Brewer, Adrian Colbrook, Chrysanthos Dellarocas, Wilson
Hsieh, Anthony Joseph, Carl Waldspurger, and Paul Wang.
PRELUDE: A system for portable parallel software.
Technical Report MIT/LCS/TR-519, Laboratory for Computer Science,
Massachusetts Institute of Technology, 1991.
[51]
Masahiro Yasugi, Satoshi Matsuoka, and Akinori Yonezawa.
ABCL/onEM4: A new software/hardware architecture for
object-oriented concurrent computing on an extended dataflow supercomputer.
In Conference Proceedings of 1992 International Conference on
Supercomputing, pages 93-103, Washington,D.C., July 1992.
[52]
Akinori Yonezawa, Jean-Pierre Briot, and Etsuya Shibayama.
Object-oriented concurrent programming in ABCL/1.
In OOPSLA '86 Conference Proceedings, pages 258-268, 1986.
Mitsubishi Research Institute,Inc.
Mon Feb 24 19:27:36 JST 1997