Operating Systems — Complete Answer Guide

// ── Shared Variables ────────────────────────────────── boolean flag[2] = {false, false} // flag[i]: does thread i want CS? int turn = 0 // whose turn if both want in? // ── Thread 0 ────────────────────────────────────────── Thread_0(): while (true): flag[0] = true // "I want to enter" turn = 1 // "But you go first if you want" while (flag[1] == true AND turn == 1): wait // busy-wait // ─── CRITICAL SECTION ─── flag[0] = false // "Done, you can go" // ─── REMAINDER SECTION ── // ── Thread 1 ────────────────────────────────────────── Thread_1(): while (true): flag[1] = true turn = 0 while (flag[0] == true AND turn == 0): wait // ─── CRITICAL SECTION ─── flag[1] = false // ─── REMAINDER SECTION ──

#include <pthread.h> #include <stdio.h> #include <unistd.h> #define NUM_ZONES 4 float temps[NUM_ZONES] = {0}; // SHARED array pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; // ── Sensor Thread: updates one zone's reading ─────────── void* sensor_thread(void* arg) { int zone = *(int*)arg; while (1) { float reading = read_sensor(zone); // hardware read pthread_mutex_lock(&lock); // ACQUIRE LOCK temps[zone] = reading; // update shared array pthread_mutex_unlock(&lock); // RELEASE LOCK sleep(1); // wait before next read } } // ── Controller Thread: computes average across all zones ─ void* controller_thread(void* arg) { while (1) { float sum = 0; pthread_mutex_lock(&lock); // ACQUIRE LOCK for (int i = 0; i < NUM_ZONES; i++) sum += temps[i]; pthread_mutex_unlock(&lock); // RELEASE LOCK printf("Avg Temp: %.2f°C\n", sum / NUM_ZONES); sleep(5); } } int main() { pthread_t sensors[NUM_ZONES], ctrl; int ids[NUM_ZONES]; for (int i = 0; i < NUM_ZONES; i++) { ids[i] = i; pthread_create(&sensors[i], NULL, sensor_thread, &ids[i]); } pthread_create(&ctrl, NULL, controller_thread, NULL); pthread_join(ctrl, NULL); }

// SHARED VARIABLE + MUTEX account_balance = 10000 mutex lock = UNLOCKED // ── Process A: Deposit ────────────────────────────────── Process_A(deposit_amt): lock(account_lock) // ENTER critical section temp = account_balance temp = temp + deposit_amt // temp = 10000 + 2000 = 12000 account_balance = temp unlock(account_lock) // EXIT critical section // ── Process B: Withdrawal ────────────────────────────── Process_B(withdraw_amt): lock(account_lock) // ENTER critical section if account_balance >= withdraw_amt: temp = account_balance temp = temp - withdraw_amt // temp = 12000 - 1500 = 10500 account_balance = temp unlock(account_lock) // EXIT critical section

// ── Document Generator (DG) — Producer ────────────────── Process_DG(): while (true): doc1 = generate_document() doc2 = generate_document() // always produce 2 wait(empty); wait(empty) // need 2 empty slots wait(mutex) // enter critical section add doc1 to buffer; in = (in+1) % N add doc2 to buffer; in = (in+1) % N count += 2 signal(mutex) // exit critical section signal(full); signal(full) // 2 new docs added if (count >= 4): // notify SP if enough docs signal(batch_ready) // ── Smart Printer (SP) — Consumer ─────────────────────── Process_SP(): while (true): wait(batch_ready) // block until ≥4 docs ready wait(full); wait(full) wait(full); wait(full) // consume 4 docs wait(mutex) // enter critical section for i = 1 to 4: doc = buffer[out] out = (out+1) % N count -= 1 print(doc) signal(mutex) // exit critical section signal(empty); signal(empty) signal(empty); signal(empty) // 4 slots freed

// ── Shared Variables ────────────────────────────────────── semaphore write_lock = 1 // exclusive access for writers semaphore count_mutex = 1 // protects reader_count int reader_count = 0 // active readers // ── Reader Process ──────────────────────────────────────── Reader(): wait(count_mutex) reader_count++ if reader_count == 1: // first reader blocks writers wait(write_lock) signal(count_mutex) // ─── READ DATABASE ─── wait(count_mutex) reader_count-- if reader_count == 0: // last reader unblocks writers signal(write_lock) signal(count_mutex) // ── Writer Process ──────────────────────────────────────── Writer(): wait(write_lock) // exclusive lock // ─── WRITE/UPDATE DATABASE ─── signal(write_lock)

#include <stdio.h> #include <pthread.h> #include <unistd.h> int arr[] = {1,2,3,4,5,6,7,8,9,10}; int n = 10; // Thread 1: sum of odd numbers void* sum_odd(void* arg) { int sum = 0; for (int i=0; i<n; i++) if (arr[i] % 2 != 0) sum += arr[i]; printf("Child T1 - Sum of odd: %d\n", sum); return NULL; } // Thread 2: average of all numbers void* calc_avg(void* arg) { double sum = 0; for (int i=0; i<n; i++) sum += arr[i]; printf("Child T2 - Average: %.2f\n", sum/n); return NULL; } int main() { pid_t pid = fork(); if (pid == 0) { // CHILD PROCESS pthread_t t1, t2; pthread_create(&t1, NULL, sum_odd, NULL); pthread_create(&t2, NULL, calc_avg, NULL); pthread_join(t1, NULL); pthread_join(t2, NULL); printf("Child done.\n"); } else { // PARENT PROCESS int sum_even = 0; for (int i=0; i<n; i++) if (arr[i] % 2 == 0) sum_even += arr[i]; printf("Parent - Sum of even: %d\n", sum_even); wait(NULL); // wait for child printf("Parent done.\n"); } return 0; }

