Date: January 19, 2025

Topic:

Recall

Better to improve implementation of a known OS due to existing market dependency on legacy systems

Notes

How to innovate Operating Systems?

Should we build a brand new OS or make a better implementation of a known OS

• Marketplace needs that depend on legacy OS like large complex server software
• Building brand new OS not viable for industrial settings
• Innovate where it makes sense for Unix, allowing third-party vendors to develop software against new APIs
• Ensure integration doesn’t break anything

Procedural design has state all over the place while object-based design uses strong interfaces and complete isolation

Object-based vs. Procedural Design

Procedural Design

• Write code as one monolithic entity, have shared state (global variables) or private states (caller and callee)
• State is strewn all over the place where shared state can be manipulated in some places as part of a big monolith

Object-based Design

• Objects contain the state and methods inside the object manipulate the state of the object
• Externally, the state is not visible. Only methods for invocation are visible and they work on state local to the object.
• Object-based design provides strong interfaces and complete isolation of object’s state from everything else

In the Spring approach, we expose interfaces through IDL which third-party vendors can use to build own subsystems for integration with Spring

Spring Network Operating System Approach

Use strong interfaces for each subsystem. Only expose what services are provided by the subsystem, but not how.

Make sure that the system is open, flexible and extensible

• Interfaces can be defined using IDL
• Third-party software vendors can use IDL to build own subsystems to integrate with Spring
• Spring uses a microkernel-based approach

Doors allow for very fast cross address space calls. A thread on the nucleus is assigned to the Target Domain to execute the invocation for the method indicated by the Door Handle.

Nucleus - Spring’s Microkernel

Object invocation within a single node, nucleus only manages threads and IPC

• Domains contain threads similar to a UNIX process, like a container or address space
• Threads can execute in the particular domain (threads are similar in semantics to PThreads)
• Door abstraction is a software capability to a domain
• Any domain can create a Door which are entry points for entering the target domain
• Other domains that want to reach a target domain can do a fopen
  • Get a file descriptor (small integer) that is a handle for accessing the file
  • In the Door Table, we have a set of IDs that each points to a particular Door
  • This lets an invocation to be made in the Target Domain
• Possessor of a Door Handle can make object invocations on the Target Domain
• Nucleus is involved in every door call, to open the door, we need the nucleus’ permission
• Client thread is deactivated, and a thread from the nucleus is allocated to the Target Domain
  • This thread can execute the invocation for the method indicated by the Door Handle
• On return from Target Domain (once protected procedure call is complete), the nucleus thread is deactivated
• Client thread is reactivated so the client can continue with whatever it was doing before