The MUSHROOM Project

mushroom logo Hardware support for Objects: The MUSHROOM Project

An overview of the project by Mario Wolczko.

A research project conducted at the Department of Computer Science of the University of Manchester, between 1987 and 1992.


picture of the mushroom PCB

The benefits of the object-oriented style of programming are now widely appreciated. Object-oriented programming helps organize software so that components are more reusable, and so that systems are more malleable. However, an oft-voiced complaint about the more dynamic object-oriented languages such as Smalltalk is that too much performance is sacrificed for the increased flexibility. Smalltalk programs typically run 5 to 20 times slower than equivalent C programs. However, those who have programmed in Smalltalk are usually impressed by its flexibility and versatility.

In 1986 a group at the University of Manchester embarked upon an investigation into how developments in computer architecture could benefit the performance of dynamic object-oriented languages. We reasoned that if the object-oriented approach was of such great benefit to software development, then it would be all the more attractive if there was little loss of performance. Over the next five years we developed an architecture to support object-oriented languages, called the Mushroom architecture. The aim of the research was, starting with carte blanche, to discover what sort of architecture was best suited to Smalltalk-like languages. (When we started, Smalltalk was the only real candidate for study, as few other object-oriented languages existed. Additionally, the behaviour of the Smalltalk system had been extensively analysed. Since then other dynamic object-oriented languages, such as Self, CLOS, Eiffel, Dylan and of course the JavaTM programming language have appeared, but we feel confident that our results will generalize to those languages too, as their implementations exhibit similar behavioural characteristics. Less dynamic languages, such as C++, will gain less from our architecture, as they exhibit behaviour closer to that assumed by conventional architectures.)

Not only did we want an architecture that was fast for Smalltalk, but also one which would efficiently support much larger applications than possible at the time. Many users had noticed that Smalltalk applications were not well supported by conventional virtual memory systems, and that almost all of a Smalltalk system had to reside in real memory for performance to be acceptable, despite much of the system not being in use at any particular moment. This meant that the real memory requirements of a Smalltalk application could be very large, and hence costly. We felt that architectural changes could lead to a virtual memory system more suited to the demands of dynamic object-oriented languages, and thereby save on memory costs.

A prototype implementation of this architecture was designed but never commissioned. The project ended for a variety of non-technical reasons in 1992, and at that time there was little interest in hardware support for objects. With the current interest in Java technology, some of these ideas might get a new lease of life.

Here can be found the various papers and theses that were part of the project or led up to it. As is usually the case, each paper is a snapshot of the ideas at the time the paper was written, so the whole collection does not paint a single coherent picture.

If you need more explanation, just ask me.


This material is presented to ensure dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All persons copying this information are expected to adhere to the terms and constraints invoked by each author's copyright. In most cases, these works may not be reposted without the explicit permission of the copyright holder.

Project overview

Mushroom - A Distributed Multi-User Object-Oriented Programming Environment. Trevor Hopkins, Ifor Williams, and Mario Wolczko.
What we originally set out to do. Of course, totally different from what we actually did. Of historical interest only.

Architecture and Implementation

Dynamic Grouping in an Object Oriented Virtual Memory Hierarchy. Ifor Wyn Williams, Mario I. Wolczko, and Trevor P. Hopkins. In Proceedings of the 1987 European Conference on Object-Oriented Programming, J. Bezivin, J.-M. Hullot, P. Cointe, and H. Lieberman, editors, Lecture Notes in Computer Science, volume 276, pages 79-88. Springer-Verlag, Paris, June 1987.
Introduced dynamic grouping of virtual memory. Simulated various algorithms as applied to Smalltalk-80 applications.

Realisation of a Dynamically Grouped Object-Oriented Virtual Memory Hierarchy Ifor Wyn Williams, Mario I. Wolczko, and Trevor P. Hopkins. In Proceedings of the Workshop on Persistent Object Systems: Their Design, Implementation and Use, pages 298-308, August 1987. Persistent Programming Research Report, Universities of Glasgow and St. Andrews (PPRR-44-87).
Described some ways to implement a dynamically-grouped virtual memory, and simulated the implementations.

The Mushroom Machine - An Architecture for Symbolic Processing Ifor Williams. In IEE Colloquium on VLSI and Architectures for Symbolic Processing, London, March 1989.
A very brief (3-page) description of the architecture as it was then envisaged.

Object-Based Memory Architecture Ifor W. Williams. PhD thesis, Department of Computer Science, University of Manchester, May 1989.
The most complete exposition of the architecture. However, read the next paper first, to get an overview.

