Understanding Operating System Structures: A Comprehensive Overview

in this lecture we'll be discussing about structures of operating system so in one of the previous lectures we

already discussed about something called operating system structures where we discussed about multi-programming and

multitasking operating systems so those were two types of operating systems but in this lecture what we are going to

discuss is about the actual structure of operating systems so we know that operating system is a large and complex

system and it has to be engineered carefully so that it will function properly and it can be modified easily

so there are different structures that have been followed from the beginning till now using which the operating

systems have been designed so we will be discussing about some of those structures and we will see the

advantages of those structures and also the disadvantages of those structures so first of all let us go to the first

structure that was followed in designing operating system which was used in the very beginning and also the olden

operating systems which we call as the simple structure so the simple structure was the

structure that was followed for most of the operating systems that were designed in the very beginning and these simple

structured operating systems did not have a very well defined structure because it was operating systems those

were designed in the very beginning so the diagram that we see here this is the figure of a simple operating system

structure that was followed by the Microsoft Disk Operating System Ms do so we know that Ms do was an old operating

system which was designed very long back and this is the structure or the simple structure followed by the Microsoft Disk

Operating System so here at the bottommost we have the Rome bios device drivers so think of this as your Base

Hardware and then on top of this we have the device drivers then we have the resident system programs and then the

application programs so we see that the device drivers they have access to this Basic Hardware and we see that the

resident progr programs they have access to the device drivers as well as to the Basic Hardware and then even the

application programs they have access to the resident programs as well as the Base Hardware so we see that the Base

Hardware can be accessed by all the things above it the device drivers system programs application programs

everything can access the Base Hardware so we see that in this structure the interfaces and levels of functionality

are not well separated so we see that application programs are able to access the basic input output routines and

write directly to the display and the dis drivers so that means application programs are able to access your Base

Hardware directly without going through these layers below it so this looks like they are kind of a layered structure but

we cannot call it actually a layered structure because there is another structure of operating system called the

layered structure following a layered approach which we will be discussing as we move on in this lecture series and we

will see how it is different from this one so even though this looks like a layered structure it is not actually a

layered structure because all these layers have access to the Base Hardware so what happens is that such Freedom

leaves the MS doors vulnerable to errant or malicious programs causing the entire system to crash when the user program

fails that means if you are running a program here if an application prr program is being run by the user and

since it is directly accessing this Base Hardware if that program fails then that entire system is going to crash because

it is having direct access so we see that it is not well protected it is not well structured and it is not well

defined so this is not a very good structure and also we cannot blame the developers or the designers for

Designing this because as we are talking about the MS do operating system Ms do was written on the Intel 88 and this

Intel 88 it does not provide dual mode or any hardware protection so the developers or designers they had no

other option than to just leave this Base Hardware accessible by all the layers above so that is why it is like

this and we see that this is not efficient and this is not a good structure all right now let us see

another structure known as the monolithic structure which is also kind of a simple structure now another

structure that we see is known as the monolithic structure and this was followed by the earlier Unix operating

systems so in this monolithic structure this also is a limited structure and why is that we'll see it here we have the

kernel and then the system programs so here on top we have the users and below that we have the shells and commands

compilers interpreters system libraries and so on and below this is the system call interface to the kernel that is the

system call which acts as an interface to the kernel and this part is the kernel all right everything below this

system call interface to the kernel and above the hardware this bottommost part is the hardware so everything Above This

hardware and below the system call interface with the kernel this is known as the kernel and in the kernel it has

all these functionalities like signal terminal handling character input output system terminal drivers file systems

swapping block input output systems dis and tape drivers then CBU scheduling page replacement demand paging virtual

memory and so on so everything is actually packed into one level and hence we call it a monolithic structure so

this was followed by the earlier Unique Systems so in here we see that everything all these functionalities are

packed into one level which we call as the kernel now the problem with this is that there are too many functions packed

into one level and this makes its implementation and maintenance very difficult so let's say that you want to

add something to this then you have to change this entire thing or you have to modify this entire thing or let's say

that you want to debug a certain functionality in this kernel let's say that there is a problem with your CPU

