All MCQs

In symmetric multiprocessing, processors are peers that can schedule work from shared or per-CPU queues.
This improves flexibility but requires coordination over shared scheduling data.

Asymmetric multiprocessing assigns a master processor to handle scheduling and selected kernel responsibilities.
Other processors execute tasks directed by the master.

Data parallelism divides a common data set into parts processed by similar operations concurrently.
Task parallelism instead assigns different kinds of work to different threads.

Concurrency can be achieved by interleaving tasks on one processor or by simultaneous execution.
Parallelism specifically requires overlapping execution on multiple processing units.

Processor affinity favors running a thread on a previous CPU to preserve cache locality.
Avoiding unnecessary migration can improve performance on multiprocessor systems.

System-contention scope schedules kernel-visible threads against other runnable threads system-wide.
This is the normal scope for kernel-level thread scheduling.

Process-contention scope selects among user threads belonging to one process.
The thread library typically performs this competition before the kernel schedules underlying entities.

A lightweight process acts as an intermediate kernel scheduling resource for user-level threads.
The user thread library multiplexes its threads over these entities.

Scheduler activations provide a communication mechanism between the kernel and a user-level thread library.
They help the library react when kernel threads block, resume, or become available.

Thread-local storage gives each thread its own instance of a logically common variable.
It is useful for per-thread state that should not be shared or locked.

Asynchronous cancellation permits termination at an arbitrary execution point.
It is dangerous because the thread may hold resources or be updating shared state.

Deferred cancellation lets the target thread stop at controlled points where cleanup is safer.
It reduces the risk of leaving locks held or data structures inconsistent.