1/38
Looks like no tags are added yet.
Name | Mastery | Learn | Test | Matching | Spaced |
---|
No study sessions yet.
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.