A programmer runs their multithreaded program 1000 times and never observes a bug. What can they conclude?

Assume there is no space left on the heap at the beginning (bytesLeft = 0). Three threads are run in the following order: T1: allocate(50) and then T2: allocate(30) and then T3: free(50). What is the final outcome?

What is the primary advantage of a thread context switch over a process context switch?

For questions 29–30, consider the following producer/consumer implementation using a shared bounded buffer of size 1. There are two producer threads and two consumer threads. Assume the mutex and condition variable are correctly initialized. The variable count tracks the number of items in the buffer (initially 0). int count = 0; mutex_t m; cond_t cv; void *producer(void *arg) { while (1) { mutex_lock(&m); // P1 if (count == 1) // P2 cond_wait(&cv, &m); // P3 count = 1; // P4 fill_buffer(); // P5 cond_signal(&cv); // P6 mutex_unlock(&m); // P7 } } void *consumer(void *arg) { while (1) { mutex_lock(&m); // C1 if (count == 0) // C2 cond_wait(&cv, &m); // C3 count = 0; // C4 use_buffer(); // C5 cond_signal(&cv); // C6 mutex_unlock(&m); // C7 } }

The wait(cv, lock) operation atomically releases the lock and puts the calling thread to sleep. When the thread is later woken up, it re-acquires the lock before wait() returns.

What is the key advantage of implementing thread_join() using a condition variable plus a done flag, compared to simply spinning on the done flag?

With a lock-free data structure, killing one thread will not cause a deadlock. With locks, killing a thread can prevent further progress.

For questions 23–24, consider the following code snippet: int bytesLeft = MAX_HEAP_SIZE; cond_t c; mutex_t m; void* allocate(int size) { mutex_lock(&m); while (bytesLeft < size) cond_wait(&c, &m); void *ptr = ...; // get mem from heap bytesLeft -= size; mutex_unlock(&m); return ptr; } void free(void *ptr, int size) { mutex_lock(&m); bytesLeft += size; cond_signal(&c); mutex_unlock(&m); }

Replacing signal() with broadcast() (an operation that wakes all waiting threads rather than the first one) in a correct condition variable program can never introduce a correctness bug; it can only affect performance.

In 1 – 2 sentences, explain Socrates’s approach to philosophy.