FINALS

Question 1

What are the two main parts of a process and what do they encapsulate?

Answer 1

Threads encapsulate concurrency (the active part), while address spaces encapsulate protection (the passive part).

Question 2

What is the difference between a heavyweight process and a lightweight process?

Answer 2

A heavyweight process is a process with its own resources, a lightweight process is a thread with shared resources within the same process.

Question 3

What is a context switch and how does it relate to process multiplexing?

Answer 3

A context switch involves saving the state of the currently running process and loading the state of a new process. This is essential for process multiplexing, which allows multiple processes to share CPU time.

Question 4

Explain the concept of an execution stack and its significance in thread execution.

Answer 4

The execution stack is a data structure that stores temporary results, parameters, and return addresses during function calls. It enables recursive execution and is crucial for modern programming languages.

Question 5

Describe the purpose and functionality of the ThreadFork() operation in multithreaded programming.

Answer 5

ThreadFork() creates a new thread to execute a specific function with given arguments, enabling concurrent task execution.

Question 6

How does the operating system use a timer interrupt for fair scheduling among threads?

Answer 6

The timer interrupt periodically forces a context switch, allowing the OS to schedule other threads and prevent monopolization of the CPU.

Question 7

What are the advantages and disadvantages of using threads compared to processes?

Answer 7

Threads are lightweight and require less overhead than processes. However, threads share the same address space, which can cause synchronization issues.

Question 8

Differentiate between internal and external events that can cause a thread to yield control.

Answer 8

Internal events occur within the thread, such as I/O blocking. External events, like timer interrupts, originate outside the thread.

Question 9

How does Simultaneous Multithreading (SMT)/Hyperthreading enhance CPU performance?

Answer 9

SMT/Hyperthreading creates virtual cores by duplicating the register state, allowing multiple threads to execute concurrently on one core, improving efficiency.

Question 10

What is a working set, and how does it impact context switching overhead?

Answer 10

The working set is the actively used memory of a process. Larger working sets increase context switching overhead as more data must be saved and restored.

Question 11

Describe the five states in the lifecycle of a process.

Answer 11

New: The process is being created.
Ready: Waiting to run.
Running: Executing instructions.
Waiting: Paused for an event.
Terminated: Finished execution.

Question 12

main() {
ThreadFork(ComputePI, “pi.txt” ));
ThreadFork(PrintClassList, “classlist.txt”));
}
What is the purpose of the ThreadFork() function in the code snippet?

Answer 12

ThreadFork() starts a new thread to execute a specific function with provided arguments. For example, ThreadFork(ComputePI, “pi.txt”) creates a thread to execute ComputePI with “pi.txt”.

Question 13

Explain the concept of an execution stack and its importance in programming.

Answer 13

The execution stack stores temporary data like function parameters, local variables, and return addresses. It enables recursive calls and scoped variables, essential for structured programming.

Question 14

What are the steps involved in saving and restoring the CPU state during a context switch?

Answer 14

1. Save the current thread’s state (PC, registers, stack pointer) to its TCB.
   
   2. Load the new thread’s state from its TCB into the CPU.
      This ensures threads resume correctly from where they left off.

Question 15

Why is saving and restoring the CPU state crucial during a context switch?

Answer 15

It maintains thread isolation and program correctness. Without it, data corruption and unpredictable behavior could occur.

Question 16

What is the concept of a yield() operation in thread execution?

Answer 16

Yield() allows a thread to voluntarily relinquish the CPU, giving other threads a chance to execute, promoting fairness and responsiveness.

Question 17

Glossary

Process

Answer 17

Independent execution unit with its own memory and resources.

Question 18

Glossary

Thread

Answer 18

Lightweight execution unit within a process sharing resources.

Question 19

Concurrency

Answer 19

Simultaneous execution of tasks for efficiency.

Question 20

Thread Control Block (TCB)

Answer 20

Stores thread state and scheduling info.

Question 21

Context Switch

Answer 21