scheduling so in order to fix that issue of CPU scheduling you will have to touch this entire kernel so this makes it a

system that is difficult to be maintained and imped all right if you want to add something to it also it is

going to be difficult so this is the disadvantage of the monolithic structure there are too many things packed into

one level so this is also a simple and limited structure followed by the earlier operating systems like the

earlier Unix so now we have talked about two simple structures the first simple structure from Microsoft DOS and the

next monolithic structure from Unix so we saw that both of them were having some disadvantage es so in order to

solve that disadvantage they came up with another structure called the layer structure so in this layer structure

your operating system is divided into a number of layers like for example here at the lowermost level or at layer zero

you have your Hardware then you have layer 1 Layer Two up to layer n and the topmost layer is the user interface so

here in contrast to the monolithic system that we just saw above where everything was packed into a single

level here we have broken down the functionalities into different layers and we have separated them like this so

the main advantage of this is that it is easy to implement and debug this one why because every layer is having different

functionalities so instead of keeping them all together we have divided them into layers and let's say that one layer

is having a problem let's say that the CPU scheduling layer is again having a problem so in order to debug that we

just have to look at that layer and debug that layer instead of going and digging into the entire operating system

so this is one of the advantages of this layered operating system but again we cannot say that this layered approach is

the best because it also has its own disadvantages like for example let us talk about some of the negatives of this

layered structure so one difficulty is in designing this layered structure because you have to be very careful and

specific in designing and deciding which will be the layers on top of a particular layer or which will be the

layers below a particular layer because a layer can use only those layers which are below that layer only the surfaces

by the layers below it can be used by a particular layer like in order to make this clear let me take an example so

let's say that we are having a layer which deals with the backing store that means the layer which deals with Dix

space used by the virtual memory algorithm so there is a layer dealing with the

backing store or the backing storage now this layer we have to make sure that it has to be below the layer that deals

with memory management all right because the memory management routines needs to use the services provided by the backing

storage so because of that we have to make sure that the backing storage layer is below the memory management layer so

this is just one example and in that way there may be so many other requirements which may not be so obvious so we need

to be very careful in designing this so this could be one problem in this and another problem of this layered

structure is that this may be not very efficient as compared to the other structures why that is because when one

layer wants to use the services provided by the layers below it the request has to go down below each layer one by one

and by the time the service is actually provided it may be late it may not be very fast like let's take an example

let's say that a user program from this layer n it wants to execute an input output operation so in order to execute

the input output operations it has to get the service from this layer zero because input output devices are falling

under this Hardware so what it will do it will issue a system call so we have already discussed what our system calls

so this layer will issue a system call in order to use the hardware so the system call has to go through all these

layers one by one and it has to reach this layer zero so as the system call passes through these layers the

parameters of the system calls may be modified and it will take time in reaching here and then once the system

call is granted then it will be able to use the input output devices so we see that as it has to pass through all these

layer one by one it is not going to be very efficient by the time it actually gets

the input output operation as it was requested it is going to take some time so that is one of the major

disadvantages of this layered structure all right so here we have seen the advantages of layer structure and

disadvantages of layer structure one major advantage is that the hardware is protected from the layers above unlike

the simple structure the user interface cannot directly access the Hardware we see that it is protected because of all

these layers above it so that is one of the advantage and we have discussed what is the disadvantage of this layer

structure now coming to the next one we have something known as micro kernels so this is another structuring of operating

system now in the monolithic structure we saw that so many things and so many functionalities were packed into the

kernel making the kernel very big packed with functionalities but in this micr kernel approach what happen happens is

that we are having a micro kernel micro from the name itself we know micro means it is something small so instead of

having a big kernel with so many functionalities what happens is that in this microc kernel approach we remove

all the nonessential components from the kernel and we Implement them as system and user level programs so here the

micro kernel what it will do it will just provide the core functionalities of the kernel and then the other

functionalities which are there like the device drivers the file services or the file servers process servers virtual

memory all the services they are implemented as a user level or system programs so they are on top of this

microc kernel implemented as some kind of system programs so the main function of this micr kernel is to provide a

