Program vs Process

• Process management involves various concepts related to programs and processes.

Program vs Process

• A process is a program in execution, contrasting with a program, which is static.
• When source code is compiled (e.g., in C or C++), the compiler generates binary code, which is a program.
• Both the original code and the binary code are considered programs.
• When binary code is executed, it becomes a process.
• Processes are active entities, while programs are passive.
• A single program can initiate multiple processes when run concurrently
• For example, opening a .exe file multiple times creates multiple instances: multiple processes.

Process Memory Structure

• A process in memory is divided into sections:
• Text Section: Contains executable code and the current activity, indicated by the Program Counter.
• Stack: Holds temporary data like function parameters, return addresses, and local variables.
• Data Section: Stores global and static variables.
• Heap Section: Provides dynamically allocated memory during runtime.

Examples of Programs and Memory Sections

• Example 1: demonstrates a simple C program to find the maximum of two numbers and shows logical memory allocation.
• Example 2: C program utilizing dynamic memory allocation with malloc, also illustrating memory sections.
• Example 3: Shows passing an array to a function to calculate the elements' sum, demonstrating data handling in memory.

Process States

• A process transitions through different states during execution.
• These states reflect the process's current activity.
• States include:
  • New: The process is being created.
  • Ready: The process is ready to run, awaiting CPU allocation, and loaded into the main memory.
  • Run: The CPU is executing the process instructions.
  • Wait (or Block): The process is waiting for an I/O operation or event to occur.
  • Complete (or Terminated): The process has finished execution.
  • Suspended Ready: The process is moved to a suspended state when the ready queue is full.
  • Suspended Block: Occurs when the waiting queue is full.

Process Schedulers

• Process scheduling is managed by the process manager, involving the removal and selection of processes from the CPU based on strategy.
• The three types of process schedulers are:
  • Long Term (Job Scheduler): Introduces new processes to the Ready state and controls the degree of multi-programming.
    • Balances I/O-bound and CPU-bound processes to increase efficiency.
  • Short Term (CPU Scheduler): Selects a process from the ready state to execute, preventing starvation.
    • Note that the scheduler chooses only to schedule the process and doesn’t load the process to running. This is when scheduling algorithms apply.
  • Dispatcher: Loads the process selected by the short-term scheduler onto the CPU, facilitating Context switching.
  • Medium Term: Handles suspending and resuming process, mainly through processes swapping to disk when memory overcommitted.
    • Helps maintain balance between I/O-bound and CPU-bound processes and reduces multi-programming.

Context Switching

• Context Switching saves the state of one process and loads another, essentially unloading and loading processes between the running and ready states.
• Context switching occurs when:
  • A high-priority process enters the ready state.
  • An interrupt occurs.
  • There is user and kernel-mode switch.
  • Preemptive CPU scheduling is used.

Process Table and Process Control Block (PCB)

• While creating a process, the OS performs multiple operations.
• The OS assigns a process ID to track each process individually.
• Due to multi-programming support, OS needs to keep track of all the processes ongoing using the PCB to track process execution.
• PCB contains:
  • Memory blocks with process state info, program counter, stack pointer, and file statuses.
  • Process State: Records the current process state.
  • Process Number: an ID that identifies.
  • Program Counter: Stores the address of the next instruction to be executed.
  • Registers: CPU registers like accumulators and base registers.
  • Memory Limits: Stores memory management system info with page table and segment table.
  • Opened Files List: a list of files opened by the process.
• The stored information is saved when switching process states, and the OS updates the PCB to reflect these changes.

Thread in Operating Systems

• A thread is a path of execution within a process, where a process can contain multiple threads.
• Also known as a "lightweight process," achieving parallelism by dividing processes into multiple threads.
• For example, tabs in a browser or formatting and input processing in MS Word are managed as individual threads.

Process vs Thread

• Threads within the same process share memory space.
• Processes run in separate memory spaces.
• Threads share code, data sections, and OS resources, like files and signals.
• Both processes and threads have their own program counter, register set, and stack space.

Differences Between Processes and Threads

• Process: Means any program in execution.
• Thread: Means segment of a process.
• Processes take a longer time to terminate compared to threads.
• Process creation takes longer.
• Context switching takes more time for processes.
• Processes are isolated meaning thread share memory.
• Processes are heavy weight, whereas threads are light weight.
• Process switches use interfaces in operating system while thread switches do not.

Advantages of Threads over Processes

• Threads provide faster context switching compared to processes.
• Multiple threads effectively enhance the utilization of multiprocessor systems, making processes execute faster.
• Code, data, and files can be shared among the threads
• Note that stack and registers can't be shared, each thread has its own stack and registers.
• Threads share a common address space, hence better communication.
• Dividing tasks into threads enhances the throughput of the system.

