Process in Operating System (OS)

A process in an operating system refers to a program that is currently executing and using system resources. Understanding processes is important because they form the foundation of multitasking and resource management in an operating system. In this article, we will cover processes in operating systems, including their components, states, life cycle, Process Control Blocks (PCBs), process scheduling, and the difference between a process and a program.

What is a Process in an Operating System?

A process in an operating system is a program that is currently executing on a computer. It is an active instance that uses resources such as CPU time, memory, and I/O resources as needed. A process consists of several components, including program code, a program counter, CPU registers, a stack, a data section, and a heap. Each process has its own process ID and address space.

The operating system manages processes using Process Control Blocks (PCBs), which store information such as process states, priority, and resource usage. A process can move through states, such as new, ready, running, waiting, and terminated. Processes can communicate with one another using Inter-Process Communication (IPC), while the operating system schedules them to determine when they can use the CPU.

How Does a Process Look in Memory?

The following diagram shows the typical memory layout of a process.

A process typically has several memory regions that serve different purposes:

1. Text or Code Segment: The text segment contains the executable instructions of the program. 
2. Data Segment: The data segment stores the global and static variables used by the process. 
3. Heap: The heap is used for dynamic memory allocation during process execution. 
4. Stack: The stack contains function call information, local variables, and return addresses. This means the stack is used for managing function calls and recursion. 
5. Memory-mapped Region: The memory-mapped region can contain shared libraries, mapped files, and other regions mapped into the process virtual address space.

Components of a Process in an Operating System

The main components of a process in an operating system include:

1. Program Code: The executable instructions that make up the program.
2. Program Counter (PC): The Program Counter is a special CPU register that stores the address of the next instruction to be executed.
3. Process Stack: The stack stores temporary data, such as function parameters, return addresses, and local variables
4. Data Section: The data section stores global and static variables used by the process.
5. Heap: The heap is used for dynamic memory allocation while the program is running.
6. Process Control Block (PCB): The operating system creates and maintains a PCB for each process. It stores information, such as:
   • Process ID (PID)
   • Process State (running, ready, waiting, etc.)
   • CPU registers
   • Memory Management Information
   • Scheduling Information
   • Accounting Information 
   • I/O Status Information

7. Open Files List: This keeps track of the files opened by the process.

These components allow the operating system to manage, schedule, and execute processes efficiently.

Become a Certified Software Development Engineer!

Learn from IIT faculty and industry leaders with no prior coding required. Enroll Now!

Explore Program

States of a Process in an Operating System

Here are the main states of the process in the operating system:

• New: The process is being created and initialized by the operating system.
• Ready: The process is ready to run and is waiting to be assigned CPU time.
• Running: The process is currently executing on the CPU.
• Waiting (Blocked): The process cannot continue until an event occurs, such as the completion of an I/O operation.
• Terminated (Exit): The process has finished execution or has been terminated.

The optional states that may be present in some systems: 

• Ready Suspended: The process is temporarily moved from main memory to secondary storage , but remain ready to execute when it is brought back into memory. 
• Waiting Suspended: The process is waiting for an event while also being swapped out of main memory.

Process Life Cycle in Operating System

The process life cycle describes the different stages a process goes through from creation to termination. 

When a program is launched, the operating system creates a process for its execution, initially placing it in the New state. Then it moves to the ready state, waiting for the CPU. When the OS schedules the process, it goes into the running state to execute instructions. If the process needs to wait for something (input/output), it goes into the waiting (Blocked) state. After finishing the wait, it returns to the ready state. The process is in the terminated state when it finishes its task or has been terminated by the system.

This process life cycle helps the operating system manage multiple processes by controlling their state transitions and CPU access.

Steps in the Process Life Cycle

1. New: The operating system creates and initializes the process.
2. Ready: The process is in main memory and waiting to be assigned CPU time.
3. Running: The process is executing instructions on the CPU.
4. Waiting or Blocked: The process cannot continue past this point until an event occurs, like an I/O operation being completed.
5. Ready: After the waiting condition is satisfied, the process returns to the ready queue.
6. Terminated or Exit: The process has completed execution or has been terminated by the operating system.

Process Control Block in Operating System

A Process Control Block (PCB) is a data structure used by the operating system to store information needed to manage a process. The PCB acts as a record for each process and helps the OS manage, schedule, and control it.

