Operating Systems · Full Mock 1 – Mock Test

Question 1 System calls Beginner Practice Code executed

printf() buffers its output; write() is a system call that writes at once. What does this print?

C main.c

#include <stdio.h>
#include <unistd.h>

int main(void) {
    printf("A");
    write(1, "B", 1);
    printf("C\n");
    return 0;
}

ACB ABC BCA BAC

Question 2 System calls Advanced Practice Answer computed

Each system call costs 200 ns of overhead. A program reads a 1,000,000-byte file one byte per read(); a better version reads 4096-byte blocks. Ignoring the final 0-byte read, how many milliseconds of system-call overhead does the better version save (two decimals)?

Your answer

Question 3 fork() Beginner Practice Answer computed

How many times is hi printed?

C main.c

#include <stdio.h>
#include <unistd.h>

int main(void) {
    fork();
    fork();
    printf("hi\n");
    return 0;
}

Your answer

Question 4 fork() Advanced Practice Answer computed

How many times is x printed?

C main.c

#include <stdio.h>
#include <unistd.h>

int main(void) {
    fork();
    if (fork() == 0)
        fork();
    printf("x\n");
    return 0;
}

Your answer

Question 5 FCFS Beginner Practice Answer computed

All three processes arrive at time 0 in the order shown. What is the average waiting time under FCFS?

Processes

Process	Arrival	Burst
P1	0	24
P2	0	3
P3	0	3

Your answer

Question 6 Round Robin Advanced Practice Answer computed

Round Robin with quantum 3. At what time does P2 complete?

Processes

Process	Arrival	Burst
P1	0	10
P2	1	6
P3	3	2
P4	5	4

Your answer

Question 7 Race conditions Beginner Practice Answer computed

x is 0. Two threads each run x = x + 1 with no lock (each is a load and a store). Which final values of x are possible?

0, 1 or 2 1 or 2 Only 2 Only 1

Question 8 Race conditions Advanced Practice Answer computed

x is 0. T1 runs x = x + 1 and T2 runs x = x + 2 (each a load and a store, no lock). Which final values are possible?

Only 1 or 2 0, 1, 2 or 3 1, 2 or 3 Only 3

Question 9 Banker's algorithm Beginner Practice Answer computed

Need = Max − Allocation. What is the Need row of P2?

System stateAvailable: A = 3, B = 3, C = 2

Process	Alloc A	Alloc B	Alloc C	Max A	Max B	Max C
P0	0	1	0	7	5	3
P1	2	0	0	3	2	2
P2	3	0	2	9	0	2
P3	2	1	1	2	2	2
P4	0	0	2	4	3	3

1204 302 600 902

Question 10 Banker's algorithm Advanced Practice Answer computed

In the state after P1's request, P0 requests (0, 2, 0). What does the Banker's algorithm do?

State after P1's requestAvailable: A = 2, B = 3, C = 0

Process	Alloc A	Alloc B	Alloc C	Max A	Max B	Max C
P0	0	1	0	7	5	3
P1	3	0	2	3	2	2
P2	3	0	2	9	0	2
P3	2	1	1	2	2	2
P4	0	0	2	4	3	3

Makes P0 wait because B is not available Denies it for now – the resources are free, but the resulting state (Available 2, 1, 0) would be unsafe Raises an error because P0 has exceeded its claim Grants it – the resources are available

Question 11 Contiguous allocation Beginner Practice Answer computed

The same holes and requests with best fit (the smallest hole that is large enough):

Free partitions (in order), sizes in KBRequests in order: 212 KB, 417 KB, 112 KB, 426 KB

free100 KB

free500 KB

free200 KB

free300 KB

free600 KB

212→600, 417→500, 112→600, 426 waits 212→300, 417→600, 112→200, 426→500 212→300, 417→500, 112→200, 426→600 212→500, 417→600, 112→500, 426 waits

Question 12 TLB Advanced Practice Answer computed

A two-level page table, TLB lookup 10 ns, memory access 100 ns, TLB hit ratio 90%. What is the effective access time in ns?

Your answer

Question 13 LRU Beginner Practice Answer computed

The same string with 3 frames under LRU (evict the least recently used page). How many page faults?

Reference string

7
0
1
2
0
3
0
4
2
3
0
3
2
1
2
0
1
7
0
1

Your answer

Question 14 Performance Advanced Practice Answer computed

Memory access 100 ns. A page fault takes 8 ms if the victim page is clean and 20 ms if it is dirty; 70% of victims are dirty. The fault rate is 1 in 10,000 accesses. What is the effective access time in ns (two decimals)?

Your answer

Question 15 Disk scheduling Beginner Practice Answer computed

The head is at cylinder 53. What is the total head movement (in cylinders) with FCFS?

Disk queue (cylinders 0–199)

