Operating Systems: Processes

• Programs on an operating system can be broken down into jobs for batch systems or user programs/tasks for time-shared systems.
• The terms "job" and "process" are often used interchangeably in textbooks.
• A process is a program in execution that progresses sequentially.

Process Components

• Text Section: Program Code.

• Current Activity: Values of the Program Counter and processor's registers.

• Stack: Temporary data, including function parameters, return addresses, and local variables.

• Data Section: Global and static variables.

• Heap: Memory dynamically allocated during runtime.

• A program is a passive entity stored on disk as an executable file, while a process is an active entity.

• Programs become processes once loaded into memory.

• Program execution can start from GUI clicks or command lines.

• One program can result in multiple processes, such as multiple users running the same program.

• A process requires resources like CPU, memory, I/O, files, and initialization data, allocated on creation or during execution.

Types of Processes

• Foreground Processes: Interact w/ users, they run on-screen, need user input & they have higher priority; e.g., Office Programs, browsers.
• Background Processes (Daemons): Not directly user-associated, run in the background, require less user input; e.g., spell-checker, printer program.

Process State

• The state of a process changes as it executes.
• New: The process is being created.
• Ready: Process waiting for processor assignment; kept in a ready queue.
• Running: Instructions are being executed.
• Waiting: The process is waiting for an event, placed in a waiting queue.
• Terminated: The process has finished its execution.
• An operating system performs all of the previous tasks.

State Transitions

• Null to New: Occurs when a process is created to execute a program.
• New to Ready: Occurs when the operating system admits a new process.
• Ready to Running: The operating system chooses a process in the ready state to run; dispatching happens here, managed by the dispatcher (scheduler).
• Running to Blocked: Occurs when a process requests something for which it must wait (e.g., I/O operation, file, input/message from another process, shared virtual memory).
• Blocked to Ready: Occurs when the event a process was waiting for happens.
• Running to Ready: Occurs when a process is preempted by the operating system (e.g., time expired, higher priority process moves to ready state, timeout).
• Running to Exit: Occurs when a running process terminates.
• Ready to Exit.
• Blocked to Exit.

Operations

• Process Creation: OS, parent process or user create a process.

• Process Termination: OS, parent process or user terminates a process.

• Resource Allocation: Allocate and de-allocate resources.

• A parent process creates child processes, forming a process tree.

• Processes are identified and managed using a process identifier (pid).

Resource Sharing

• Parent and children sharing all resources.
• Children sharing a subset of parent's resources.
• Parent and child sharing no resources.

Execution options

• Parent and children execute concurrently.
• Parent waits until children terminate.
• Address space is the memory available for a process.
• Child Duplicate of a parent has the same address space (code, data, program).
• Child loading a program into it creates a separate address space for the child.
• fork() is a system call, in UNIX, that creates a new process.
• exec() is a system call used after fork() to replace the process's memory space.

Process Termination

• The exit() system call is used by a process to request its deletion from the OS after its final statement.
• Parent receives the status data from the child via wait().
• Operating system then de-allocates resources
• The abort() system call is used by parents to terminate the execution of child processes.
• Termination Reasons: Child exceeding allocated resources, task no longer required, or parent exiting.
• The wait() system call is uased by a parent process to wait for a child's termination, it returns termination status and the pid of the exited process.
• Zombie processes result from a parent not waiting (not invoking wait()) for a child.
• Orphan processes result from a parent terminating without invoking wait.

Termination can occur through:

• Normal, voluntary exit.
• Voluntary error exit.
• Involuntary fatal error.
• Being killed by another process involuntarily.

Process Control Block (PCB)

• The PCB, stores information for each process.
• Components: process state, program counter (next instruction location), CPU registers, CPU scheduling info, memory management info, accounting info, & I/O status.

Interprocess Communication (IPC)

• Independent processes cannot affect other processes.
• Cooperating processes can affect or be affected by each other, including sharing data.
• Cooperation Reasons: information sharing, computation speedup, modularity.
• Google Chrome's new tab feature uses a separate thread.
• IPC is necessary for cooperating processes.

IPC Models

• Shared Memory: Processes access a common memory area.
• Message Passing: Processes communicate through exchanging messages.
• Other methods: using pipes, sockets, etc.

Shared Memory

• Shared memory communications are under user process control, not the OS.
• It's Important to synchronize for user processes to ensure actions access shared memory properly.

Message Passing

• Processes communicate and synchronize actions through messages.
• The sender writes to a queue/buffer, the receiver reads from it.
• Systems don't need shared variables.
• send(message) is one of two operations, for communication, under IPC.
• receive(message) is the second.
• Messages can be fixed or variable in size.
• Processes "P" and "Q" need to establish a communication link and exchange messages via send/receive to communicate.

Communication Link Implementation Issues:

• Establishment
• Link association
• Link quantity
• Link capacity
• Message size accommodation
• Unidirectional or bi-directional link

Implementation

• Physical: shared memory (single-processor), hardware bus (multi-processor), or network (distributed systems).
• Logical: Direct or indirect, synchronous or asynchronous, and automatic or explicit buffering.

Producer-Consumer Paradigm

• A producer process generates information to a consumer process.
• The producer inserts data in an empty buffer slot.
• A consumer removes data from a filled slot.
• The consumer removes data from filled slots.
• Errors arise when a producer adds to a full buffer.
• Errors arise when a consumer removes data from an empty buffer.
• Concurrent insertion and removing lead to errors.

Process Switching

• Process switch, like context switch, occurs when the OS interrupts a running process to assigns another to a running state.
• Process Switch Involves: saving current context, PCB updates, queue adjustments, & memory management updates, and lastly, restoring.

Threads

• Thread is a manageable agent for task execution, sharing resources.
• Processes use a single thread of execution.
• Consider multiple program counters (multiple locations to execute)
• Create threads via multiple threads of control.
• Then you must have storage for thread details & multiple program counters in PCB.
• A program or application is divided into many independent threads through Multithreading.
• Examples; Excel application, client browser, multithread server, OS, implemented using multithreads.
• Each thread owns program counter (tracks instructions), stack, registers (hold current variables and history of execution).

Thread vs. Process

• A process is a collection of threads sharing resources.
• A thread is a dispatchable work unit.
• Traditional OS are single-threaded.
• Modern OS are, multithreaded.
• Processes have heavy weighting and interact with the OS.
• Threads have light weighting and do not interact OS.
• Processes are independent, but threads aren't.
• Independent data and code segments are used for processes while they share them among them for threads.
• Processes consume more resources, while threads, consume less.