Saves/restores thread states for CPU sharing.

Question 22

Yield()

Answer 22

Voluntary relinquishment of CPU by a thread.

Question 23

Interrupt

Answer 23

Signal interrupting normal execution for a specific task.

Question 24

Timer Interrupt

Answer 24

Periodic interrupt for OS scheduling.

Question 25

Multithreading

Answer 25

Using threads within a process for concurrency.

Question 26

Hyperthreading

Answer 26

Hardware creating virtual cores for concurrent thread execution.

Question 27

Synchronization

Answer 27

Mechanisms for safe shared resource access.

Question 28

Mutex

Answer 28

Lock allowing one thread access to a resource.

Question 29

Semaphore

Answer 29

Signal controlling access to limited resources.

Question 30

Race Condition

Answer 30

Unpredictable behavior from thread timing issues.

Question 31

Deadlock

Answer 31

Threads blocked indefinitely, waiting for each other’s resources.

Question 32

Explain the concept of hyper-threading and its potential performance implications.

Answer 32

Hyper-threading allows a single physical core to execute multiple threads concurrently by duplicating certain CPU components. While it increases throughput, contention for shared resources like ALUs can limit performance gains.

Question 33

Differentiate between multiprocessing and multiprogramming.

Answer 33

Multiprocessing uses multiple CPUs for parallel task execution, while multiprogramming allows multiple jobs to share a single CPU through time-sharing.

Question 34

What are the characteristics of independent threads?

Answer 34

Independent threads have no shared state with others, making them deterministic and reproducible. Their execution order does not affect the results.

Question 35

Why might cooperating threads be preferred in certain situations?

Answer 35

Cooperating threads share resources and can achieve speedup through overlapping I/O and computation, e.g., multiple ATMs accessing a single bank account.

Question 36

How does a threaded web server handle multiple client requests?

Answer 36

A threaded web server creates a new thread for each incoming client request, allowing concurrent processing and better utilization of system resources.

Question 37

What is the purpose of a thread pool in a web server?

Answer 37

A thread pool manages a fixed number of worker threads, preventing resource exhaustion during traffic spikes. Incoming requests are queued and processed by available threads.

Question 38

What potential problems can arise from shared state among concurrent threads?

Answer 38

Shared state can lead to race conditions, inconsistencies, and unpredictable behavior due to the non-deterministic nature of thread interleaving.

Question 39

Why are atomic operations crucial in concurrent programming?

Answer 39

Atomic operations complete without interruption, ensuring data consistency and predictable behavior when multiple threads access shared resources.

Question 40

What challenges exist in debugging programs with cooperating threads?

Answer 40

Non-deterministic execution can lead to “Heisenbugs” that are difficult to reproduce. Extensive testing with different interleaving scenarios is required.

Question 41

Multiprocessing

Answer 41

Parallel task execution using multiple CPUs.

Question 42

Multiprogramming

Answer 42

Time-shared execution of multiple jobs on one CPU.

Question 43

Atomic Operation

Answer 43

an indivisible operation that either completes entirely or does not occur at all. It ensures data consistency in concurrent programming by preventing interruptions during execution.

Question 44

Thread Pool

Answer 44

Pre-created threads for handling incoming tasks efficiently.

Question 45

Denial of Service (DoS)

Answer 45

Overloading a server with requests to disrupt service.

Question 46

Interleaving

Answer 46

Non-deterministic thread instruction execution order.

Question 47

Heisenbug

Answer 47

Bug that alters/disappears during debugging attempts.

Question 48

Why is it challenging to achieve synchronization using only atomic load and store operations?

Answer 48

Atomic load and store operations guarantee atomicity only for individual memory accesses. However, synchronization often involves multi-step operations, like checking and updating a flag, which can be interrupted, leading to race conditions.

Question 49

Describe the “Too Much Milk” problem and its significance in understanding synchronization issues.

Answer 49

