As we saw earlier, a multiprocessor consists of several processors sharing a common memory. The memory is typically divided into several modules which can be accessed independently. Thus several (non-conflicting) memory requests can be serviced concurrently A switching network is used to direct requests from processors to the correct memory module. Each processor has its own cache.
Converting a uniprocessor operating system to a multiprocessor requires a way to exploit the concurrency provided by the hardware. Here are some approaches:
Let each processor handle a different set of devices and run different operating systems. This situation resembles the distributed case except that we have shared memory.
Let one processor execute processes and another handle the devices.
Let one processor support user processes and another support communication among them. This is a useful idea when interprocess communication is widely used, as is the case in server-based operating systems.
Let one processor be the master processor and others be slave processors. The master processor runs the complete OS, while the slave processors simply run processes, leaving the master processor to handle system calls and interrupts.
All the cases above are asymmetric. We can also develop a symmetric multiprocessor system: Treat the machines equally, and divide the ready processes among them. Under this approach, a device interrupts whichever machine currently allows interrupts. All the processor equally share the OS code and data structures. We will consider only the symmetric case in this course.
In all cases except the first one,
code running on different processors shares common data structures,
and thus needs process coordination primitives.
The coordination schemes we have seen so far will not
work since disabling interrupts on a processor does not
prevent processes from executing on other processors.
Thus these multiprocessor systems support busy waiting
or spin-controlled
coordination schemes in which processes spin in a loop
waiting to be unblocked.
We will not look explicitly at multiprocessor coordination schemes:
take Jim Anderson's courses to learn more about them, in particular, lock-free schemes.