Unit 1: Scheduling, synchronization and memory management

Input the burst times (and arrival times), compute completion time (CT), turnaround time (TAT = CT − AT) and waiting time (WT = TAT − BT), and print averages.

c/* FCFS, all arriving at time 0 */
wt[0] = 0;
for (i = 1; i < n; i++)
    wt[i] = wt[i - 1] + bt[i - 1];
for (i = 0; i < n; i++) {
    tat[i] = wt[i] + bt[i];
    avg_wt += wt[i]; avg_tat += tat[i];
}

• SJF: sort processes by burst time first, then apply the FCFS logic.
• Round Robin: loop over processes, giving each min(quantum, remaining time) until all remaining times are zero.

• Producer-consumer: semaphores empty (initially buffer size), full (0) and mutex (1). Producer: wait(empty), wait(mutex), add item, signal(mutex), signal(full). Consumer does the reverse.
• Dining philosophers: five philosophers and five chopsticks (semaphores); to avoid deadlock, allow at most four to pick up chopsticks, or make one philosopher pick up the right chopstick first.
• Pipes and FIFOs: pipe(fd) creates a one-way channel; after fork(), the parent writes to fd[1] and the child reads from fd[0]. A FIFO (named pipe) is created with mkfifo and works between unrelated processes.

• First fit / best fit: for each process, search the list of free blocks for the first block (or the smallest block) large enough, allocate it and reduce the block size.
• Paging: given a logical address, page number = address / page size and offset = address % page size; look up the frame in the page table.
• MVT: allocate memory exactly equal to each process size until memory runs out, then report external fragmentation.
• FIFO page replacement: keep frames in a circular array; on a miss, replace the frame at the pointer and advance it; count faults.
• Sequential file allocation: a file occupies consecutive disk blocks from a starting block; check that the required blocks are free.