Parallel Programming Concepts Quiz

A method of executing multiple tasks or instructions simultaneously on a single processor core by rapidly switching between them, giving the illusion of parallel execution.

A method of executing multiple tasks or instructions simultaneously on multiple processor cores, allowing true parallelism with each core working independently.

A type of parallelism where the same operation is performed on different parts of a dataset, distributed across multiple cores.

A type of parallelism where different tasks or operations are distributed across multiple cores, with each core performing a unique task.

A mathematical model that estimates the performance gains of adding more processing cores to an application with both serial and parallel parts. It states that the speedup achieved is limited by the portion of the application that cannot be parallelized.

A parallel programming pattern where tasks are recursively split into smaller subtasks until they can be executed independently, and then the results are joined back together.

A Java class that provides a framework for implementing fork-join parallelism. It defines basic methods for creating and managing tasks.

A subclass of ForkJoinTask that returns a result. The result is obtained by invoking the compute() method.

A subclass of ForkJoinTask that does not return a result. It performs an action but does not have a return value.

A set of compiler directives and API for C, C++, and FORTRAN that enables parallel programming in shared-memory environments. It allows the specification of parallel regions where blocks of code can be executed concurrently.

A technology from Apple for macOS and iOS that enables parallel programming. It provides a framework for identifying and executing parallel tasks in a multi-threaded environment.

In GCD, blocks of code that are executed concurrently. They are placed in dispatch queues and assigned to threads for execution.

In GCD, data structures that hold blocks of code waiting to be executed. Blocks are removed from the queue and assigned to threads.

A type of dispatch queue where blocks are executed in the order they were added (FIFO). Each process has a main queue, and additional serial queues can be created within a program.

A type of dispatch queue where multiple blocks can be removed and executed concurrently based on the order they were added (FIFO).

A mechanism in UNIX systems for notifying a process about a specific event.

A function that processes a signal received by a process.

This signal handler is the default behavior when a signal is received.

A specific function defined by the user that handles signals according to their need.

A function that provides the developer with the ability to set the interrupt status of a thread, allowing for deferred cancellation.

A method of stopping a thread before it finishes its execution.

A point in the execution of a thread where it checks if it should be cancelled using 'pthread_testcancel()'.

An approach that immediately terminates the target thread.

An approach that allows a thread to periodically check if it should be cancelled.

A type of cancellation that only occurs when a thread reaches a cancellation point and invokes a cleanup handler.

Threads managed by a user-level library, providing a simpler way to manage concurrency within a process.

Threads managed directly by the operating system kernel, providing a more efficient way to manage concurrency.

A model where many user threads are mapped to a single kernel thread.

A model where each user thread is mapped to its own dedicated kernel thread.

A model allowing multiple user threads to be mapped to multiple kernel threads, providing flexibility and efficiency.

A library that provides programmers with an API for creating and managing threads.

A POSIX standard API for thread creation and synchronization.

A method of managing threads where the compiler and runtime libraries handle thread creation and management, reducing programmer burden.

A technique used to improve performance by creating a pool of threads that are ready to handle tasks.

A library providing a simple and efficient way to create and manage threads using thread pools.

Creating threads by extending the Thread class or implementing the Runnable interface in Java.

The standard practice for creating threads in Java, which allows multiple threads to share the same runnable task.

A method for waiting for a thread to finish execution before proceeding with other tasks.

A mechanism that allows each thread to have its own private copy of data. It is particularly useful when you don't have control over thread creation, like when using a thread pool.

Data stored within TLS is accessible across multiple function calls within the same thread, unlike local variables that are only visible during a single function invocation.

TLS is similar to static data in that it's unique to each thread, but unlike static data, each thread gets its own copy.

In two-level thread models (M:M) and many-to-many (M:M), a communication mechanism is needed to ensure the right number of kernel threads are allocated for each application. This often involves using lightweight processes (LWPs).

LWPs are intermediate data structures that bridge the gap between user and kernel threads. Each LWP appears as a virtual processor for user threads, and each LWP is attached to a kernel thread. The number of LWPs to create depends on the application's needs.

A communication mechanism from the kernel to a thread library, enabling applications to manage the correct number of kernel threads. It allows the kernel to initiate actions in user-space (application) code.

Windows API provides a one-to-one mapping between user-level threads and kernel-level threads. Each thread has its own unique identifier, register set, and separate stacks for user and kernel modes.

A data structure containing the thread ID, user-mode stack, thread-local storage, and resides in user space.

Linux calls them 'tasks' and uses the clone() system call for creating new threads. This call allows a child task to share the same address space as its parent task, enabling efficient resource sharing.

A structure that points to process-related data structures (either shared or unique) within the Linux kernel.

The system call used for creating new threads in Linux. It allows for a child task to inherit the address space of its parent process, enabling shared resources and efficient memory management.