Report Principles Of Operation Of An Os

Published Date: 02 Nov 2017

Multiprocessor Systems are known as parallel or tightly coupled systems. They are different than single processor systems because they have two or more processors in close communication often sharing the computer bus and more importantly the clock, memory and peripheral devices of the computer. Such operation has some distinct advantages over single processor systems which are:

Increased throughput: Increased number of processors allow for an increase of performance in the system. Although the performance gain isn’t additive, because we have to worry about keeping different parts working correctly, as well as competition for the same recourses lead to a gain but not one which the user would expect.

Economy of scale: Using multiprocessors we can save a significant amount of money, by having the system share mass storage, peripherals and power supplies. If a significant amount of programs use the same set of data, it would be cheaper to have one disk and share the data, than having different computers with single processors having to copy data on their own disk.

Increased reliability: If we can share the functions correctly among the processors the failure of one, would not stop the system, it would only slow it down. Thus by having two or more processors, the system would still continue operation.

The operating system is generally accepted as the software you receive when you buy a computer; however that concept is no longer true, as several extra applications are already installed on a computer that you buy, and vary greatly between OS. Thus the most correct notion of what is an OS is that the OS is the only program running all of the time on a computer (known as the kernel). Applications usually provide extra functionality, and they cannot be an integral part of the OS. A web browser is not necessary for an OS to work properly, even though many OS have it as part of them now. An OS needs only the absolutely necessary programs to run, and by using different applications we can increase functionality.

When a computer starts it needs an initial program to run with, typically called bootstrap program. This program is pretty simple and it’s stored in ROM. The bootstrap loads the OS and start executing it, by loading the kernel into memory and waits for an event to happen. Then an interrupt from the hardware or the software occurs signalling the event that was expected. Hardware can trigger an interrupt by sending a signal to the CPU from the system bus. Software can execute an interrupt by using a system call. Then the CPU stops what it is doing and transfers execution to the location containing the starting address where the service routine for the interrupt is located. On completion the CPU continues the interrupted execution. //enough for interrupts?

Structural Organization

Monolithic structure: This structure is mostly used by systems that are small and simple, mostly limited systems that go beyond their original scope. They are written to provide the most functionality in the least amount of space. A typical example is MS-DOS with a picture of the structure below.

Image courtesy of Operating Systems Concepts.

Because the interfaces are not well separated applications programs can access the basic I/O routines and write directly to the disk or the display. Freedom like that leaves the system vulnerable to malicious applications, in some cases causing the system to crash. However MS-DOS was limited in this respect by the hardware of the era, for example the Intel 8088 did not offer dual-mode or hardware protection. Another example is the UNIX kernel which provides the file system, CPU scheduling, memory management and many more OS functions through system calls. That is an exorbitant amount of functionality combined into one level. The monolithic structure was very difficult to implement and to provide maintenance.

Layered Approach: This approach divides the OS into different layers or levels. This in turn allows the OS to retain a greater amount of control over the programs that use the computer. Also implementers have more freedom to change the system and programmers can implement low level methods more easily. A layered approach leaves the different layers only able to invoke operations on lower level layers, and their methods only being able to be invoked by higher level layers. The main advantage this approach has is simplicity of construction and debugging. The layers only have access to functions on lower level layers. When the first layer is debugged and a bug is found on a higher level layer it is assumed that the bug is on that particular layer because the layers below are debugged. Ergo the design and implementation are simplified. And because a layer does not need to know how different operations are implemented on lower level layers it can hide different data structures and operations from higher level layers.

However there are some problems with this approach. Firstly the definition of different layers is crucial because a layer can only use lower level layers. An example from the Operating System Concepts is this: "the device driver for the backing store must be at a lower level than the memory management routines, because memory management requires the ability to use the backing store." This is a major difficulty that must be considered. Also the layered approach is less efficient than other types. When a user application executes a basic I/O instruction, the system call has to pass through all the layers to reach the hardware and each pass adds overhead, and in turn this takes longer on the layered systems than non-layered systems.

Microkernel Approach: This approach removes all the unnecessary components from the kernel and adds them as system programs or user-level programs, the end result being a smaller kernel. These kernels provide minimal process and memory management and a communication facility. The communication facility is between client space and different services that are running in the user space. Communication is provided by ‘message passing’. The client programs and service interact indirectly by exchanging messages with the microkernel. One benefit of the microkernel is that it is easy to extend an OS. Every new service is added to the user space with no modifications to the kernel, and if the kernel needs to be modified there are fewer changes because it is a smaller kernel. Furthermore the microkernel approach provides more security and reliability. As most services are running as user, if a service fails the OS can continue to work with no problems. Nevertheless the microkernel can suffer from performance issues, due to the increased system function overhead.