// READ-WRITE LOCK: allows concurrent reads, exclusive writes // Better than mutex — ControlThread can still read while // SensorThread is NOT writing (only blocks during writes) pthread_rwlock_t coord_lock = PTHREAD_RWLOCK_INITIALIZER; int x = 0, y = 0; SensorThread(): while (true): int nx = getGPS_X() int ny = getGPS_Y() pthread_rwlock_wrlock(&coord_lock) // WRITE LOCK — exclusive x = nx // atomic pair update y = ny pthread_rwlock_unlock(&coord_lock) ControlThread(): while (true): pthread_rwlock_rdlock(&coord_lock) // READ LOCK — shared OK int cx = x, cy = y // consistent snapshot pthread_rwlock_unlock(&coord_lock) if (cx > 100 && cy > 100): adjustCourse()

// ── Shared Primitives ───────────────────────────────────── semaphore turnstile = 1 // FIFO order enforcement — key to fairness semaphore write_lock = 1 // exclusive write access semaphore count_mutex = 1 // protects reader_count int reader_count = 0 // ── Reader ──────────────────────────────────────────────── Reader(): wait(turnstile) // FIFO queue — readers wait behind pending writers signal(turnstile) // pass through, let next reader/writer proceed wait(count_mutex) reader_count++ if reader_count == 1: wait(write_lock) // first reader blocks writers signal(count_mutex) // ─── READ eventLog ─── wait(count_mutex) reader_count-- if reader_count == 0: signal(write_lock) // last reader releases writers signal(count_mutex) // ── Writer ──────────────────────────────────────────────── Writer(): wait(turnstile) // FIFO — writer blocks NEW readers from entering wait(write_lock) // wait for existing readers to finish signal(turnstile) // release turnstile AFTER acquiring write_lock // ─── WRITE to eventLog ─── signal(write_lock)

#include <stdio.h> #include <unistd.h> #include <sys/wait.h> int main() { pid_t c1, c2, c3; c1 = fork(); if (c1 == 0) { // First Child c2 = fork(); if (c2 == 0) { // Second Child c3 = fork(); if (c3 == 0) { // Third Child (terminates FIRST) sleep(1); printf("C3 (3rd child) terminates\n"); _exit(0); } wait(NULL); // C2 waits for C3 sleep(2); // then C2 terminates printf("C2 (2nd child) terminates\n"); _exit(0); } wait(NULL); // C1 waits for C2 sleep(1); // then C1 terminates printf("C1 (1st child) terminates\n"); _exit(0); } wait(NULL); // Parent waits for C1 printf("Parent terminates last\n"); // Parent terminates LAST return 0; } // Output order: C3 → C2 → C1 → Parent

// ── Shared Semaphores ──────────────────────────────────── semaphore s3_done = 0 // signals when S3 completes (P3→P1) semaphore s1_done = 0 // signals when S1 completes (P1→P2) // ── Process P1 (executes S1 ONLY after S3 done) ────────── P1(): wait(s3_done) // block until S3 complete execute S1 signal(s1_done) // notify P2 that S1 is done // ── Process P2 (executes S2 ONLY after S1 done) ────────── P2(): wait(s1_done) // block until S1 complete execute S2 // ── Process P3 (executes S3, no constraint) ─────────────── P3(): execute S3 signal(s3_done) // notify P1 that S3 is done // ── Execution Order Guaranteed: S3 → S1 → S2 ───────────── // If P1 runs first: wait(s3_done) blocks → P3 runs S3 → signals → P1 runs S1 → P2 unblocks // If P2 runs first: wait(s1_done) blocks → similar chain // Any execution order of the processes yields S3 → S1 → S2

#include <stdio.h> #include <pthread.h> typedef struct { long long int num; int max_digit; } ThreadData; // Thread function: finds max digit of a number void* find_max_digit(void* arg) { ThreadData* d = (ThreadData*)arg; long long int n = d->num; int max = 0; while (n > 0) { int digit = n % 10; if (digit > max) max = digit; n /= 10; } d->max_digit = max; return NULL; } int main() { pthread_t t1, t2; ThreadData d1 = {55687, 0}; ThreadData d2 = {87934, 0}; pthread_create(&t1, NULL, find_max_digit, &d1); pthread_create(&t2, NULL, find_max_digit, &d2); pthread_join(t1, NULL); // wait for t1 pthread_join(t2, NULL); // wait for t2 printf("Max digit of %lld = %d\n", d1.num, d1.max_digit); printf("Max digit of %lld = %d\n", d2.num, d2.max_digit); printf("Sum of max digits = %d\n", d1.max_digit + d2.max_digit); return 0; } // Output: Max digit of 55687 = 8, Max digit of 87934 = 9, Sum = 17

// Shared variables semaphore write_done = 0 // signals after 2 writers complete semaphore read_done = 0 // signals after 5 readers complete semaphore mutex = 1 // protects counters int writer_count = 0 int reader_count = 0 // Writer Process Writer(id): if id == 3: // 3rd writer must wait for 5 readers for i in range(5): wait(read_done) // wait for 5 read_done signals // ─── WRITE ─── wait(mutex) writer_count++ signal(mutex) if writer_count == 2: // 2nd writer signals readers signal(write_done) // unblock ONE reader // Reader Process Reader(id): wait(write_done) // wait until 2 writers done signal(write_done) // pass to next reader (chain signal) // ─── READ ─── wait(mutex) reader_count++ if reader_count <= 5: signal(read_done) // signal for 3rd writer signal(mutex)