Add Preemption Using SIGALRM to Switch User-Space Threads

Topic Overview

Adding a Timer Preempt

Cooperative threads fail when one thread never yields. Preemption fixes that by forcing switches on asynchronous events. In userspace you can hijack SIGALRM from setitimer to run a scheduler on every tick.

Signal Handler as Scheduler Tick

Setup sequence:

• Install SIGALRM handler that calls schedule()
• Configure setitimer(ITIMER_REAL, ...) for quantum
• Mark signal handler safe regarding async-signal rules

For example, a 10 ms timer firing while thread A runs in an infinite loop preempts A, saves its context, and dispatches thread B without A calling yield().

Why This Matters in Production

This is how early user-level threading libraries like GNU Pth added preemption on top of cooperative scheduling, and the async-signal-safety constraint you'll hit is a real, frequently-violated rule: calling malloc() or printf() inside a signal handler is a documented source of deadlocks and heap corruption in production C code, which is exactly why POSIX maintains an explicit async-signal-safe function list.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will wire alarm-driven preemption into your green-thread runtime. The task asks you to compare cooperative-only and preemptive modes on a CPU-bound loop so the starvation difference is visible.

Your Task

Add preemption to user-space threads. An interval timer (setitimer) raises SIGALRM every Q ticks of CPU time, and the handler forces a switch, so a thread that never yields still loses the CPU. Code that must not be interrupted blocks SIGALRM with sigprocmask. An alarm that arrives during that time stays pending (standard signals do not queue, so repeats merge), and it is delivered the moment the thread unblocks it. Simulate this tick by tick.

Input

cCopy
Loading…

Rules

• The first thread runs first. The ready queue is FIFO, and the other threads start in definition order.
• Only work takes time. The other steps take zero ticks and run at once.
• The timer fires whenever the global tick count reaches a multiple of Q. If the running thread has SIGALRM unblocked, the thread is preempted. Otherwise the signal becomes pending, or merges if one is already pending.
• unblock with a signal pending delivers it immediately, and the thread is preempted.
• If a thread gives up the CPU for any other reason (yield, finished) while a signal is pending, the switch consumes the signal.
• A preempted or yielding thread goes to the back of the queue. A thread finishes when its steps run out.

Output

cCopy
Loading…

• When a thread gives up the CPU, print t=START-END NAME ran, REASON, or t=END NAME REASON if it ran zero ticks. REASON is preempted, yield or finished.
• A print step outputs t=NOW [NAME] TEXT.
• A step that is not recognised prints t=NOW [NAME] bad step: TEXT and is skipped.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Keep one process-wide "pending" flag and a mask per thread. This is what a green-thread library does with sigprocmask in a single OS thread.
2. Never switch inside a blocked section. The deferred switch happens exactly at unblock.

Hidden tests cover a quantum of 1, a thread preempting itself when it is the only one left, several merges inside one long blocked section, block/unblock with no alarm in between, yield with nobody else ready, and bad steps.