By J. H. Saltzer, February 24, 1995, revised February 21, 1997

Question 1:  At a high level, what are the main ideas that we have been
talking about in the lectures on system structure?

Answer:     Industrial strength modularity, achieved by
               -  introducing a client/server model
               -  reusing virtual memory with a new purpose
            Threads

Question 2:  Where do microkernels fit in?

Answer:  That is just an application of industrial strength modularity
(primarily the client/server model) to the organization of the operating
system itself.

Question 3: (The exact form of this question depends a bit on the
particular case studies chosen for reading, but they all allow the
question.)  This system is a microkernel that implements virtual memory
and threads.  Each of those ideas was actually pretty simple, and the
mechanics of implementation of each one is fairly obvious and
straightforward.  The papers by Bershad, et al. (or Anderson et al., or
Wahbe et al., or about Mach) are on exactly these topics.  Yet those
papers are NOT obvious and straightforward.  Why not? What is going on?

[This question is likely to produce responses that are unfocused and
fluffy.  That is OK, because after a few minutes the class will come
to realize that it is all fluffiness.  The trick now is to spot
something that someone says that can be interpreted as being near the
heart of the matter, namely:]

a)  In the lectures, we talked about each idea independently.  The
systems in the papers all implement all of the ideas at once.  The ideas
interact with considerable ferocity.  For example, the simple idea of
threads blossoms to consideration of abstract and concrete threads and,
along another dimension, to user threads and kernel threads.  A design
space that had one option--to implement threads or not--all of a sudden
has eight or more options.  For another example, the virtual memory
management may be implemented partly in kernel space and partly in a VM
server.  This takes advantage of the microkernel design, but involves
more complexity.

b)  Introducing modularity has a performance cost.  Much of the
complexity described in the case studies consists of mechanism that
erodes our newly-achieved modularity in order to regain performance.
The goal, of course, is to be as clever as possible in maximizing the
recouped performance while minimizing the modularity erosion.
Unfortunately, the cleverness adds quite a bit of complexity, both
conceptually and in the details of implementation.

c)  Mach, especially, provides a third lesson:  Each idea does *not*
appear in its simplest form.  Threads are done with multiple processors,
adding affinity sets for scheduling.  Virtual memory is done with
features for direct mapping of files and shared virtual memory pages.
The microkernel, with its many calls for each kernel function, is hardly
minimal.