Kernel in Operating Systems

• The Kernel is the central component of an operating system which manages memory, CPU time and hardware.
• It acts as a bridge between applications and hardware using inter-process communication.
• It decides which process should be allocated to the processor and be kept in the main memory.

Objectives of the kernel

• Establishing communication between the application and the hardware.
• Decide state of incoming processes.
• Control disk and memory management.
• Control Task Management.

Thread Types

• There are two types of threads:
  • User Level Thread
  • Kernel Level Thread

User Level Threads (ULT)

• Implemented in user-level libraries.
• Thread switching does not involve OS calls or interrupt the kernel.
• Kernel does not know about the users so manages it as a single threaded process.
• ULT advantages: - Simpler representation since limited to program counter, registers and stack space. - Simple and fast to create.
• ULT disadvantages: - Coordination among threads is restricted. - A page fault can block over the entire process.

Kernel Level Threads (KLT)

• The kernel knows and manages the threads.
  • Kernel itself has a master thread table, instead of having a process thread table for all the threads in the system. - System calls create and manage threads
• KLT advantages:
  • Good for applications that frequently need to block.
• KLT disadvantages:
  • Slow and inefficient.
  • It is an overhead and requires thread control.

User Level Threads (ULT) vs Kernel Level Threads (KLT)

• ULT are are implemented by users while KLT are implemented by OS.
• ULT switch time less whereas KLT has higher switch time.
• Implementation easy for ULT and complicated for KLT.
• Kernel threads are designed as thread independent, so they continue execution and provide better concurrency.

CPU Scheduling

• Scheduling of processes/work is the way to ensure finishing work on time.
• Key process times:
  • Arrival Time: the time when a process arrives in a ready queue.
  • Completion Time: The time at which the process completes the execution.
  • Burst Time: The time required for CPU execution. -Turn Around Time (TAT): the difference between completion and arrival. (TAT = Completion Time – Arrival Time).
  • Waiting Time: the difference between the turn around time and the burst time.

CPU Scheduling Needs

• A typical process uses I/O time and CPU time.
• If multi-programming is not used, CPU is free time is wasted.
• Multi programming helps processes use the CPU while waiting for I/O.

Process Scheduling Algorithm Objectives

• Objective is to maximize CPU utilization and fair allocation, maximizing the amount of processes that can complete execution per time unit, fairness, and fast execution.

Preemptive Scheduling

• A process’s ability to execute is paused for the resources that are available and then returned to the ready queue if the process has CPU execution remaining.
• The process waits to execute until it receives the next chance.

Non-Preemptive Scheduling

• A process terminates only when the process releases what is allocated or is stopped.

FCFS CPU Scheduling

• Given n processes with their burst times, the task is to find average waiting time and average turn around time using FCFS scheduling algorithm.
• also known as first come, first served (FCFS), is the simplest scheduling algorithm.
• processes are added to the ready queue based on order they arrive in.
  • the process the first arrives is executed first, next will continue after it the first fully executes.
  • the process the first arrives is executed first.
  • The arrival time here is assumed to be all "0" in the ready states for all processes.

FCFS Convoy Effect

• the burst time has a high impact.

Shortest Job First (SJF) CPU Scheduling

• This algorithm picks the waiting process that has the smallest execution time to execute next.
• SJF is a non-preemptive algorithm.
• Having a minimum average waiting among all scheduling algorithms.
• may cause starvation if a process is repeatedly chosen.

Shortest Remaining Time First (SRTF) CPU Scheduling

• This is the preemptive version.
• At the arrival of every process the short term scheduler looks and makes decisions to choose between available processes.

Round Robin (RR) Scheduling

• Process has assigned time to each process that is assigned via the time quantum.
  • Specifically designed for the time-sharing system
    • It provides interrupt for running processes that execute longer that assigned, and processes get added to the tail of ready queue.

Priority CPU Scheduling

• A non-preemptive algorithm, and commonly found in batch systems.
• It is assigned first arrival time, and if two processes have equal arrival time, it is then compared to see priorities based on highest amount process first and repeated until processes are executed.

Multilevel Queue Scheduling

• processes are placed in the queues based on amount of priority.
• the high priority processes are placed at the top level queue.
• Processes are only scheduled in the lower lever queues after the completion.
• It may be subject to process starvation.

Multi Level Feedback Queue Scheduling

• The processes can be between the queues. - It helps separate based on the specific characteristics of the CPU Bursts. - It helps separate based on the specific characteristics of the CPU Bursts.