Package javax.realtime

The javax.realtime package is jRate's implementation of the real-time Java API.

See:
Description

Interface Summary

Interruptible	This interface is used with AsynchronouslyInterruptedException.doInterruptible().
PhysicalMemoryTypeFilter	For use by the PhysicalMemoryManager class (not directly by application code).
Schedulable	Handlers and other objects can be run by a Scheduler if they provide a run() method and the methods defined below.

Class Summary

AbsoluteTime	An object that represents a specific point in time given by milliseconds plus nanoseconds past the epoch (January 1, 1970, 00:00:00 GMT).
AperiodicParameters	This release parameter object characterizes a Schedulable object that may become active at any time.
Arena	Arena is the base class for all those memory areas whose lifetime depends on reachability.
ArenaFactory	The class ArenaFactory has the responsibility of creating Arena instances.
AsyncEvent	An asynchronous event represents something that can happen, like a light turning red.
AsyncEventHandler	An asynchronous event handler encapsulates code that gets run at some time after an AsyncEvent occurs.
BoundAsyncEventHandler	A bound asynchronous event handler is an asynchronous event handler that is permanently bound to a thread.
Clock	A clock advances from the past, through the present, into the future.
CTMemory	A scoped memory area with an allocator that operates in constant-bounded time (with respect to the size of the allocation request).
CTPrivateMemory	The CTPrivateMemory provides constant time allocation time.
GarbageCollector	An abstract class allowing access to information about the system's garbage collection policy.
HeapMemory	The HeapMemory class is a singleton object that allows logic within other scoped memory to allocate objects in the Java heap.
HighResolutionClock	This class provide an high resolution clock.
HighResolutionTime	Used to express time with nanosecond accuracy.
HighResolutionTimer	This class provide a way of conducting a high resolution measurement of the time spent doing something.
ImmortalMemory	ImmortalMemory is a memory resource that is shared among all threads.
ImmortalPhysicalMemory	A memory area that allows allocation from a physical memory range with particular memory attributes.
ImportanceParameters	Importance is an additional scheduling metric that may be used by some priority-based scheduling algorithms during overload conditions to differentiate execution order among threads of the same priority.
jRateSystem	The class jRateSystem contains information about jRate's runtime and configuration.
LTMemory	A scoped memory area with an allocator that operates in linear-bounded time (with respect to the size of the allocation request).
LTPhysicalMemory	A scoped memory area with a linear-time allocator that provides storage from a particular type of memory.
LTPrivateMemory	The LTPrivateMemory provides linear time allocation time.
MemoryArea	MemoryArea is the abstract base class of all classes dealing with the representations of allocatable memory areas, including the immortal memory area, physical memory and scoped memory areas.
MemoryParameters	Memory parameters can be given on the constructor of RealtimeThread and AsyncEventHandler.
MethodAreaMemory	This class encapsulates the JVM (or GCJ run-time) method area.
MonitorControl	Abstract superclass for different monitor control strategies.
NoHeapRealtimeThread	A NoHeapRealtimeThread is a specialized form of RealtimeThread.
OneShotTimer	A timed AsyncEvent that is driven by a clock.
PeriodicParameters	This release parameter indicates that the public boolean RealtimeThread.waitForNextPeriod() throws IllegalThreadStateException method on the associated Schedulable object will be unblocked at the start of each period.
PeriodicTimer	An AsyncEvent whose fire method is executed periodically according to the given parameters.
PhysicalMemoryManager	This class provides a collection of methods to query, set up filters for, and set up insertion/removal handlers for physical memory ranges.
PooledAsyncEventHandler
POSIXSignalHandler	The class POSIXSignalHandler provides a way of handling POSIX signals by means of AsyncEventHandler.
PriorityCeilingEmulation	A monitor control class specifying the priority ceiling protocol as a strategy to avoid deadlock.
PriorityInheritance	A monitor control class specifying priority inheritance as a strategy to avoid deadlock.
PriorityParameters	Instances of this class should be assigned to threads that are managed by schedulers which use a single integer to determine execution order.
PriorityQueue	This class represent a priority queue.
PriorityQueue.ForwardIterator
PriorityQueue.Item
PriorityQueue.PriorityQueueLane	This class implements a priority lane that is used to group together all the objects that have the same priority.
PriorityScheduler	This class implements a priority scheduler.
PrivateScopedMemory	The class PrivateScopedMemory refines ScopedMemory by restricting the number of active threads within the memory area to one.
ProcessingGroupParameters	This is associated with one or more schedulable objects for which the system guarantees that the associated objects will not be given more time per period than indicated by cost.
RationalTime	Deprecated. This class is deprecated in version 1.0.1(b) of the RTSJ.
RawMemoryAccess	A class permitting access to specific memory offsets within the process address space.
RawMemoryFloatAccess	This class extends the capabilities of RawMemoryAccess by additionally supporting the interpretation of raw memory as float and double types.
RealtimeClock	The class RealtimeClock provides access to the "Wall-Clock" time.
RealtimeSecurity	jRate security policies.
RealtimeSystem	Provides access to some system parameters.
RealtimeThread	RealtimeThread extends Thread and includes classes and methods to get and set parameter objects, manage the execution of those threads with a ReleaseParameters type of PeriodicParameters , and waiting.
RefCountedArena	The RefCountedArena class implements a reference counted arena.
RelativeTime	An object that represents a time interval millis/1E3 + nanos/1E9 seconds long.
ReleaseParameters	The abstract top-level class for release characteristics of threads.
Scheduler	An instance of Scheduler manages the execution of schedulable objects and may implement a feasibility algorithm.
SchedulingParameters	Subclasses of SchedulingParameters (PriorityParameters, ImportanceParameters, and any others defined for particular schedulers) provide the parameters to be used by the Scheduler.
ScopedMemory	ScopedMemory is the abstract base class of all classes dealing with representations of memory spaces with a limited lifetime.
SizeEstimator	This is a convenient class to help people figure out how much memory they need.
SporadicParameters	A notice to the scheduler that the associated schedulable object s run method will be released aperiodically but with a minimum time between releases.
Timer	A Timer is a timed event that measures time relative to a given Clock.
VTMemory	A scoped memory area with an allocator that doesn't provide a time complexity guarantee on allocation requests.
VTPhysicalMemory	A scoped memory area with a variable-time allocator that provides storage from a particular type of memory.
WaitFreeDequeue	Deprecated. This class is deprecated in version 1.0.1(b) of the RTSJ.
WaitFreeReadQueue	A queue that provides unsynchronized nonblocking read() and synchronized blocking write().
WaitFreeWriteQueue	A queue that provides unsynchronized nonblocking write() and synchronized blocking read().

