Pebble

This is a summary/overview page.

http://www.bell-labs.com/project/pebble/ - zombie url

Ports vs. portals - means of calling crossdomain code. (portals allow interposing in much the same way as Mach ports).

• don't forget flask
• don't forget binding (when components can bind to each other after trader has found appropriate servers - but this can be later invalidated if some components revoke rights on these domains)

Where L4 implements IPC and minimal virtual memory management in privileged mode, Pebble’s nucleus includes only code to transfer threads from one protection domain to another and a small number of support functions that require kernel mode. (@sa glue code)

Pebble builds on Fluke and Exokernel works by slightly improving on them.

From SPACE it takes cross-domain-calls as generalization of interrupt handling.

Like Dijkstra’s THE system [Dijkstra68], Pebble hides the details of interrupts from higher level components and uses only semaphores for synchronization.

Philosophy and Architecture

The Pebble philosophy consists of the following four key ideas.

1. The privileged-mode nucleus is as small as possible. If something can be run at user level, it is.
2. The operating system is built from fine-grained replaceable components, isolated through the use of hardware memory protection.
3. The cost of transferring a thread from one protection domain to another should be small enough that there is no performance-related reason to co-locate services.
4. Transferring a thread between protection domains is done by a generalization of hardware interrupt handling, termed portal traversal. Portal code is generated dynamically and performs portal-specific actions.

@sa Portals

@dfn tear-away {read,write}

Scheduling

... a portal transfer does not involve the scheduler in any way. (Section 5.4 describes the only exception to this rule.)

... and direct transfer of control from clients to their servers without scheduler intervention. <- a benefit for thread-migration

@sa Scheduling

Previous works

(As spec'd in Pebble whitepapers)

• Micro-kernels: Mach and L4.
• Protection domains and portals: SPACE.
• Specialized code generation: Synthesis and Synthetix.
• Efficient parameter passing: LRPC.
• Object oriented OS: Spring.
• Dynamically replaceable components: Kea.
• User-level implementation of high-level abstractions: Exokernel