An Object-Based Memory Architecture Ifor Williams and Mario Wolczko. In Implementing Persistent Object Bases: Proceedings of the Fourth International Workshop on Persistent Object Systems, Alan Dearle, Gail M. Shaw, and Stanley B. Zdonik, editors, pages 114-130. Morgan Kaufmann Publishers, Inc., 1991.
An overview of the Mushroom memory architecture, its whys and wherefores.

Programmable Logic Arrays for Prototype Computer Implementation Ifor W. Williams. In Proceedings of the IEE Colloquium on Programmable Logic Devices for Digital Systems Implementation, Savoy Place, London, May 1990.
This paper is lost in the mists of time.

Issues in Code Generation for Smalltalk-80 on an Object-Oriented Architecture Mario Wolczko and Ifor Williams. Draft presented at CODE '91, Schloss Dagstuhl, Germany, May 1991.
An early paper about the Mushroom Smalltalk compiler.

Using FPGAs to Prototype New Computer Architectures Ifor Williams. In Will R. Moore and Wayne Luk, editors, FPGAs, chapter 6.8, pages 373-382. Abingdon EE & CS Books, 1991.
Describes the use of Xilinx FPGAs to build the Mushroom prototype.

Object Mobility in Distributed Systems
Rhodri M. Davies. Technical Report UMCS-92-4-5, Department of Computer Science, University of Manchester, 1992. Available from the University of Manchester, or contact Rhod Davies
All about object migration.

The software structure of the Mushroom object store (unpublished).
Mario Wolczko. Technical report of the Mushroom project, Department of Computer Science, University of Manchester, May 1992.
All about how to build object tables, pagers, etc., for Mushroom. Unpublished, unfinished. If you really badger me, I might let you have a copy.

The influence of the object-oriented language model on a supporting architecture Mario Wolczko and Ifor Williams. Proceedings of the 26th Hawaii Conference on System Science, pages 182-191, January 1993. Also published in The Interaction of Compilation Technology and Computer Architecture, David Lilja and Peter Bird, editors, Kluwer, 1994.
How the object-oriented model influences the Mushroom architecture and the software system.

Programming Languages and Techniques

Introducing MUST -- The Mushroom Programming Language Mario I. Wolczko. Technical report of the Mushroom project, Department of Computer Science, University of Manchester, October 1988.
An overview of a language designed as a successor to Smalltalk-80. It was never implemented.

Writing Concurrent Object-Oriented Programs using Smalltalk-80 Trevor P. Hopkins and Mario I. Wolczko. The Computer Journal, 32(4):341-350, October 1989.
How to write concurrent programs in Smalltalk. The first paper to present futures in Smalltalk.

Encapsulation, Delegation and Inheritance in Object-Oriented Languages Mario Wolczko. IEE Software Engineering Journal, 7(2):95-101, March 1992.
About the relationships between delegation, inheritance and encapsulation.

Delayed Code Generation in a Smalltalk-80 Compiler Ian Piumarta, PhD thesis, Department of Computer Science, University of Manchester, October 1992.

From Types To Dataflow: Code Analysis for an Object-Oriented Language Andrew J. Barnard, PhD thesis, Department of Computer Science, University of Manchester, October 1992. Available in printed form as a Technical Report, UMCS-93-10-2 (see below).

Garbage Collection

Garbage Collection Mario I. Wolczko. In Case Studies in Systematic Software Development, Cliff B. Jones and Roger C. F. Shaw, editors, chapter 8, pages 211-233. Prentice-Hall International, 1990.
Formal models of garbage collection in VDM.

Garbage Collection in a High-Performance System Mario Wolczko and Ifor Williams. Position paper from the OOPSLA/ECOOP workshop on garbage collection, November 1990.
An early overview of the Mushroom garbage collection system.

Multi-level Garbage Collection in a High-Performance Persistent Object System Mario Wolczko and Ifor Williams. In Persistent Object Systems, San Miniato, 1992, pages 396-418. Springer-Verlag, San Miniato, Italy, 1993.
A complete description of garbage collection in Mushroom.


Final Report of SERC Research Grant GR/E/65050: A high-performance distributed object-oriented system, The MUSHROOM Project Trevor P. Hopkins, Ifor Williams, Mario Wolczko. June 1991.
An interim report to the funding body.


Pictures and links for The Mushroom Group.

The Mushroom Memorial Page

Ending a project with a bang.
This page, and all photos within, except where noted, Copyright © 1996 Mario Wolczko.