Processes: Definition, Management, States & Communication

• Education is a powerful tool for changing the world, as stated by Nelson Mandela

Processes

• Covers process definition, management, states, scheduling, context switching, and inter-process communication
• Learning outcomes include defining processes, differentiating between processes and threads, understanding multitasking and process states
• Aims to teach process operations (creation, termination, communication) and the Producer-Consumer model

Process Definition and Management

• Program source code written in a high-level language like C++/Java is transformed into machine-readable code
• A compiler transforms the code that operating system loads into computer memory for program execution, allocating resources as needed

Process vs. Thread

• A process is a program in execution
• A thread is a unit of execution within a process
• A process can have one or more threads

Multitasking

• Processes spend time on I/O activities, which is slower than CPU processing
• Multitasking happens when the OS runs multiple processes concurrently by time-sharing hardware

Chrome Browser Example

• Chrome uses multiple processes: a browser process for the UI and network I/O, renderer processes for web pages and HTML parsing, and plug-in processes like Adobe Flash Player
• Adobe Flash Player enables viewing multimedia content, executing rich internet applications, and streaming audio/video

Process State

• The state is defined by the current activity
• When executing, a process changes states

Five Process States

• New: The process is being created
• Running: Instructions are being executed
• Waiting: Waiting for an event (I/O completion or a signal)
• Ready: Waiting to be assigned to a processor
• Terminated: The process has finished execution

Diagram of Process State

• Illustrates transitions between New, Ready, Running, Waiting, and Terminated states via events like interrupts, scheduler dispatch, and I/O

Process Control Block (PCB)

• Each process runs in the OS and is tracked via a PCB - sometimes called a task control block
• PCB represents a process in the Operating System

PCB Contents

• Process ID: Unique identifier
• Process State: Current state (New, Waiting, etc.)
• Program Counter: Points to the next instruction to be executed
• CPU Registers: Registers used by process
• CPU Scheduling Information: Process priority, scheduling queue
• Memory Management Information: Memory used by the process
• Accounting Information: Resources used (CPU, time, memory)
• I/O Status Information: I/O devices assigned

PCB in Linux

• Linux maintains a doubly-linked list of processes using the C structure task_struct

Process Scheduling

• Multiprogramming maximizes CPU use by running a process all the time
• Time sharing switches the CPU between processes, and allows user interaction
• The process scheduler makes program accessible for the CPU to run it

Single Processor System

• Only one process can run at the same time on a computer

Scheduling Queues

• Job Queue: Contains all processes in the system
• Ready Queue: Contains processes residing in main memory, ready and wait time

Schedulers

• Long-term (job) scheduler: Selects processes from a storage pool and loads them into memory
• Short-term (CPU) scheduler: Selects from ready processes and allocates the CPU
• Medium-Term Scheduler: Part of swapping, removes processes from memory to reduce multiprogramming, manages swapped-out processes

Context Switch

• The operating system has to save the current context of the process that's currently running on the CPU so that it can restore that context when its processing is done, suspending the process and then resuming it
• The PCB stores it in the context

Concept of Context

• Interrupts cause the OS to switch the CPU from the current task to a kernel routine
• The system saves the current process context (state) for later restoration

Context Switch Details

• A context switch occurs when a CPU core switches from one process to another
• The OS saves the context of the current process and loads the context of the new process
• A scheduler decides when to perform a context switch and selects the next process, this occurs in the kernel

Context Switch Performance

• Context switch time is pure overhead
• Speed varies depending on memory speed and registers
• Typical speeds are milliseconds

Operation on Processes: Creation

• Via a create process-system call, a process can create several new processes
• The creating process is considered the parent process, and the new processes are called the children.
• Each process has a unique pid (process identifier), usually an integer

Process Creation Options

• Parent can execute concurrently with its children

• The parent can wait until some or all of its children are terminated

• The child is a duplicate of the parent

• The child uses a new program loaded

Process Creation in UNIX and Windows:

• UNIX programs use fork() to create a new process, exec() to replace its image, exit() to terminate, and wait() for child processes
• Windows uses CreateProcess() to specify the command to execute in a child process; it does not support fork()

Process Termination

• A process ends by calling exit()
• The parent recovers the status via wait().
• The PCB waits until the parent calls wait() and becomes a zombie process
• The kernel can also "kill" a process

Inter-Process Communication (IPC)

• Concurrent processes are either independent or cooperating
• IPC is needed in cooperating processes

Needs for Inter-Process Communication

• Information sharing
• Computation speedup
• Convenience

IPC Methods

• Shared Memory: A shared memory region is established with cooperating processes
• Message Passing: Uses messages exchanged between processes
• Pipes: Functions like shared files, with one process writing and another reading (unidirectional)
• Sockets: Endpoints for communication, identified by IP address and port number

Producer-Consumer Model

• A common IPC pattern involves a producer and a consumer which run concurrently
• Buffering is needed to handle variable production/consumption rates
• A buffer has a limited size, so it's also called a bounded-buffer problem

Example Practical Implementations

• I/O device drivers act as producers, collecting input that applications (consumers) process
• Print spooling involves applications sending files to a folder
• After this a spooler process sends them to the printer one at a time

Shared Memory

• Different memory accessible by different processes in a bidirectional manner

Shared Memory: Consumer-Producer Model

• Uses a memory area that the accessing processes use
• Producer and consumer utilize a shared buffer

Key Concepts

• Processes have unique memory spaces
• The OS provides special ways to allocate memory that can be shared across processes
• The code given in the previous slide is not synchronized!!

Key Considerations of shared memory and Message passing

• Shared memory allows processes to allocate memory for use in several processes
• OS provides special ways to allocate this memory, these have to be created explicitly with more configuration than message passing
• Sharing memory only works with systems the memory across them, and this implementation requires a kernel

Message Passing

• Uses direct links with send(pid, msg) and recv(pid, msg)
• Uses indirect links with mailboxes send(mbox, msg) and recv(mbox, msg)
• send() and recv() can be blocking or non-blocking, some apps utilize these for synchronization

Message Passing: Consumer-Producer Model

• Consumer reads from the producer
• Producer sends message to consumer

Characteristics of Shared Memory and Message Passing

• Shared memory requires system calls only to establish shared regions, then accesses work as routine memory accesses
• Message passing requires more kernel intervention, is useful for small data, and is easier to implement in distributed systems

Pipes

• Acts like having an intermediate file where one process writes and the other process reads, pipes exist in main memory
• The system calls used to read and write to/from a pipe mirror file accessing
• Examples are READ() and WRITE()

Two pipe types

• Ordinary pipe in UNIX (Anonymous pipes in Windows) work by creating a parent that connects to a child process to create a line of communication
• Named pipe - also known as AKA FIFO makes information accessible by process
• In both cases Pipe is Unidirectional, but two pipes can be added to ensure that you can create two lines of pipes in different directions

Pipes In Code

• In code a descriptor fd[0] is for reading and fd[1] is for writing
• If the program is connected, the data written in fd[1] can be read from fd[0]

Pipes in Command Line Interface (CLI)

• CLI creates pipes between two programs where you can redirect input and output
• You can redirect the output of a command into a specified file by adding the redirector, represented by ">"
• The Pipe symbol "|" pipes the output of the first command, and pipes it directly as in input into the second command