D686: Operating Systems for Computer Scientists (chapter 4 & 5)

threads

lightweight units of process execution that share the same memory space but run independently

register set

collection of registers used to store data and instructions currently being processed by the CPU

user thread

a thread that operates exclusively in user mode, managed and scheduled by user-level thread libraries without direct kernel involvement

kernel threads

threads that operate in kernel mode, directly managed by the operating system kernel, providing efficient execution and access to system resources

user thread

A thread running in user mode.

kernel threads

Threads running in kernel mode.

thread control block (TCB)

a data structure in an operating system that stores information about a thread, including its identifier, state, CPU information, priority, and pointers to related threads

thread ID

unique identifier assigned to a thread by the operating system

thread state

the current condition or status of a thread in the system (e.g., running, waiting, blocked)

register contents

the current values stored in the CPU registers used by the thread

thread priority

the assigned importance level of a thread, determining its scheduling order compared to other threads

multicore

refers to a CPU architecture that integrates multiple processing cores onto a single chip, or within a single system, enabling parallel execution of tasks

data parallelism

a computational technique where subsets of identical data are distributed across multiple processing cores, 
each core performing the same operation simultaneously on its subset of data

task parallelism

a computational approach where tasks or threads are distributed across multiple processing cores, with each task executing a unique operation independently, often on different or related data sets

fork()

a system call that creates a new process by duplicating the existing process

exec()

a system call that replaces the current process with a new program

signal

a way to alert a process about an event

default signal handler

the built-in handler for signals unless a process uses its own

pthread_kill()

a function in the POSIX threads (Pthreads) library used to send a signal to a specific thread within the same process

asynchronous procedure call (APC)

a function a thread sets to run when it gets a certain notice 

thread cancellation

ending a thread before it finishes

pthread_cancel()

a function that requests the cancellation of a specific thread in Pthreads

process synchronization

the coordination of processes to ensure they operate smoothly and efficiently without interfering with each other, especially when accessing shared resources or data

mutex

short for mutual exclusion, a mutex is a lock that ensures only one process can access a critical section or resource at a time, preventing race conditions

semaphores

synchronization tools used to control access to shared resources by multiple processes

starvation

a situation where a process is perpetually denied access to resources because other processes continuously acquire them

circular wait

a condition where each process in a set is waiting for a resource held by another process in the same set, contributing to deadlock

fair resource allocation

a principle ensuring that all processes have fair access to resources, preventing starvation and ensuring balanced system performance

producer-consumer scenario

where one process produces data and another consumes it, requiring synchronization to ensure that the buffer used does not overflow or underflow

concurrency

the ability of an operating system to execute multiple processes simultaneously, improving performance and responsiveness

critical section

A section of code responsible for changing data that must only be executed by one thread or process at a time to avoid a race condition.

entry section

The section of code within a process that requests permission to enter its critical section.

exit section

The section of code within a process that cleanly exits the critical section.

remainder section

Whatever code remains to be processed after the critical and exit sections.

preemptive kernel

A type of kernel that allows a process to be preempted while it is running in kernel mode.

nonpreemptive kernels

A type of kernel that does not allow a process running in kernel mode to be preempted; a kernel-mode process will run until it exits kernel mode, blocks, or voluntarily yields control of the CPU.

mutex lock

A mutual exclusion lock; the simplest software tool for assuring mutual exclusion.

contended

A term describing the condition of a lock when a thread blocks while trying to acquire it.

uncontended

A term describing a lock that is available when a thread attempts to acquire it.

busy waiting

A practice that allows a thread or process to use CPU time continuously while waiting for something. An I/O loop in which an I/O thread continuously reads status information while waiting for I/O to complete.

spinlock

A locking mechanism that continuously uses the CPU while waiting for access to the lock

semaphore

An integer variable that, apart from initialization, is accessed only through two standard atomic operations: wait() and signal().

counting semaphore

A semaphore that has a value between 0 and N, to control access to a resource with N instances.

binary semaphore

A semaphore of values 0 and 1 that limits access to one resource (acting similarly to a mutex lock).

readers-writers problem

A synchronization problem in which one or more processes or threads write data while others only read data.

reader-writer lock

A lock appropriate for access to an item by two types of accessors, read-only and read-write.

dining-philosophers problem

A classic synchronization problem in which multiple operators (philosophers) try to access multiple items (chopsticks) simultaneously.

monitor

a synchronization construct in programming languages that prevents race conditions

synchronization

coordinating processes or threads to ensure they work together properly without causing problems

initialization

the setup code included in the monitor package and used once when creating the monitor

encapsulation

keeping data and methods that use it together in one unit to make it easier to manage and protect

monitor entry queue

a place that holds all the threads (or procedures) waiting to enter the monitor

monitor procedure

 functions that can be called from outside the monitor

private data

secret data inside the monitor, including private functions that cannot be used outside the monitor

signal()

a function that allows one of the paused processes in the waiting queue to start running

wait()

a function that pauses a process and puts it in a waiting queue inside the monitor

interprocess communication (IPC)

mechanisms allowing processes to communicate and synchronize their actions

race conditions

occur when multiple processes access and modify shared data concurrently, leading to unpredictable outcomes depending on the timing of their execution

shared variables

memory locations accessible by multiple processes for reading and writing data