Main Components of a PCB:

Here are a few main components of the PCB that will help you to understand the process information better.

1. Process ID (PID): An identifier assigned by the operating system to identify a process.
2. Process State: It indicates the current state of the process, such as new, ready, running, waiting, or terminated. Knowing where it is helps the operating system decide what to do next.
3. Program Counter: A program counter keeps the address of the next instruction to be executed by the CPU. It allows the process to restart where it left off after the context switch.
4. CPU Registers: Store the values of CPU registers associated with the process, such as general-purpose registers and the stack pointers. The specific registers vary by CPU architecture. The operating system saves and restores these register values during context switches so the process can resume correctly. 
5. Memory Management Information: It contains information used to manage the process’s memory, such as page tables, segment tables, or other memory-management structures, depending on the system. This information helps the operating system manage the process’s virtual memory and memory protection.
6. Accounting Information: Information such as total CPU time used, limits on execution time, process priority, and user or group identification is used by the operating system to track the use of resources and may also be used to track resource usage and enforce system policies.
7. I/O Status Information: It contains information about I/O resources, open files, and pending I/O requests associated with the process. This allows the OS to manage and coordinate input/output operations.
8. CPU Scheduling Information: It basically consists of scheduling parameters such as process priority, pointers to scheduling queues, and other relevant data used by the OS scheduler to decide the order in which processes are executed.

Difference Between Process and Program in OS

Process Scheduling in Operating System

Process Scheduling is the mechanism the operating system uses to select which ready process should receive CPU time next. Because multiple processes may compete for available CPU resources, the scheduler must fairly and efficiently share limited CPU time among competing processes.

Here are the main objectives of process scheduling in an OS: 

• It aims to maximize CPU utilization by keeping the CPU busy whenever there are processes ready to execute.
• It determines how CPU time is allocated among ready processes.
• It optimizes performance measures, such as throughput (number of processes completed per time period), turnaround time, wait time, and response time.
• Scheduling decisions can occur when a process is created or terminated, when a waiting process becomes ready, or when a running process is preempted.

Types of Process Schedulers in OS

Operating systems traditionally use three types of process schedulers:

• Long-term Scheduler (Job Scheduler): Selects jobs from the pool of new processes for admission into the system and helps control the degree of multiprogramming.
• Short-term Scheduler (CPU Scheduler): Determines the next process in the ready queue that will execute on the CPU, so that the scheduling operations take place very frequently.
• Medium-term Scheduler (Swapper): Temporarily suspends and resumes processes and resumes, often by moving them between main memory and secondary storage to help control the degree of multiprogramming.

Common Process Scheduling Algorithms in OS

Here are a few common process scheduling algorithms in OS:

• First-Come, First-Served (FCFS): In FCFS, the process that enters the ready queue first is scheduled first.
• Shortest Job First (SJF): SJF selects the process scheduling algorithm with the shortest expected CPU burst time to be scheduled next, thus reducing waiting time.
• Shortest Remaining Time First (SRTF): If a newly ready process has a shorter remaining CPU burst than the currently running process, SRTF can preempt the current process.
• Priority Scheduling: Processes are scheduled according to their assigned priorities, with the scheduling policy determining which priority is favored.
• Round Robin (RR): In round robin scheduling, each ready process receives CPU time for a fixed period called a time quantum. When the time quantum expires, the running process is preempted and moved to the back of the ready queue if it has not finished. This allows processes to share CPU time cyclically.
• Multilevel Queue Scheduling: Processes are divided into separate queues based on characteristics such as process type or priority. Each queue can use its own scheduling algorithm, and the queues may have a fixed priority order for CPU allocation.
• Multilevel Feedback Queue Scheduling: Processes can move between queues based on factors such as CPU usage and scheduling behavior.  Different queues may have different priorities and scheduling algorithms, allowing the system to balance responsiveness, fairness, and CPU utilization.

Conclusion

Understanding processes is a fundamental part of how operating systems control the programs that are currently running. A process is an executing program that goes through a life cycle of states, such as new, ready, running, waiting, and terminated, through the use of operating system tools, including the Process Control Block (PCB) and scheduling algorithms. The operating system manages process states and CPU allocation, enabling multitasking and efficient resource use. Understanding processes helps explain how operating systems manage many tasks concurrently and reliably.

Frequently Asked Questions