Kernel Constructs

These are the objects that are supported by the kernel.

Atomic Constructs

These constructs are durable. They are to designed to last as long as the machine unless they are destroyed by explicit program actions. In particular they are not lost upon power failures or when the system is brought down. These constructs are kept on disk unless recently accessed. Thus they are the long term as well as the short-term memory of the system.

Keys

Keys are the tokens of authority. Concisely stated, the authority of a program is the set of actions it can take as a direct result of the keys it holds.

There are several types of keys. There is no general way for a program to discover the type of a key that it holds. {See however (p2,discrim) and (p3,alleged).}

Some keys are associated with one page or one node. Such keys are said to (_designate) that page or node. Such keys represent some kind of authority {depending on the key type} over that page or node.

Nodes
Keys are kept in (_nodes). A node consists of 16 slots, numbered from 0 to 15, each of which holds one key. A slot is a key variable; the key in a slot may be replaced by another key. Every slot always contains a key. When a node is first created, each of its slots contains a key known as the zero data key and known as DK(0). We sometimes say that a slot with DK(0) in it is (_empty).

Nodes are stored in memory where the user program cannot directly access them. Only Gnosis kernel calls can modify them. The program provides the initiative to modify a node, but the Gnosis kernel verifies that the rules described herein are followed. Nodes are themselves designated by keys. A node key is one of the types of key that designates a node. Programs holding a node key to a node may modify any slot in that node by placing a held key in that slot. Programs explicitly create and delete nodes. See (p2,node) about nodes.

Some nodes may have (_processes) in them. The kernel considers such nodes {according to the logic described in (p1,domain)} as domain roots. The actions caused by processes in domain roots are entirely responsible for the evolution of the state of the total system. See (p1,process) for more about processes.

Nodes also play the role of control blocks in other operating systems. For example, a node is used to define a process to Gnosis.

If a key designates a node, the key type may limit what the key holder may do with the key to that node. With the node key, the program can place any key that it holds into any slot of the node, and can copy {and use} any key therein. With a different kind of key to the same node, the program is restricted to using the node for a very limited and specific function. A fetch key to a node allows the holder of the key to use and make copies of keys in the node. In effect the program holds the keys in the nodes for which it holds fetch keys.

Pages
Under Gnosis, data is kept in pages and to a very limited extent in data keys. These pages are the 4096-byte pages defined by the 370 architecture. The disks are formatted into page frames and the core is divided into page frames. The paging hardware of the 370 is used to make it appear that data pages have been arranged to form the virtual address space of a program running under Gnosis. Programs can control what pages appear at what addresses in the same and other programs. One page may appear at once at different addresses in the same or different programs. See (p2,pagekey) for more about pages.

Compound Constructs
These constructs are built of atomic constructs by programs outside the kernel but are interpreted by the Gnosis kernel.

Segments

Segments are the means of defining ranges of virtual addresses. A segment is constituted of pages or portions of other segments. Programs can be associated with segments so as to be able to compute the data in the segment just before the first reference by the segment user. See (p1,memtree) about segments.

Meters
Meters measure computer resources {except disk storage} as electric meters measure electricity. Meters also provide a switch function that permits a program with authority over a meter to halt the programs that depend on the meter. A (_meter key) is the authority to use a meter. As with electric meters, Gnosis meters form a tree. Meters are built out of nodes. See (p1,meter) about meters.

Domains
A domain is a bundle of authority and data, organized by a program that is part of the data within the domain. A domain has some authority {keys} and obeys a program that it finds in a segment. All programs except the Gnosis kernel run only in domains.

A domain is somewhat like a subroutine in that it can be called by a program in another domain with an appropriate key.

In a domain there are keys that the program holds and can use directly. A domain includes a key that designates a segment that constitutes the address space of the program in the domain. The domain also includes a meter key that designates a meter that counts and limits the resources used by the domain. The program in the domain can access the data of the domain and exercise some of the authority of the domain.

The authority to call a domain does not grant the authority held by the domain. The program of the domain is thus in a position to grant the caller synthesized authority according to the logic of the program and the authority of the domain.

Domains were designed primarily to directly solve the following fundamental programming problems:

Multi-programming: Domains are independently scheduled.

Hiding complexity and secrets: You may communicate with a domain who knows more and less than you.

Distinguishing situations: They provide multiple contexts for the same program.

When any user program runs, it is in a domain. The domain, in fact, specifies the program and the state of the CPU {general registers, etc.}.

A domain has memory between calls; a call to a domain may change its state according to the logic of the program. That is, a domain is not a pure procedure. Only one process may be in a domain at one time; IBM would call domains serially reusable.

Domains are built from nodes but few programs depend on this fact.

See (p1,domain) about domains.

Since nodes hold keys and some keys designate nodes, we may build trees. This is in fact an important structure. In this manual we will view trees and hierarchies as having their roots high and their branches low. Thus "higher in the tree" means toward the root.

The node hierarchy of meters {(p1,meter)} has its root high, but the keys in nodes designate nodes closer to the root of the hierarchy.