Exception Summary

ArrivalTimeQueueOverflowException	Thrown by AsyncEvent.fire() if its queue is already full and the event's BoundAsyncEventHandler has an associated SporadicParameters with arrivalTimeQueueOverflowExcept behavior.
AsynchronouslyInterruptedException	A special exception that is thrown in response to an attempt to asynchronously transfer the locus of control of a RealtimeThread.
CeilingViolationException	Thrown when a Schedulable object or Thread attempts to lock an object governed by an instance of PriorityCeilingEmulation and the thread or Schedulable object's base priority exceeds the policy's ceiling.
DuplicateFilterException	Thrown by PhysicalMemoryManager when more than one filter is registered for a given type of memory.
InaccessibleAreaException	Thrown when the specified memory area is not above the current allocation context on the current thread scope stack.
MemoryInUseException	Thrown when an allocation request is made for a range of physical or virtual memory that is already in use.
MemoryScopeException	Thrown when an object in an incompatible memory area is placed on a wait-free queue.
MemoryTypeConflictException	Thrown when conflicting memory attributes are specified together, or when a particular offset within physical memory is requested of a particular type, and the offset doesn't match the type.
MITViolationException	Thrown by AsyncEvent.fire() when the minimum interarrival time (MIT) is violated and the event's BoundAsyncEventHandler has an associated SporadicParameters with mitViolationExcept behavior.
OffsetOutOfBoundsException	Thrown by the raw memory and physical memory classes when given an invalid address.
ScopedCycleException	Throws when a Schedulable object attempts to enter an instance of ScopedMemory and the operation would case a violation of the single parent rule.
SizeOutOfBoundsException	Thrown by raw and physical memory classes when their constructors are given an invalid size parameter or when an accessor method attempts to access an invalid address.
Timed	Perform a computation (or subcomputation) that will be interrupted after a specified duration.
UnimplementedFeatureError
UnknownHappeningException	Exception thrown when an event is bound to an unknown happening.
UnsupportedPhysicalMemoryException	Thrown when the hardware doesn't support the type of physical memory requested.

Error Summary

AccessViolationError	The exception thrown on an attempt to enter a PrivateScopedMemory which is not owned.
IllegalAssignmentError	The exception thrown on an attempt to make an illegal assignment.
MemoryAccessError	This error is thrown when an illegal access occurs---for example, when MemoryArea.newInstance() is used to construct an object in an inaccessible memory area, or when a NoHeapRealtimeThread has a crisis of identity and decides it wants to try referring to the heap anyway.
ResourceLimitError	Exception thrown if a system resource limit is exceeded.
ThrowBoundaryError	This error is thrown by MemoryArea.enter() (and associated methods) if an exception allocated in a memory area is thrown against its scope boundary; that is, if an exception object cannot propagate further up the call stack because it is being deallocated.

Package javax.realtime Description

The javax.realtime package is jRate's implementation of the real-time Java API. The implementation is not yet complete.

jRate's distribution of this package includes several non-standard methods and classes. We are deprecating/removing non-standard functionality as development continues, and we hope eventually to provide a standard javax.realtime package (with jRate extensions to it residing in another namespace).