Scheduling, Cores and Events · Lesson 27 of 30 · about 15 minutes

Interrupts and Handlers

Handle an event and restore the interrupted foreground value.

01 / Explain

Understand the idea

An interrupt is an event that temporarily diverts a running task to a handler. The handler must save the state the interrupted code still needs, perform its work, then resume the interrupted execution. The systems lab logs event delivery and resumption explicitly.

The 25-opcode CPU has no hidden interrupt instruction. This challenge models a handler with CALL and data-stack save/restore. The foreground value belongs in R0 again after the handler; event bytes live at addresses 240 and 241.

02 / Try

Watch it happen

Expect the restored foreground value 17, then handled event result 5. The stack is empty after return.

STORE 4 240
LOAD 17
CALL handler
PRINT
LOAD [241]
PRINT
HALT
handler: PUSH
LOAD [240]
ADD 1
STORE 241
POP
RETURN

Use Step to follow one instruction at a time. You can change the example and replay it.

03 / Challenge

Make it work

Read a foreground integer, then an event byte. Store the event at address 240. Call a handler that writes event + 1 to byte memory 241 while preserving foreground R0 with PUSH/POP. Print the restored foreground value, then the stored event result.

The checker runs your current editor program in a fresh machine for each of 3 test cases. It supplies inputs and seeded memory itself; the lab’s current output and memory do not decide your result.

INPUT
COPY R0 R1
INPUT
STORE 240
LOAD R1
CALL handler
PRINT
LOAD [241]
PRINT
HALT
handler:
  # Save R0, process the event, restore R0.
RETURN

Need a hint?

PUSH before loading the event and POP after storing the handler result.

Reveal a worked solution

Read the program, predict each instruction’s effect, then step through it in the lab.

INPUT
COPY R0 R1
INPUT
STORE 240
LOAD R1
CALL handler
PRINT
LOAD [241]
PRINT
HALT
handler: PUSH
LOAD [240]
ADD 1
STORE 241
POP
RETURN

Emoji program

Type LOAD, ADD, or another opcode then Space to insert emoji. Ctrl/⌘ + Enter runs or pauses; Escape pauses; Ctrl/⌘ + ] indents. Tab moves focus. Labels use a colon. Jumps use zero-based instruction addresses.

INPUT
COPY R0 R1
INPUT
STORE 240
LOAD R1
CALL handler
PRINT
LOAD [241]
PRINT
HALT
handler:
  # Save R0, process the event, restore R0.
RETURN

Instruction map and breakpoints (0)

Breakpoints stop before an instruction. Run resumes past the stopped breakpoint once; Step executes it directly. Editing source clears old breakpoints and machine state.

Use Number

CPU registers

R0: 0
R1: 0
R2: 0
R3: 0
R4: 0
R5: 0
R6: 0
R7: 0

Program counter (PC): 0
Stack pointer (SP): 255
Flags: Zero: off · Negative: off · Overflow: off
Delay request: 0 ms

Stacks and loop frames

SP = 255 − data depth − call depth. The stack is separate from memory.

Data stack (bottom → top)

Empty

Call return addresses (bottom → top)

Empty

Loop frames

Empty

Output and input

Run a PRINT instruction to see output.

Queued input: Empty

Memory · 256 bytes · 0 nonzero

Each cell shows address:value. R = read this step; W = written this step. Select a cell to inspect or initialize it before execution. Use arrow keys to move, Home/End for the row, and Ctrl/⌘ + Home/End for the whole memory.

Execution trace · 0 entries

Recent entries below. Inspect any zero-based index to see complete detached before/after state.

Check your challenge

You can run this check any time. Every case must pass to record completion.

Progress uses localStorage only. It stays on this browser and is never sent to a server.