Package edu.utah.janosvm.sys

Provides the java interface to the JanosVM Team facilities.

See:
Description

Interface Summary

CrossTeamCloneable	Interface used to indicate that cross team pointers should be nulled when cloning an object instead of throwing a SegmentationFaultError.
EventHandler	Interface for objects that are want to handle system events.
ManagedExportable	Declares that a subclass of Exportable needs to be explicitly released when it is revoked.
PersistentExport	Indicates an Exportable is to be kept alive even though it isn't imported by anyone at the moment.
TeamEventHandler	An interface for EventTeamHandle call backs.
TemporaryExport	Indicate that an exported object is only alive as long as it is imported by someone.

Class Summary

ConfigFile	Provides basic access to the configuration file.
Event	Simple base class for events used by the kernel.
EventQueue	An internal queue/dispatcher for events.
EventTeamHandle	An extended handle for accessing a team and receiving events from it.
Exportable	Abstract base class for objects {@linkplain Team#exportObject exported} from a team.
ExportManager	Tracks the {@linkplain Importable importables} associated with a single {@linkplain Exportable exportable}.
Importable	An Importable is a safe, cross-team reference to a remote "Exportable" object.
List	Root for a doubly linked list.
ListNode	Doubly linked list node.
PortAuthority	Manages the imports and exports of a team.
Team	Peer object for a TeamBackEnd.
TeamBackEnd	Kernel class used to represent a team, this is then extended internally with a nativeClass.
TeamEvent	Simple class that describes a team related event.
TeamHandle	Provides a safe handle to a Team.
TeamLocal	A java.lang.ThreadLocal-like class that stores data local to a team.
TeamReservation	Record a reservation with another team.
TeamThread
VMInstance	Functions specific to the VM as a whole.

Exception Summary

DeadTeamException	Exception thrown when a {@linkplain Team#switchTo visit} or {@linkplain Team#pushReservation reservation} cannot be secured because one of the teams involved is dead.
DuplicateExportException	Exception thrown when trying to export a object with an 'id' that has already been used.
IndexedResourceSpecException	Internal exception thrown when an resource spec couldn't be satisfied.
NoSuchExportException	Exception thrown when trying to import an object that doesn't exist.
ReservationOverflowException	Exception thrown when a thread has too many team reservations.
TeamEjectionException	Exception thrown when a thread is forcefully thrown from a team during a visit.

Error Summary

ReservationOverflowError	Error thrown when a thread has too many team reservations.
SegmentationFaultError	Indicates that an invalid cross-process pointer was dereferenced.

Package edu.utah.janosvm.sys Description

Provides the java interface to the JanosVM Team facilities.

There are three basic abstractions provided in this package: Teams, Importables and Exportables. The Team is the basis of separation and control in the JanosVM, it is the hook from which resource controls and access controls are hung. Importables and Exportables represent the two views of an object that is shared between teams: the owner's (Exportable) and the user's (Importable).

Teams

A team is a context for execution. It provides the resource limits for threads executing in that context. Most notably the Team embodies the memory available to threads in that context. Another resource associated with a Team is the root name space for classes within the team.

Importables and Exportables

The JanosVM supports separate heaps and garabage collection for each Team. This means the GC thread for team A can run independently of the GC in team B, and that the GC thread for each team looks only at its local roots when performing a GC. References between heaps (say from team A to team B) need to be counted without requiring the GC for team A to look at every other heap in the system. We accomplish this by making all inter-heap references be explicitly managed. This is what Importables and Exportables do. They act as proxies to keep alive local objects referenced remotely, even if the local heap has no references to the object.

See Also:

Team, TeamHandle, TeamBackEnd, Importable,