communication between the client program and these Services all right so there is a client program requesting for some

kind of services so the monolithic approach what will happen is that the client program will have to ask a

service from the kernel because everything is there in the kernel and then from the kernel it has to get its

services but in this micr kernel approach the client program will request something and the micro kernel what it

will do is it will just provide the communication between the client programs and it will just help them to

communicate to these Services which are implemented as system programs and then the communication between the client

programs and these system programs which provide the services are made through with something known as message passing

so message passing is the thing that we use for communication and we will discuss message passing in detail when

we move ahead in this lecture Series so again at the advantage of this micro kernels is that we see that these most

of the functions which are there will be executed in user mode because the kernel is having only the core functionalities

so when the client program wants to access any of the services it does not actually have to be run in kernel mode

it has it can be run in user mode because most of the services are there as a system program now we have already

discussed user mode and kernel mode in the previous lectures so if a program is executing in user mode even if that

program crashes the entire system is not going to crash but if it is running in kernel mode if that particular program

fails then the entire system is going to crash so in micronel approach since most of the functionalities will be run in

user mode the crashing problem of the entire system is not going to happen mostly so that is advantages of micr

Kernel approach but again this also has its own disadvantages like micr kernels can suffer from performance decrease due

to the increased system function overhead because as I told you we are using message passing which helps in

communication of the client programs and these Services over here so since that communication has to be done always

there could be a system overhead leading to a decreased performance so this is another disadvantage of this micr

kernels so that is the concept of micr kernels and we saw how it is good and also what are the negatives of that all

right now coming to the last one we have modules modules means we follow a modular approach in the structuring of

the operating system and this by far perhaps is the best current methodology for operating system design which

involves using objectoriented programming techniques to create a modular kernel so here what happens we

have a core kernel and then this core kernel will have only the core functionalities of the kernel and then

the other functionalities are present in the form of modules which will be loaded to the

kernel either at boot time or at run time so there are some functionalities like the device and bus drive scheduling

classes file systems loadable system calls executable formats stream modules and miscellaneous modules so these

modules will be dynamically loaded to the kernel as and when required so this is how the modular structuring works so

if you look at this modular approach it looks something like the layered approach and also it looks a little bit

like the micr kernel approach let's see why and let's see how it is actually better from those two so it resembles

the layered system inside such a way that each kernel section has defined protected interfaces each of the layers

have a defined protected interfaces which is protected from the things that we don't want them to access but it is

more flexible than a layered system in that any module can call any other module so in the layered approach we saw

that when one layer wants to communicate to another layer it had to go through the layers all above it like for example

we have already seen if let's say that layer 1 wants to communicate or use some services from layer 4 then it has to go

through layer 2 layer three and then reach for but in this modular approach even though it looks like the layered

system it does not have to go through those layers each of the modules can communicate to the other modules

directly through the core kernel let's say that the file systems has to communicate to the device and bus

drivers so it can directly communicate like this all right so that is the advant vantages and flexibility that it

offers as compared to the layered approach even though it looks like the layered approach so though it looks like

the layed approach altogether but it is more flexible and better than the layer approach and also it looks a bit like

the micro kernel approach that we just saw before this so in the micro kernel approach what we had we had the kernel

the micro kernel which have only the core kernel functionalities and then the other functional anties were provided as

system programs above that so here also we are having the core kernel with only the core functionalities and then the

other functions are loaded into it whenever necessary but its Advantage as compared to the micr kernal approach is

that in micronal approach we need to have message passing in order to communicate between the modules because

they are implemented as system or user level programs above the kernel but in this one they are loaded dynamically

Direct ly into the core kernel as and when needed so they don't need to use that message passing and hence the

system overhead is not there so that is the advantages of the modular approach as compared to the layered and micr

kernel approach though it resembles them in some areas so we can say that by far this is one of the best structuring of

the operating system that we can have and is used by most of the operating systems so those were some of the

structures of operating systems so we discuss about the simple structure the monolithic structure the layered

structure the micr kernel approach and then the modular structure so these are the structures of operating system and I

hope this was clear to you thank you for watching and see you in the next one [Music]

[Applause] [Music]