Processes & Threads · Intermediate

Question 1 fork() Intermediate Practice Answer computed

How many times is x printed?

C main.c

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

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

Your answer

Question 2 fork() Intermediate Practice Answer computed

How many times is x printed?

C main.c

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

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

Your answer

Question 3 fork() Intermediate Practice Answer computed

How many dashes are printed (output to a terminal)?

C main.c

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

int main(void) {
    for (int i = 0; i < 2; i++) {
        fork();
        printf("-\n");
    }
    return 0;
}

Your answer

Question 4 fork() Intermediate Practice Answer computed

What does this print?

C main.c

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main(void) {
    int x = 10;
    if (fork() == 0) {
        x += 5;
        printf("child %d\n", x);
    } else {
        wait(NULL);
        x -= 5;
        printf("parent %d\n", x);
    }
    return 0;
}

child15parent10 parent5child15 child15parent5 child15parent15

Question 5 exec() and wait() Intermediate Practice Answer computed

What does this print (on a terminal)?

C main.c

#include <stdio.h>
#include <sys/wait.h>
#include <unistd.h>

int main(void) {
    printf("1\n");
    if (fork() == 0) {
        printf("2\n");
        return 0;
    }
    wait(NULL);
    printf("3\n");
    return 0;
}

132 123 213 1123

Question 6 Threads Intermediate Practice Code executed

Threads share memory. What does this print?

Python main.py

import threading

results = []

def work(n):
    results.append(n * n)

threads = [threading.Thread(target=work, args=(i,)) for i in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(sorted(results), threading.active_count())

[0, 1, 4, 9] 1 [] 1 [9] 4 [0, 1, 4, 9] 5

Question 7 fork() Intermediate Practice Code executed

Processes do not share memory. What does the parent print?

Python main.py

import os

data = [1]
pid = os.fork()
if pid == 0:
    data.append(2)
    os._exit(0)
os.waitpid(pid, 0)
print(data)

[] [1, 2] [2] [1]

Question 8 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 9 Threads Intermediate Practice One or more answers

Which of these does each thread have its own copy of? (Select all that apply.)

Global variables Heap Register set and program counter Stack Open file descriptors

Question 10 IPC Intermediate Practice Code executed

A parent sends a message to its child through a pipe. What does this print?

C main.c

#include <stdio.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

int main(void) {
    int fd[2];
    pipe(fd);
    if (fork() == 0) {
        char buf[16] = {0};
        close(fd[1]);
        read(fd[0], buf, sizeof buf - 1);
        printf("child got %s (%zu)\n", buf, strlen(buf));
        return 0;
    }
    close(fd[0]);
    write(fd[1], "hello", 5);
    close(fd[1]);
    wait(NULL);
    return 0;
}

child got hello (16) child got (0) Nothing – the child blocks forever child got hello (5)

Question 11 IPC Intermediate Practice

Why is shared memory usually the fastest IPC mechanism?

The kernel copies data twice as fast After it is set up, processes read and write the same pages directly, with no system call or copy per message – but they must synchronise themselves It is stored in CPU registers It does not use RAM

Question 12 Schedulers Intermediate Practice

Memory is overcommitted and the system is slow. Which scheduler swaps whole processes out to disk to reduce the load?

The long-term scheduler, which only admits new jobs The medium-term scheduler The short-term scheduler The I/O scheduler

Question 13 fork() Intermediate Practice

A process using 2 GB of memory calls fork(). Why is fork() still fast?

Copy-on-write: parent and child share the pages read-only, and a page is copied only when one of them writes to it The kernel compresses the memory first The child gets no memory at all fork() copies the 2 GB in parallel on all cores

Question 14 Threads Intermediate Practice

Why is switching between two threads of the same process usually cheaper than switching between two processes?

Threads do not have registers Thread switches do not need the kernel on any system Processes always have more threads The address space stays the same, so page tables need not be switched and TLB and caches stay useful

Question 15 exec() and wait() Intermediate Practice Code executed

What does this print?

C main.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>

int main(void) {
    pid_t pid = fork();
    if (pid == 0)
        exit(7);
    int status;
    waitpid(pid, &status, 0);
    printf("%d %d\n", WIFEXITED(status) != 0, WEXITSTATUS(status));
    return 0;
}

7 1 0 7 1 0 1 7

Processes & Threads · Intermediate

Before you start