Question

Q.6. Consider a preemptive operating system where processes have priorities and a running process gets preempted (i.e., forced to leave the CPU) as soon as a higher priority process is ready to run. The life cycle of a process, other than the very first process, begins with a "spawn" by another process and ends with either a regular "exit" by the process or a "terminate (process_id)" command by another process of equal or higher priority. COMP 346 – Fall 2019 TA 1 - page 1 of 2 Each process is assigned an initial priority at spawn time and this priority remains unchanged during the entire life cycle. There are system resources, both hardware and software, for which a process can block if the resource is not free. A process can also be suspended by another process of equal or higher priority through the call "suspend (process_id)". A suspended process is resumed by the call "resume (process_id)". Note that a process can be in any state (i.e., running, blocked or ready) when suspended. Processes communicate with one another via "send" and "receive" message passing primitives. "Receive" is always blocking, i.e., the calling process blocks if the message is not available. "Send" is always non-blocking. Illustrate the complete life-cycle of a process with the help of a process state transition diagram.

Answer 1

Before going into the life cycle of process we need to know about what process is. So When we write any instruction into any environment then it will must go for execution, so when an instruction is in execution state then it is called process.

If we talk about the life cycle of process, As a process executes,it changes state. The state of a process is defined in part by the current activity of that process. A process may be in one of the following states:
• New. The process is being created.

• Running.Instructions are being executed

• Waiting. The process is waiting for some event to occur (such as an I/O completion or reception of a signal).

• Ready. The process is waiting to be assigned to a processor

• Terminated. The process has finished execution.

The main priority is to maximize the CPU utilization, for this OS system enable concurrent access the critical section where the process are sharing something let say variables. For concurrent accessing of critical section, process should be preemptive so that other process can execute if any process is taking more time or any process moves for input/output operations then other process can execute their instructions. Suppose of one process let say p1 is currently executing in critical section in CPU, let say high priority process p2 came there then p1 will get preempt and high priority process will execute.

In priority scheduling algorithm in os, The SJF(shortest job first) algorithm is a special case of the general priority-scheduling algorithm. Apriority is associated with each process, and the CPUis allocated to the process
with the highest priority. Equal-priority processes are scheduled in FCFS order. An SJF algorithm is simply a priority algorithm where the priority (p) is the inverse of the (predicted) next CPU burst. The larger the CPU burst, the lower the priority, and vice versa.

Priority scheduling can be either preemptive or non-preemptive. When a process arrives at the ready queue, its priority is compared with the priority of the currently running process. A preemptive priority scheduling algorithm
will preempt the CPU if the priority of the newly arrived process is higher than the priority of the currently running process. A non-preemptive priority scheduling algorithm will simply put the new process at the head of the ready
queue.

In various case we may face the deadlock situation. A set of processes is in a deadlocked state when every process in the set is waiting for an event that can be caused only by another process in the set. The events with which we are mainly concerned here are resource acquisition and release. The resources may be either physical resources (for example, printers, tape drives, memory space, and CPU cycles) or logical resources (for example, semaphores, mutex locks, and files). However, other types of events may result
in deadlocks. let say example consider a system with one printer and oneDVDdrive. Suppose that process Pi is holding the DVD and process Pj is holding the printer. If Pi requests the printer and Pj requests the DVD drive, a deadlock occurs. for removing these issue we have various deadlock handling algorithms are designed.

A process also have suspend properties by which any high priority process can suspend the low priority process through the suspend(process_id) and then again that process can resume their task. let say in Linux system

You can use kill to stop the process.

For a 'polite' stop to the process (prefer this for normal use), send SIGTSTP:

kill -TSTP [pid]

For a 'hard' stop, send SIGSTOP:

kill -STOP [pid]

Note that if the process you are trying to stop by PID is in your shell's job table, it may remain visible there, but terminated, until the process is fg'd again.

To resume execution of the process, sent SIGCONT:

kill -CONT [pid].

A message queue is a linked list of messages stored within the kernel and identified by a message queue identifier. A new queue is created or an existing queue opened by msgget().
New messages are added to the end of a queue by msgsnd(). Every message has a positive long integer type field, a non-negative length, and the actual data bytes (corresponding to the length), all of which are specified to msgsnd() when the message is added to a queue. Messages are fetched from a queue by msgrcv(). We don’t have to fetch the messages in a first-in, first-out order. Instead, we can fetch messages based on their type field.

All processes can exchange information through access to a common system message queue. The sending process places a message (via some (OS) message-passing module) onto a queue which can be read by another process. Each message is given an identification or type so that processes can select the appropriate message. Process must share a common key in order to gain access to the queue in the first place.