Operating Systems Chapter 4: Threads

Heavyweight process

Process with only one thread of control.

Threads

Process-tasks running concurrently, each with their own registers and stacks, sharing code, date and files. Less resource intensive and time consuming than process creation.

Heavyweight process

Process with only one thread of control.

Threads

Process-tasks running concurrently, each with their own registers and stacks, sharing code, date and files. Less resource intensive and time consuming than process creation.

Single-threaded process

serves one client at a time, making another client wait, contains one thread and stack

Multi-threaded process

contains many registers and stacks, several threads of control

Multicore system

System with multiple cores per CPU or across CPUs.

Parallelism

The system can perform more than one task simultaneously.

Concurrency

A system that can let more than one task make progress (doesn't have to be parallel), by e.g. rapidly switching.

Data splitting

Data accessed and manipulated by multiple threads must be divided to run on separate cores.

Data dependency

Execution sometimes needs to be synchronised to make sure two or more tasks use the right data if they depend on each other.

Data parallelism

Distributing subsets of same data across multiple cores, and performing the same operation on each core.

Task parallelism

Distributing threads across multiple cores, each performing a unique operation.

User threads

Threads provided at user level, above kernel level (managed without kernel support).

Kernel threads

Threads supported and managed by the OS.

Many-to-one model

Mapping of user-level threads to one kernel thread. Only one thread can access the kernel at a time (no parallel execution).

One-to-one model

Mapping of each user thread to a kernel thread. Allows for other threads to run when one makes a blocking call, and parallel execution. Creation of a kernel thread per user-level process can cause overhead (limit possible).

provides more concurrency than the many to one model by allowing another thread to run when a thread makes a blocking system call; also allows multiple threads to run in parallel on multiprocessors

Many-to-many model

Multiplexing user-level threads to a smaller or equal amount of kernel threads. Corresponding kernel thread can run in parallel on processor, and there is no limit on the amount of kernel threads.

Two-level model

Variation of the many-to-many model that also allows the binding of a user-level thread to a single kernel thread (one-to-one model).

Thread library

Provides an API for creating and managing threads.

Asynchronous threading

Once the parent creates a child thread, it resumes operation. Children run independently, because the parent need not know when its child terminates.

Synchronous threading

Parent must wait until all of its created children threads terminate before it resumes (fork-join strategy). Threads execute concurrently.

Implicit threading

Transferring the creation and management of threading from app developers to compilers and run-time libraries.

Thread pool

Create a number of threads during process startup in a pool, where they wait for work, limiting the number of threads that can be created.

Signal

UNIX - Process notification that a certain event has occurred. Can be received (a)synchronously.

Synchronous signal

UNIX - Signal that notifies the process itself (division by zero, illegal memory access, ...)

Asynchronous signal

UNIX - Signal that notifies an external process.

Default signal handler

Handler for every signal, run by the kernel when the signal is handled.

User-defined signal handler

Overridden default action in the default signal handler for a a specific kernel action.

Asynchronous procedure calls (APC)

Windows - Emulation of the non-supported signalling system. Allows the specification on user functions that are to be called when the user thread receives a notification (roughly equivalent to UNIX asynchronous signals).

Thread cancellation

Terminating a thread before it had finished.

Target thread

Thread that is to be cancelled.

Asynchronous thread cancellation

One thread immediately terminates the target thread. Target thread updating data of other threads can cause a problem.

Deferred cancellation

Target thread periodically checks wether it should terminate, allowing it to terminate itself in an orderly fashion.

Cancellation point

Thread terminates when reaching this point. Only way a thread can end in deferred cancellation mode.

Cleanup helper

Function that is invoked when a cancellation request is pending, deallocates all resources from the thread before it is terminated.

Thread-local storage (TLS)

Thread-specific copy of certain data. Visible across all function invocations (≠ local variables).

Lightweight process (LWP)

Intermediate data structure in the many-to-many and two-level models between the user-level and kernel threads (± virtual processor). I/O intensive applications may require multiple LWP for each blocking system call.

Scheduler activation

The scheduling of LWP by the kernel (user library schedules user-level threads).

Upcall

Kernel informing applications about certain events.

Upcall handler

Handler in the thread library handling upcalls. Running on virtual processors.