Operating Systems: Process and Thread Management

Flashcards covering the fundamentals of Operating Systems, focusing on process concepts, states, threading models, and inter-process communication mechanisms.

Process

An abstraction of a running program or an instance of an executing program, including the current values of the program counter, registers, and variables.

Multiprogramming

The rapid switching back and forth of the CPU from process to process to improve utilization.

Degree of Multiprogramming

The number of processes loaded simultaneously in memory.

System Initialization

The event during system booting where various foreground and background processes are created.

fork()

A system call in UNIX that creates a process as an exact clone of the calling process, sharing the same memory image, environment strings, and open files.

init

A special process in UNIX boot images that acts as the root of the process tree, spawning terminal processes.

Running State

A process state where the process is actually using the CPU at that instant.

Ready State

A process state where the process is runnable and willing to run, but temporarily stopped because no CPU is available.

Blocked State

A process state where the process is unable to run until some external event, such as the arrival of input, happens.

Process Control Block (PCB)

A data structure identified by a PID that stores essential information about a process, including its program counter, registers, and state, to allow it to be restarted later.

Context Switch

The overhead process of saving the state of an active process into its PCB and restoring the state of a new process from its PCB.

CPU Utilization Formula

A probabilistic model represented as $1 - p^n$, where $p$ is the fraction of time a process waits for I/O and $n$ is the number of processes in memory.

Thread

A lightweight process and single sequence stream within a process that contains its own program counter, registers, and stack while sharing the code and data segments of the parent.

Pthreads

An IEEE standard (1003.1c) for threads supported by most UNIX systems, defining over 60 function calls.

Scheduler Activations

A mechanism that mimics kernel thread functionality with user-space performance by assigning virtual processors to processes and using upcalls for notification.

Upcall

A mechanism in scheduler activations where the kernel notifies a process's run-time system about a blocking event or newly ready thread by activating it at a known starting address.

Pop-up Thread

A new thread created quickly upon the arrival of a message to handle processing; it starts fresh with no history, reducing latency.

Race Condition

A situation where multiple processes manipulate shared data concurrently and the final result depends on the specific order or timing of execution.

Critical Section

The specific part of a program where a shared resource is accessed and where processes must be synchronized.

Mutual Exclusion

A condition ensuring that if one process is using a shared variable or file, other processes are excluded from doing the same thing.

Busy Waiting

The process of continuously testing a variable in a loop while waiting for an event to occur, which wastes CPU time.

TSL (Test and Set Lock)

A hardware instruction used for synchronization that reads a memory word into a register and stores a nonzero value at that memory address indivisibly.

Peterson's Solution

A software-based algorithm for mutual exclusion that uses a 'turn' variable and an 'interested' array to allow two processes to share a resource.

Semaphore

An abstraction variable used to control access to shared resources, categorized into binary (values 0 or 1) and counting types.

Mutex

Short for 'Mutual Exclusion Object,' it is a synchronization tool used to guard critical regions by blocking threads if the associated lock is already held.

Monitor

A higher-level synchronization primitive grouping procedures and data structures together, ensuring only one process is active inside it at any time.

Barrier

A synchronization mechanism for applications divided into phases, blocking any process from proceeding until all processes have reached the barrier.