The “Too Much Milk” problem illustrates the difficulties of coordination between threads accessing a shared resource. It emphasizes the need for synchronization mechanisms to prevent redundant actions while ensuring the task is performed when needed.

Question 50

Why is Solution #1 to the “Too Much Milk” problem, which involves leaving a note, insufficient?

Answer 50

Solution #1 fails because it does not ensure atomicity. A thread may be interrupted after checking for the note but before performing the action, allowing other threads to take the same action unnecessarily.

Question 51

What are the key issues with using interrupt enable/disable as a locking mechanism?

Answer 51

Disabling interrupts can delay critical event handling and is unsuitable for multiprocessor systems, where globally disabling interrupts is complex and inefficient.

Question 52

Explain the purpose of a “guard” variable in the improved lock implementation using test&set.

Answer 52

A “guard” variable ensures only one thread attempts to acquire the lock at a time. It helps reduce contention and prevents threads from continuously busy-waiting.

Question 53

What are the advantages and disadvantages of using test&set for implementing locks?

Answer 53

Advantages: Works on multiprocessors, allows user-level locks, and avoids prolonged interrupt disabling.
Disadvantages: Leads to busy-waiting, wasting CPU cycles, and can cause priority inversion.

Question 54

Describe the concept of “busy-waiting” and why it is generally undesirable.

Answer 54

Busy-waiting occurs when a thread continuously checks the status of a lock without performing useful work. It wastes CPU resources and can block other threads from progressing.

Question 55

How does a semaphore differ from a simple integer variable in the context of concurrency?

Answer 55

Semaphores are accessed exclusively through atomic P() and V() operations, ensuring controlled modification and preventing race conditions. Simple integers lack this atomicity and control.

Question 56

Provide an example of how semaphores can be used to enforce scheduling constraints between threads.

Answer 56

A semaphore initialized to 0 can be used for a “joiner” thread to wait using P() until a “worker” thread signals completion using V(). This ensures the joiner proceeds only after the worker finishes.

Question 57

Discuss the difficulties in designing and debugging concurrent programs, focusing on the challenges of non-determinism and race conditions.

Answer 57

Non-determinism in concurrent programs arises because thread execution order varies, leading to unpredictable outcomes. Race conditions occur when threads access shared resources without proper synchronization, causing data corruption. Debugging is difficult due to the intermittent and non-reproducible nature of these issues.

Question 58

Compare and contrast the use of disabling interrupts and using test&set for implementing locks. Highlight the trade-offs and suitability of each approach in different scenarios.

Answer 58

Disabling interrupts ensures mutual exclusion but is inefficient in multiprocessor systems and delays critical events. Test&set is more scalable, allowing user-level locks, but causes busy-waiting and potential priority inversion. Use disabling interrupts in simple, single-core systems and test&set for multiprocessor environments.

Question 59

Explain the concept of priority inversion. Describe how it can occur with locks and discuss potential solutions or mitigation strategies.

Answer 59

Priority inversion occurs when a high-priority thread is blocked waiting for a resource held by a lower-priority thread, while a medium-priority thread preempts the lower-priority thread. Solutions include priority inheritance, where the lower-priority thread temporarily inherits the higher priority to complete its task.

Question 60

Describe in detail how semaphores can be used to solve the “producer-consumer” problem, where one thread produces data and another thread consumes it. Explain how semaphores ensure both synchronization and buffer management.

Answer 60

Semaphores enforce synchronization using a full semaphore to track available items and an empty semaphore for available space. The producer signals full after producing, and the consumer signals empty after consuming. This prevents overfilling and ensures correct order.

Question 61

Analyze the different correctness properties that must be considered when designing concurrent programs. Provide specific examples of these properties and discuss their implications for program behavior and reliability.

Answer 61

Correctness properties include safety (no two threads enter a critical section simultaneously), liveness (threads eventually proceed), and fairness (equal access to resources). For example, mutexes ensure safety, but improper implementation can cause deadlocks, impacting liveness. Fair scheduling avoids starvation, maintaining system reliability.