C++ · AArch64 · Raspberry Pi 4

πOS / Browser demo

A real AArch64 kernel running in QEMU compiled to WebAssembly.

Checking browser support…

Machine off.

Select Boot OS to watch the kernel start.

Serial console · type a command and press Enter.

Commands

Type in the terminal, or click a command.

: List the commands.
: Read the kernel's 10 ms clock.
: Inspect task count, ID and priority.
: List files in RAM.
: Read a file. Try cat readme.txt.
: Find matching lines: grep PATTERN FILE. Literal, case-sensitive text.
: Print text, or use > to write and >> to append. Files reset on reboot.
: Play ping-pong between two tasks.
: Play Doom with Freedoom maps and artwork.
: Watch timer preemption share the CPU.
: Run the 19-case on-target suite. May take several minutes.
: Clear the terminal.

A real-time OS targeting ARM.

Running in the browser on QEMU’s ARM virt board, compiled to WebAssembly.

Example programs

Small C++ programs built from tasks and messages. These examples are compiled into an OS image; the terminal above runs the built-in ipc, sched, and test demonstrations.

Syscall reference

Each example is a separate source file. With the name, clock, and console services running, launch its entry point at priority 10.

Ping-pong

Eight request/reply exchanges between two tasks. Send waits until the other task replies. This is the byte-buffer form of the exchange demonstrated by the terminal’s ipc command.

Create(10, ping_pong);

#include "kern/syscall.h"

void pong() {
    for (int round = 0; round < 8; ++round) {
        tid_t sender;
        char ping[4];
        Receive(&sender, ping, sizeof(ping));
        Reply(sender, "pong", 4);
    }
    Exit();
}

void ping_pong() {
    tid_t server = Create(9, pong);
    if (server < 0) { Exit(); return; }

    for (int round = 0; round < 8; ++round) {
        char reply[4];
        Send(server, "ping", 4, reply, sizeof(reply));
        // reply contains four bytes: p o n g.
        // The server has replied before this line runs.
    }
    Exit();
}

A named counter

The server owns the state. A name resolves to its task ID; typed messages supply the buffer sizes. Three requests add 5 each time, then both tasks exit.

Create(10, counter_client);

#include "kern/syscall.h"
#include "user/message_type.hpp"
#include "user/nameserver.hpp"
#include "user/nio.hpp"

struct Add { using reply_type = int; int amount; };

void counter_server() {
    RegisterAs("example.counter");
    int count = 0;
    for (int i = 0; i < 3; ++i) {
        auto request = ReceiveTyped<Add>();
        count += request.msg.amount;
        request.ReplyToSender(count);
    }
    Exit();
}

void counter_client() {
    if (Create(9, counter_server) < 0) { Exit(); return; }
    int counter = WhoIs("example.counter");
    int out = WhoIs(NIO::CONSOLE_PUTS_SERVER);
    for (int i = 0; i < 3; ++i) {
        auto result = SendTyped(counter, Add{5});
        if (result.syscall_ret == sizeof(int))
            NIO::Println(out, "count = %d", result.msg);
    }
    Exit(); // Prints 5, 10, 15.
}

A timed task

The clock server holds a reply until the requested deadline. While this task sleeps, the scheduler runs other ready tasks. One clock tick is 10 ms of guest time.

Create(10, timed_task);

#include "kern/syscall.h"
#include "user/clockserver.hpp"
#include "user/nameserver.hpp"
#include "user/nio.hpp"

void timed_task() {
    int clock = WhoIs(CLOCK_SERVER_NAME);
    int out = WhoIs(NIO::CONSOLE_PUTS_SERVER);
    int next = Time(clock);

    for (int i = 0; i < 3; ++i) {
        next += 100; // One guest second.
        int tick = DelayUntil(clock, next);
        if (tick < 0) break;
        NIO::Println(out, "task %d: tick %d", MyTid(), tick);
    }
    Exit();
}