Info-Grade: OS Notes

Critical Section (Operating System)

One way to avoid race conditions is not to allow two processes to be in their critical sections at the same time.
Critical section is the part of the process that accesses a shared variable.
That is, we need a mechanism of mutual exclusion. Mutual exclusion is the way of ensuring that one process, while using the shared variable, does not allow another process to access that variable.

Race Condition (Operating System)

Race conditions are situations where two or more processes reads or writes some shared data at the same time and the final result is incorrect.
Final result may be different according to order of completion of competing processes.
let us consider a simple but common example: a print spooler. When a process wants to print a file, it enters the file name in a special spooler directory.
Another process periodically checks to see if there are any files to be printed, and if there are, it prints them and then removes their names from the directory.
Consider the situation given in figure below, where in and out are two shared variables.

Process A reads value of in(i.e. 7) but before inserting the name of the document to be printed in index 7, the CPU decides to schedule process B.
Now, process B also reads in, and also gets 7. Process B now continues to run and stores the name of its file in slot 7 and updates in to be an 8.

After some time process A runs again. It looks at value of in stored in its local variable and finds a 7 there, and writes its file name in slot 7.Then it increments value of in and sets in to 8.The printer daemon will not notice anything wrong, but process B will never receive any output. Situations like this are called race conditions.

System Calls (Operating System)

System calls are the interface between the operating system and the user programs. Access to the operating system is done through system calls.
Each system call has a procedure associated with it so that calls to the operating system can be done in a similar way as that of normal procedure call.
When we call one of these procedures it places the parameters into registers and informs the operating system that there is some work to be done. When a system call is made TRAP instruction is executed. This instruction switches the CPU from user mode to kernel (or supervisor) mode.

Eventually, the operating system will have completed the work and will return a result.
Making a system call is like making a special kind of procedure call, only system calls enter the kernel and procedure calls do not.
Example: count = read(file, buffer, nbytes);

To make this concept clearer, let us examine the read call written above. Calling program first pushes the parameters onto stack (steps 1-3) before calling the read library procedure (step 4), which actually makes the read system call.

The library procedure, possibly written in assembly language, typically puts the system call number in specified register (step 5). Then it executes a TRAP instruction to switch from user mode to kernel mode and start execution at a fixed address within the kernel (step 6).
The kernel code examines the system call number and then dispatches to the correct system call handler (step 7). At that point the system call handler runs (step 8).

Once the system call handler has completed its work, control may be returned to the user-space library procedure at the instruction following the TRAP instruction (step 9).
This procedure then returns to the user program in the usual way procedure calls return (step 10).
To finish the job, the user program has to clean up the stack, as it does after any procedure call (step 11).

Process and Thread its Difference in CPU (Operating System)

Process

Process is a program that is ready for execution in CPU. When a program is loaded into memory, it becomes ready for execution and competes with other process to access CPU. Thus when a program is loaded into memory it becomes process. Computers nowadays can do many things at the same time. They can be writing to a printer, reading from a disc and scanning an image. Operating system is responsible for running many processes, usually, on the same CPU. In fact, only one process can be run at a time so the operating system has to share the CPU between the processes that are available to be run, while giving the illusion that the computer is doing many things at the same time. This approach can be directly contrasted with the first computers. They could only run one program at a time.

Now, the main point of this part is to consider how an operating system deals with processes when we allow many to run. To achieve true parallelism we must have multiprocessor system when n processors can execute n programs simultaneously. True parallelism cannot be achieved with singl CPU. In single processor CPU switched from one process to another process rapidly. In 1 sec CPU can serve 100's of processes giving the illusion of parallelism to a user which is called pseudo-parallelism.

Threads

Threads are like mini-processes that operate within a single process. Each thread has its own program counter and stack so that it knows where it is. Apart from this they can be considered the same as process, with the exception that they share the same address space. This means that all threads from the same process have access to the same global variable and the same files. Threads are also called light weight process. The table given below shows the various items that a process has compared to the items that each thread has.

Uses of Thread

Some application need to perform multiple activities at once that share common data and files. Thus reason behind need of multiple threads.
Ability of parallel entities, within a process to all share common variables and data.
Since threads do not have their own address space, it is easier to create and destroy threads than processes. In fact thread creation is around 100 times faster than process creation.
Thread switching has much less overhead than process switching because threads have few information attached with them.
Performance gain when there is a lot of computing and lot of I/O as tasks can overlap. Pure CPU bound thread application no advantage through
Threads are very effective on multiple CPU system for concurrent processing because with multiple CPU's true parallelism can be achieved

**Difference between Process and Threads**
Thread	Process
- Threads are lightweight	- Processes are heavyweight
- Threads are runs in address space of processes	- Processes have their own address space
- Threads shares files and other data	- Processes do not share files and other data
- Thread switching is faster	- Process switching is slower
Threads are easy to create and destroy	Process are difficult to create and destroy