Your answer

Question 16 Disk scheduling Advanced Practice Answer computed

Head at 50 moving up. Which algorithm gives the smallest total head movement for this queue?

Disk queue (cylinders 0–199)

SCAN (332) LOOK (314) C-LOOK (341) SSTF (208)

Question 17 Creating threads Beginner Practice Code executed

What does this print?

Java Main.java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        StringBuilder log = new StringBuilder();
        Thread t = new Thread(() -> log.append("worker "));
        t.start();
        t.join();
        log.append("main");
        System.out.println(log);
    }
}

worker main main worker Either order, it varies main

Question 18 Performance Advanced Practice Answer computed

90% of a program can run in parallel. By Amdahl's law, what speedup do 8 cores give? (two decimals)

Your answer

Question 19 Text tools Beginner Practice Answer computed

What does this print?

printf 'a\nb\nc\n' | wc -l

Your answer

Question 20 Permissions Advanced Practice Answer computed

/tmp has mode 1777. What is its permission string, and what does the extra bit do?

-rwxrwxrwt – it is a file drwxrwxrwt – the sticky bit lets everyone create files, but only a file's owner (or root) may delete or rename it drwsrwxrwx – files run as root drwxrwxrwx – everyone may delete anything

Question 21 Dual mode Intermediate Practice

Does every system call cause a context switch?

No – system calls run entirely in user mode Yes – the kernel is a separate process No – it always causes a mode switch (user → kernel → user), but a context switch happens only if the kernel decides to run another process, e.g. because the call blocks Yes – every system call switches to another process

Question 22 Process states Intermediate Practice

Which pairing of an event and a state transition is correct?

Timer interrupt: running → waiting; disk completes: ready → running Timer interrupt: running → ready; read() from disk: running → waiting; disk completes: waiting → ready read() from disk: running → ready; timer interrupt: waiting → ready Disk completes: waiting → running; timer interrupt: ready → running

Question 23 Multilevel queues Intermediate Practice

How does a Multilevel Feedback Queue (MLFQ) treat a new process that turns out to be CPU-bound?

It stays in the top queue forever It starts in the top (short-quantum) queue and is moved down a level each time it uses up its whole quantum, so CPU-bound jobs sink and interactive jobs stay on top It is killed after one quantum It is moved up a level each time it uses its quantum

Question 24 Classic problems Intermediate Practice

A producer is written as wait(mutex); wait(empty); add item; signal(mutex); signal(full); – the two waits are swapped. What can happen?

The buffer overflows Deadlock: with the buffer full, the producer holds mutex while blocked on empty, so the consumer can never take an item Items are lost but no deadlock Nothing – the order of waits never matters

Question 25 Detection Intermediate Practice

A resource-allocation graph with two instances of R1 has a cycle P1 → R1 → P2 → R2 → P1, and the second instance of R1 is held by P3, which is not waiting for anything. Is there a deadlock?

Yes – P3 is also deadlocked No – P3 will finish and release its R1 instance, which P1 can take, breaking the cycle It cannot be decided Yes – any cycle means deadlock

Question 26 Page tables Intermediate Practice

What is an inverted page table?

A table that maps frames back to disk blocks only A page table stored in reverse order One table for the whole system with one entry per physical frame (process ID + page number); its size depends on RAM, not on the number of processes A page table per thread

Question 27 LRU Intermediate Practice

Why do real kernels approximate LRU instead of implementing it exactly?

LRU only works with 3 frames LRU needs the future reference string Exact LRU causes Belady's anomaly Exact LRU needs work on every memory access (updating a timestamp or a stack), which is far too slow without special hardware; reference bits plus the clock algorithm are cheap

Question 28 Allocation Intermediate Practice

How does the File Allocation Table (FAT) improve on plain linked allocation?

It uses inodes It stores each file contiguously It removes the need for directories The next-block pointers are kept together in one table at the start of the volume, which can be cached in memory, so following a chain needs no data-block reads

Question 29 Thread safety Intermediate Practice

Code using a ConcurrentHashMap does if (!map.containsKey(k)) map.put(k, load(k)); and sometimes loads the same key twice. Why, and what is the fix?

containsKey() is slow ConcurrentHashMap is not thread-safe put() ignores duplicates Each call is thread-safe, but check-then-act is two operations – another thread can insert in between; use map.computeIfAbsent(k, this::load)

Question 30 Pipes and redirection Intermediate Practice

Why does find . -name "*.tmp" | xargs rm work, while find . -name "*.tmp" | rm does not?

rm takes file names as arguments, not from stdin; xargs reads stdin and turns it into arguments (use find -print0 | xargs -0 for names with spaces) Pipes do not work with find rm cannot delete .tmp files xargs makes rm run as root

Operating Systems · Full Mock 1

Sections

Before you start