Changes Accepted in Early May 2005
Change list RSTJ 1.0.1(a) to 1.0.1(b)

Note that changes to inherited methods are only itemized in the class where the method is defined.

Note that numbered items such as semantics are identified by unique numbers in this change list.  Since deleted semantics and new semantics have numbers, the numbers in this change list may not match either the 1.0.1(a) or 1.0.1(b) documents.  Because if this, cross references that appear in this change list may not make sense.

                1.       change 

The non-normative thread safety chapter has been removed.

 

Design Chapter

Scheduling section

                2.       change

Replaced:

By timely execution of threads we mean that

With:

Timely execution of schedulable objects means that

In

Timely execution of schedulable objects means that the programmer can determine by analysis of the program, testing the program on particular implementations, or both whether particular threads will always complete execution before a given timeliness constraint.

                3.       change 

Replaced: threads

With :

schedulable objects

In

We use the term scheduling (or scheduling algorithm) to refer to the production of a sequence (or ordering) for the execution of a set of schedulable objects (a schedule).

                4.         change

Replaced thread

With

schedulable object

In

Priority is typically an integer associated with a schedulable object;

                5.               change

Replaced

?to?

With

?that may help?

In

However, the base scheduler also inherits methods from its superclass that may help determine feasibility.

Memory Management

Subsection Memory Areas

                6.         change

 

Inserted

?real-time?

in

specifically including no-heap real-time threads and no-heap asynchronous event handlers.

 

Subsection Scoped Memory

                7.       change

Replaced: ?Every ? With: ?The contents of a?

Replaced  ?area effectively maintains?

With ?are discarded when no object in the scope can be referenced. This is done by a technique similar to reference counting the scope. A conformant implementation might maintain?

Replaced:  ?that? With ?each?

Replaced: ?is? With  ?would be?

Replaced: ?is? With ?would be?

Replaced ?is? With ?would be?

Replaced ?The? With: ?Reuse of the?

Replaced ?Cannot be reused? With ?is blocked?

Replaced ?complete and the RTSJ requires that the finalizers execute to completion before the next use (calling enter() or in a constructor) of the scoped memory area? With ?complete?

In

The contents of a scoped memory are discarded when no object in the scope can be referenced. This is done by a technique similar to reference counting the scope. A conformant implementation might maintain a count of the number of external references to each memory area. The reference count for a ScopedMemory area would be increased by entering a new scope through the enter() method of MemoryArea, by the creation of a schedulable object using the particular ScopedMemory area, or by the opening of an inner scope. The reference count for a ScopedMemory area would be decreased when returning from the enter() method, when the schedulable object using the ScopedMemory terminates, or when an inner scope returns from its enter() method. When the count drops to zero, the finalize method for each object in the memory would be executed to completion. Reuse of the scope is blocked until finalization is complete.

                8.       change

Replaced ?Enclosing? With ?Outer?

In

A reference to a scoped object cannot be assigned to a variable from an outer scope,

Synchronization section

Priority Inversion Avoidance subsection

                9.       change

Replaced

?A second policy, priority ceiling emulation protocol (or highest locker protocol), is also specified for systems that support it. The highest locker protocol is also a well known algorithm in the literature, and it has the following effect:

? With this policy, a monitor is given a priority ceiling when it is created, which is the highest priority of any thread that could attempt to enter the monitor.

? As soon as a thread enters synchronized code, its priority is raised to the monitor?s ceiling priority.

? If, through programming error, a thread has a higher priority than the ceiling of the monitor it is attempting to enter, then an exception is thrown.

Note that while the RTSJ requires that the execution of non-heap schedulable objects must not be delayed by the execution of the garbage collector, an application can cause a no-heap schedulable to wait for garbage collection by synchronizing using an object between an heap-using thread or schedulable object and a non-heap schedulable object. The RTSJ provides three wait-free queue classes to provide protected, non-blocking, shared access to objects accessed by both regular Java threads and no-heap real-time threads. These classes are provided explicitly to enable communication between the real-time execution of non-heap schedulable objects and regular Java threads.?

With

?A second policy, priority ceiling emulation protocol (or highest locker protocol), is also specified for systems that support it. This protocol is also a well-known algorithm in the literature; somewhat simplified, its effect is as follows:

? A monitor is given a ?priority ceiling? when it is created; the programmer should choose the highest priority of any thread that could attempt to enter the monitor.

? As soon as a thread enters synchronized code, its (active) priority is raised to the monitor?s ceiling priority. If, through programming error, a thread has a higher base priority than the ceiling of the monitor it is attempting to enter, then an exception is thrown.

? On leaving the monitor, the thread has its active priority reset. In simple cases it will set be to the thread?s previous active priority, but under some circumstances (e.g. a dynamic change to the thread?s base priority while it was in the monitor) a

different value is possible

Note that while the RTSJ requires that the execution of non-heap schedulable objects must not be delayed by garbage collection on behalf of lower-priority schedulable objects, an application can cause a no-heap schedulable object to wait for garbage collection by synchronizing using an object between an heap-using thread or schedulable object and a non-heap schedulable object. The RTSJ provides wait-free queue classes to provide protected, non-blocking, shared access to objects accessed by both regular Java threads and no-heap real-time threads. These classes are provided explicitly to enable communication between the real-time execution of non-heap schedulable objects and regular Java threads or heap-using schedulable objects.? 

Asynchronous Event Handling section

              10.     change

 

Replaced ?soft? With ?execution time?

in

The Clock class may be extended to represent other clocks the underlying system might make available (such as a execution time clock of some granularity).

Asynchronous Transfer of Control section

Methodological Principles subsection

              11.     change

Replaced ?methods? with ?methods, static initializers?

in

These ATC-deferred sections are synchronized methods, static initializers, and synchronized statements.

Expressibility Principles subsection

              12.     change

Replaced ?thread? With ?schedulable object?

In

Code that responds to an ATC does not return to the point in the schedulable object where the ATC was triggered;

              13.     change

Replaced ?thread? With ?schedulable object?

Replaced ?thread? With ?thread or schedulable object?

Replaced ?thread ? with  ?thread or schedulable object?

in

 

              14.     change

Inserted: ?real-time?

in

Through ATC it must be possible to abort a real-time thread but in a manner that does not carry the dangers of the Thread class?s stop() and destroy() methods.

Pragmatic Principles subsection

              15.     change

Inserted: ?real-time?

in

There should be straightforward idioms for common cases such as timer handlers and real-time thread termination.

              16.     change

Deleted

?ATC must be implemented without inducing an overhead for programs that do not use it.?

Asynchronous Thread Termination section

              17.     change

Inserted: ?Real-Time? in the title.

              18.     change

Replaced ?is? With ?would be?

In

It would be convenient to program threads that abnormally terminate when the external real-time system changes in a way such that the thread is no longer useful.

              19.     change

 

deleted ?would?

from

Without this facility, a thread or set of threads would have to be coded in such a manner so that their

computational behavior anticipated all of the possible transitions among possible states of the external system.

              20.     change

Inserted ?real-time?

in

The RTSJ accommodates safe asynchronous real-time thread termination through a combination of the asynchronous event handling and the asynchronous transfer of control mechanisms.

              21.     change

Inserted ?real-time?

in

To create such a set of real-time threads consider the following steps

              22.     change

Inserted ?real-time?

in

Make all of the application methods of the real-time thread interruptible

              23.     change

Inserted ?real-time?

in

Have the handlers call interrupt() on each of the real-time threads affected by the change

              24.     change

Inserted ?real-time?

in

After the handlers call interrupt() have them create a new set of real-time threads appropriate to the current state of the external world

              25.     change

Inserted ?real-time?

in

Ultimately the run() method of the real-time thread will complete normally.

              26.     change

Insert ?real-time?

in

This idiom provides a quick (if coded to be so) but orderly clean up and termination of the real-time thread.

Physical Memory Access section

              27.     change

Deleted

?The base implementation will provide a PhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes that correctly identify memory classes that are standard for the (OS, JVM, and processor) platform.?

from

The PhysicalMemoryManager is available for use by the various physical memory accessor objects (VTPhysicalMemory, LTPhysicalMemory, ImmortalPhysicalMemory, RawMemoryAccess, and RawMemoryFloatAccess) to create objects of the correct type that are bound to areas of physical memory with the appropriate characteristics - or with appropriate accessor behavior. Examples of characteristics that might be specified are: DMA memory, accessors with byte swapping, etc. The base implementation will provide a PhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes that correctly identify memory classes that are standard for the (OS, JVM, and processor) platform. OEMs may provide PhysicalMemoryTypeFilter classes that allow additional characteristics of memory devices to be specified.

Requirements and Conventions

              28.               change

Inserted

?Subject to the usual assumptions, the methods in javax.realtime can safely be used concurrently by multiple threads unless it is otherwise documented.?

In the list of base requirements

Optional Facilities section

              29.               change

Replaced

?Allows the application to control the processor utilization of a thread or group of threads.?

With

?Allows the application to control the processor utilization of a schedulable object.?

In the description of the cost enforcement option

              30.               change

 

Insert the following option in the option table:

 ?Processing Group Enforcement

Allows the application to control the processor utilization of a group of schedulable objects?

              31.               change

 Insert the following option in the option table:

?Processing Group deadline less than period

Allows the application to specify a processing group deadline ?

              32.               change

Insert the following option in the option table:

 ?Allocation-rate enforcement on heap allocation

Allows the application to limit the rate at which a schedulable object creates objects in the heap.?

              33.               change

Inserted

?The ProcessingGroupParameters class is only functional on systems that support the processing group enforcement option. Cost enforcement, and cost overrun handlers are only functional on systems that support the cost enforcement option. If processing group enforcement is supported, ProcessingGroupParameters must function as specified. If cost enforcement is supported, cost enforcement, and cost overrun handlers must function as specified.?

              34.               change

Inserted

?If the processing group deadline less than period is not supported, values passed to the constructor for ProcessingGroupParameters and its setDeadline method are constrained to be equal to the period. If the option is supported, processing group deadlines less than the period must be supported and function as specified.?

              35.               change

Replaced

?If cost enforcement is not supported, the ProcessingGroupParameters class must not be present. If cost enforcement is supported, ProcessingGroupParameters must be implemented as specified.?

With

?If priority ceiling emulation is supported, PriorityCeilingEmulation must be implemented as specified. If priority ceiling emulation is not supported, PriorityCeilingEmulation must be present, but the implementation may not permit its use as a monitor control policy.?

              36.               change

Replaced

?If priority ceiling emulation protocol is not supported, the PriorityCeilingEmulation class must not be present. If priority ceiling emulation is supported, PriorityCeilingEmulation must be implemented as specified.?

With

?If heap allocation rate enforcement is supported, it must be implemented as specified. If heap allocation rate enforcement is not supported, the allocation rate attribute of MemoryParameters must be checked for validity but otherwise ignored by the implementation.?

              37.               change

Inserted

?The following semantics are optional for an RTSJ implementation designed and licensed exclusively as a development tool:

? The priority scheduler need not support fixed-priority preemptive scheduling or priority inheritance. This does not excuse an implementation from fully supporting the relevant APIs. It only reduces the required behavior of the underlying scheduler to the level of the scheduler in the Java specification extended to at least 28 priorities.

? No semantics constraining timing beyond the requirements of the Java specifications need be supported. Specifically, garbage collection may delay any thread without bound and any delay in delivering asynchronously interrupted exceptions is permissible including never delivering the exception. Note, however, that if any AIE other than the generic AIE is delivered, it must meet the AIE semantics, and all heap-memory-related semantics other than preemption remain fully in effect. Further, relaxed timing does not imply relaxed sequencing. For instance, semantics for scoped memory must be fully implemented.

? The RTSJ semantics that alter standard Java method behavior—such as the modified semantics for Thread.setPriority and Thread.interrupt—are not required for a development tool, but such deviations from the RTSJ must be documented, and the implementation must be able to generate a run-time warning each time one of these methods deviates from standard RTSJ behavior.

? These relaxed requirements set a floor for RTSJ development system tool implementations. A development tool may choose to implement semantics that are not required.?

Required Documentation section

              38.               change

Replaced ?admission control? with ?feasibility testing?

twice in

If the feasibility testing algorithm is not the default, document the feasibility testing algorithm.

              39.                 change

Replaced ?the base? With  ?each other?

In

document the behavior of the scheduler and its interaction with each other scheduler

              40.                 change

Deleted

?3 An implementation of the RTSJ is permitted to spuriously release waiting threads, but it must document the circumstances under which that may happen.?

              41.               change

Deleted

?4. Threads that are preempted in favor of a thread with higher execution eligibility may be given access to the processor at any time as determined by a particular implementation. If the behavior does not match the POSIX specification, the implementation is required to provide documentation stating exactly the algorithm used for granting such access.?

              42.                 change

Inserted

?Placement at the front of the queue may be required in a future version of this specification.?

In

If the preempted schedulable object is not placed at the front of the appropriate queue the implementation must document the algorithm used for such placement. Placement at the front of the queue may be required in a future version of this specification.

              43.                 change

Replaced ?default? With ?base?

in

It must supply documentation for the behavior of the new scheduler with priority inheritance (and, if it is supported, priority ceiling emulation protocol) equivalent to the semantics for the base priority scheduler found in the Synchronization chapter.

              44.                 change

Replaced ?This? With ?The?

in

The worst-case response interval between firing an AsyncEvent because of a bound happening to releasing an associated AsyncEventHandler

              45.                 change

Inserted the following documentation requirement

?An implementation may run finalizers for objects in scoped memory before the scope is reentered and before it returns from any call to getReferenceCount() for that scope. It must, however, document when it runs those finalizers.?

 

              46.               change

 Inserted the following documentation requirement

 

?For each supported clock, the documentation must specify whether the resolution is settable, and if it is settable the documentation must indicate the supported values.?

              47.               change

Inserted the following documentation requirement

 

?If an implementation includes any clocks other than the required real-time clock, their documentation must indicate in what contexts those clocks can be used.?

              48.               change

Deleted

?If we refer to other heaps, such as the heap used by the C language runtime or the operating system?s heap, we will explicitly state which heap.?

from

Throughout the RTSJ, when we use the word code, we mean code written in the Java programming language. When we mention the Java language in the RTSJ, that also refers to the Java programming language. The use of the term heap in the RTSJ will refer to the heap used by the runtime of the Java language. If we refer to other heaps, such as the heap used by the C language runtime or the operating system?s heap, we will explicitly state which heap.

Standard Java Chapter

Thread Groups section

              49.               change

Replaced

?Thread groups are rooted at a base ThreadGroup object which is created in heap memory, and thread group objects hold references to all their member threads. Since no-heap threads cannot hold a reference to a heap object they are not permitted to contain a reference to a thread group, and since thread groups cannot hold references to threads created in scoped memory they are also not permitted to have normal thread group membership. In consequence all no-heap threads and some plain real-time threads have null thread group references.?

With

?Thread groups are rooted at a base ThreadGroup object which may be created in heap or immortal memory. All thread group object hold references to all their member threads, and subgroups, and a reference to their parent group. Since heap and immortal memory can not hold references to scoped memory, it follows that a thread group can never be allocated in scoped memory. It then follows that no thread allocated in scoped memory may be referenced from any thread group, and consequently such threads are not part of any thread group and will hold a null thread group reference. Similarly, a NoHeapRealtimeThread can not be a member of a heap allocated thread group.?

              50.               change

Deleted

?Note that a thread group cannot be created in a scoped memory area because the parent/child references between thread groups would violate scoped memory assignment rules and throw an IllegalAssignmentError.?

              51.               change

Insert new section ?InterruptedException?

              52.               change

Inserted

?The interruptible methods in the standard libraries (such as Object.wait, Thread.sleep, and Thread.join) have their contract expanded slightly such that they will respond to interruption not only when the interrupt method is invoked on the current thread, but also, for schedulable objects, when executing within a call to AIE.doInterruptible and that AIE is fired. See Asynchrony.?

Real-Time Threads chapter

 

Semantics and Requirements for Real-time Threads section

              53.               change

Replaced

?A no-heap real- time thread will not be blocked by the garbage collector executing in the context of a Java thread with a lower execution eligibility.?

With

?Garbage collection executing in the context of a Java thread must not in itself block execution of a no-heap thread with a higher execution eligibility, however application locks work as specified even when the lock causes synchronization between a heap-using thread and a no-heap thread.?

              54.                 change

Inserted

?, and when an asynchronously interrupted exception?s fire method is invoked between the time the real-time thread has entered that exception?s doInterruptible method, and return from doInterruptible. (See the Asynchrony chapter.)?

in

Each real-time thread has an attribute which indicates whether an AsynchronouslyInterruptedException is pending. This attribute is set when a call to RealtimeThread.interrupt() is made on the associated real-time thread, and when an asynchronously interrupted exception?s fire method is invoked between the time the real-time thread has entered that exception?s doInterruptible method, and return from doInterruptible. (See the Asynchrony chapter.)

 

Second RealtimeThread constructor

              55.               change

Replaced ?default? With ?associated?

In

java.lang.IllegalArgumentException - Thrown if the scheduling parameters are not compatible with the associated scheduler.

 

Third RealtimeThread constructor

              56.               change

Replaced ?default? With ?associated?

In

java.lang.IllegalArgumentException - Thrown if the scheduling parameters or release parameters are not compatible with the associated scheduler.

 

Fourth RealtimeThread constructor

              57.               change

Inserted ?The newly-created real-time thread is associated with the scheduler in effect during execution of the constructor.?

In the description of the scheduling parameter

              58.               change

Replaced ?copy? With ?clone?

Replaced ?the new RealtimeThread? With ?this?

Replaced ?default ? with  ?associated?

in

scheduling - The SchedulingParameters associated with this (And possibly other instances of Schedulable). If scheduling is null and the creator is a schedulable object, SchedulingParameters102 is a clone of the creator?s value created in the same memory area as this. If scheduling is null and the creator is a Java thread, the contents and type of the new SchedulingParameters object is governed by the associated scheduler.

 

              59.                 change

In the description of the release parameter

Replaced  ?default ? with  ?associated ?

Replaced ?copy? with ?clone?

In

release - The ReleaseParameters associated with this (and possibly other instances of Schedulable). If release is null the new RealtimeThread will use a clone of the default ReleaseParameters for the associated scheduler created in the memory area that contains the RealtimeThread object.

              60.                 change

Replaced ?The ? with  ?This ?

In

java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler.

 

Text copied from the Schedulable interface is covered with that interface

 

currentRealtimeThread method

              61.               change

Replaced  ?not an instance of RealtimeThread or an asynch event handler? 

with ?that of a Java thread?

in

java.lang.ClassCastException - Thrown if the current execution context is that of a Java thread. 

getCurrentMemoryArea method

              62.               change

Inserted

?If this method is invoked from a Java thread it will return that thread?s current memory area (heap or immortal.)?

getInitialMemoryAreaIndex method

              63.               chang

Inserted ?This method returns the position in the memory area stack of the initial memory area.?

              64.               change

Insert ?may?

              65.               change

Delete ?This method returns the position in the memory area stack of initial memory area.?

In

This method returns the position in the memory area stack of the initial memory area. Memory area stacks may include inherited stacks from parent threads. The initial memory area for the current RealtimeThread or AsyncEventHandler is the memory area given as a parameter to the constructor. The index on the memory area stack of the initial memory area is a fixed property of the real-time thread. This method returns the position in the memory area stack of initial memory area.

getOuterMemoryArea method

              66.               change

Inserted ?Note: The current memory area (getCurrentMemoryArea()) is found at memory area stack index getMemoryAreaStackDepth() - 1., so getCurrentMemoryArea() == getOutMemoryArea(getMemoryAreaStack- Depth() - 1).?

Sleep(clock, time) method

              67.               change

Inserted ?This method must not throw IllegalAssignmentError. It must tolerate time instances that may not be stored in this.?

              68.               change

Replaced ?if interrupted ? with ?if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?

In

java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.

 

              69.                 change

Replaced ?not an instance of RealtimeThread or an async event handler.? With ?that of a Java thread.?

In

java.lang.ClassCastException - Thrown if the current execution context is that of a Java thread.

              70.                 change

Replaced ?java.lang.IllegalArgumentException - Thrown if clock cannot represent calendar time, or if time is a relative time less than zero.?

With

?java.lang.UnsupportedOperationException - Thrown if the sleep operation is not supported by clock.

java.lang.IllegalArgumentException - Thrown if time is null, or if time is a relative time less than zero.?

 

Sleep(time) method

              71.               change

Inserted

?This method must not throw IllegalAssignmentError. It must tolerate time instances that may not be stored in this.?

              72.               change

Replaced  ?if interrupted ?

With ?if the thread is interrupted by interrupt()36 or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?

In

java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt()36 or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.

              73.               change

Replaced  ?not an instance of RealtimeThread or an async event handler.?

With ?that of a Java thread.?

In

java.lang.ClassCastException - Thrown if the current execution context is that of a Java thread.

              74.               change

Replaced ?java.lang.IllegalArgumentException - Thrown if clock cannot represent calendar time, or if time is a relative time less than zero.?

With

?java.lang.UnsupportedOperationException - Thrown if the sleep operation is not supported using the clock associated with time.?

java.lang.IllegalArgumentException - Thrown if time is null, or if time is a relative time less than zero.

start() method

              75.               change

Inserted ?it ?

in

Set up the real-time thread?s environment and start it. The set up might include delaying it until the assigned start time and initializing the thread?s scope stack.

NoHeapRealtimeThread class

First constructor

              76.               change

Replaced  ?scheduling or area is? with  ?the parameters are?

Replaced  ?default ? with  ?associated?

Deleted  ?or?

Inserted

?if area is heap memory, if area or scheduling is allocated in heap memory, or if this is in heap memory?

in

java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null, if area is heap memory, if area or scheduling is allocated in heap memory, or if this is in heap memory.

Second constructor

              77.               change

Replaced ?default? with ?associated?

Deleted ?or?

Inserted

?if area is null, if area is heap memory, if area, release or scheduling is allocated in heap memory, or if this is in heap memory.?

In

java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null, if area is heap memory, if area, release or scheduling is allocated in heap memory, or if this is in heap memory.

 

              78.               change

Deleted ?release?

Replaced ?area and group? with ?release?

In

IllegalAssignmentError - Thrown if the new NoHeapRealtimeThread instance cannot hold a reference to non-null values of scheduling release and area and

grouprelease, or if those parameters cannot hold a reference to the new NoHeapRealtimeThread.

Third constructor

              79.               change

Inserted

?The newly-created no-heap real-time thread is associated with the scheduler in effect during execution of the constructor.?

              80.               change

Replaced ?default? with ?associated?

Deleted ?or?

Inserted

?if area is heap memory, if area, scheduling release, memory or group is allocated in heap memory, if this is in heap memory, or if logic is in heap memory. ?

In

java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null, if area is heap memory, if area, scheduling release, memory or group is allocated in heap memory, if this is in heap memory, or if logic is in heap memory.

 

              81.               change

Replaces  ?parameters ? with  ?scheduling, release, memory and group?

In

IllegalAssignmentError422 - Thrown if the new NoHeapRealtimeThread instance cannot hold references to non-null values of the scheduling release, memory and group,

or if those parameters cannot hold a reference to the new NoHeapRealtimeThread.

start() method

              82.               change

Replaced

?Checks if the NoHeapRealtimeThread is startable and starts it if it is. Checks that the parameters associated with this NHRT object are not allocated in heap. Also checks if this object is allocated in heap. If any of them are allocated, start() throws a MemoryAccessError?

with

?Checks if the NoHeapRealtimeThread is startable and starts it if it is.?

              83.               change

Delete the Throws: MemoryAccessError clause

Scheduling chapter

Definitions and Abbreviations section

              84.               change

Replaced  ?inherited? with  ?acquired?

Inserted  ?the action of?

              85.               change

Replaced  ?inheritance ? with  ?inversion avoidance algorithms?

              86.               change

Replaced  ?Synchronization ? with  ?the Synchronization?

In

The active priority of a schedulable object, or a Java thread, is the maximum of its base priority and any priority it has acquired due to the action of priority inversion avoidance algorithms (see the Synchronization Chapter).

              87.               change

Replaced

?This specification does not require any particular feasibility algorithm be implemented in the Scheduler object. The default algorithm always returns success, as it assumes an adequately fast computer.?

With

?This specification does not require any particular feasibility algorithm be implemented in the Scheduler object. The default algorithm always returns success for sporadic and periodic schedulable objects, as it assumes adequate resources, but it always returns false for aperiodic schedulable objects since no pool of resources would render such a load feasible.?

 

Processing Groups subsection

              88.               change

Replaced  ?cost enforcement ? with  ?processing group enforcement?

in

Processing groups are only functional in a system that implements processing group enforcement. Although the processing group itself does not consume CPU time, it acts as a proxy for its members.

              89.               change

Insert semantic

?Changes to the membership of the processing group take effect immediately?

Rationale section

              90.               change

Inserted  ?active ?

in

Although a system may not implement the first release (start) of a schedulable object as unblocking that schedulable object, under the base scheduler those semantics apply; i.e., the schedulable object is added to the tail of the queue for its active priority.

Schedulable interface

addIfFeasible method

              91.           change

Replaced  ?The ? with  ?This?

In

The This method first performs a feasibility analysis with this added to the system.

              92.           change

Deleted

?the scheduling release, and memory parameters of?

from

If the resulting system is feasible, inform the scheduler and cooperating facilities that the scheduling, release, and memory parameters of this instance of Schedulable should be considered

              93.           change

Replace ?feasible? with ?feasibility?

In

This method first performs a feasibility analysis with this added to the system. If the resulting system is feasible, inform the scheduler and cooperating

facilities that this instance of Schedulable73 should be considered in feasibility analysis until further notified. If the analysis showed that the system including this would not be feasible, this method does not admit this to the feasibility set.

              94.           change

Replace ?feasible? with ?feasibility ?

In

If the object is already included in the feasibility set, do nothing.

              95.           change

Replaced

?Returns: True, if this was admitted to the feasible set, False, if this was not admitted because it would not be feasible or because there is no assigned instance of Scheduler.?

With

?Returns: True if inclusion of this in the feasibility set yields a feasible system, and false otherwise. If true is returned then this is known to be in the feasibility set. If false is returned this was not added to the feasibility set, but may already have been present.?

addToFeasibility method

              96.           change

Deleted: ?the SchedulingParameters ReleaseParameters ReleaseParameters and MemoryParameters of?

from

Inform the scheduler and cooperating facilities that the SchedulingParameters ReleaseParameters and MemoryParameters of this instance of Schedulable should be considered in feasibility analysis until further notified.

              97.           change

Replaced  ?feasible ? with  ?feasibility ?

In

If the object is already included in the feasibility set, do nothing.

 

getScheduler() method

              98.           change

Replaced  ?current ? with  ?associated ?

in

Returns: A reference to the associated Scheduler object.

removeFromFeasibility() method

              99.           change

Deleted  ?the parameters of ?

in

Inform the scheduler and cooperating facilities that the parameters of this instance of Schedulable82 should not be considered in feasibility analysis until it is further notified.

            100.         change

Deleted  ?there is no assigned instance of Scheduler or if?

Replaced  ?feasible ? with  ?feasibility ?

in

Returns: True, if the removal was successful. False, if there is no assigned instance of Scheduler , or if the schedulable object cannot be removed from the scheduler?s feasible set; e.g., the schedulable object is not part of the scheduler?s feasible feasibility set.

setIfFeasible(release, memory) method

            101.         change

Deleted  ?release and memory ?

From

The method first performs a feasibility analysis using release and memory as replacements for the matching parameter values of this. If the resulting system is feasible the method replaces the current release and memory parameters of this with the new parameters.

            102.         change

Replaced ?The ? with  ?This?

Replaced  ?release and memory ? with  ?the proposed parameter objects?

Replaced  ?matching parameter values ? with  ?current parameters?

Replaced  ?feasible the ? with  ?feasible, this ?

Replaced  ?new parameters ? with  ?proposed ones?

in

This method first performs a feasibility analysis using the proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible, this method replaces the current parameters of this with the proposed ones.

            103.         change

Replaced  ?feasible ? with  ?feasibility?

Replaced  ?feasible ? with  ?feasibility?

Replaced  ?schedule ? with  ?system?

In

This method does not require that the schedulable object be in the feasibility set before it is called. If it is not initially a member of the feasibility set it will be added if the resulting system is feasible.

            104.         change

Inserted

?Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.?

In

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.

            105.         change

Deleted  ?object ?

Replaced  ?release and memory ? with  ?the proposed parameter objects?

Replaced  ?release or memory ? with  ?parameter objects?

Replaced  ?references ? with  ?a reference ?

in

IllegalAssignmentError - Thrown if this object cannot hold references to release and memory the proposed parameter objects, or the release or memory parameter objects cannot hold references a reference to this.

setIfFeasible(release, memory, group) method

            106.         change

Replaced ?The? with ?This?

Replaced ?new ReleaseParameters, MemoryParameters, and ProcessingGroupParameters? with ?proposed parameter objects?

Replaced ?feasible the? with ?feasibility, this?

Replaced ?release, memory and processing group? with ?of this?

Replaced ?corresponding replacement parameters? with ?proposed ones?

in

The This method first performs a feasibility analysis using the new ReleaseParameters , MemoryParameters and

ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible the feasible, this method replaces the current release, memory and processing group parameters of this with the corresponding replacement parameters.proposed ones.

            107.         change

Replaced ?feasible? with ?feasibility?

Replaced ?feasible? with ?feasibility?

Replaced ?schedule? with ?system?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            108.         change

Inserted ?schedulable object?s?

Inserted ?Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.

            109.         change

Deleted ?object?

Replaced ?all three? with ?the proposed?

Replaced ?objects? with ?objects,?

Replaced ?parameters? with ?parameter objects?

Replaced ?references? with ?a reference?

In

IllegalAssignmentError456 - Thrown if this object cannot hold references to all three the proposed parameter objects objects, or the parameters parameter objects cannot hold references a reference to this.

setIfFeasible(release, group) method

            110.         change

Replaced ?The? with ?This?

Replaced ?new ReleaseParameters and ProcessingGroupParameters? with ?proposed parameter objects?

Replaced ?the? with ?this?

Replaced ?ReleaseParameters and ProcessingGroupParameters? with ?parameters of this?

Replaced ?new parameters? with ?proposed ones?

In

The This method first performs a feasibility analysis using the new ReleaseParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible, the this method replaces the current ReleaseParameters and ProcessingGroupParameters parameters of this with the new parametersproposed ones.

            111.         change

Replaced ?feasible? with ?feasibility?

Replaced ?feasible? with ?feasibility?

Replaced ?schedule? with ?system?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            112.         change

Inserted ?schedulable object?s?

Inserted ?Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.?

In

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.

            113.         change

Deleted ?object?

Replaced ?both? with ?the proposed?

Replaced ?objects? with ?objects,?

Replaced ?parameters? with ?parameter objects?

Replaced ?references? with ?a reference?

In

IllegalAssignmentError456 - Thrown if this object cannot hold references to both the proposed parameter objects objects, or the parameters parameter objects cannot hold references a reference to this.

setIfFeasible(scheduling, release, memory) method

            114.         change

Replaced ?sched? with ?scheduling? in the method declaration

            115.         change

Replaced ?The? with ?This?

Replaced ?release and memory? with ?the proposed parameter objects?

Replaced ?matching parameter values? with ?current parameters?

Replaced ?feasible the? with ?feasibility, this?

Deleted "scheduling, release and memory?

Replaced ?corresponding replacement parameters? with ?proposed ones?

In

The This method first performs a feasibility analysis using release and memory the proposed parameter objects as replacements for the matching parameter values current parameters of this. If the resulting system is feasible the feasible, this method replaces the current scheduling, release and memory parameters of this with the corresponding replacement parametersproposed ones.

            116.         change

Replaced ?feasible? with ?feasibility?

Replaced ?feasible? with ?feasibility?

Replaced ?schedule? with ?system?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            117.         change

Inserted ?. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable

object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.

            118.         change

Inserted ?object?

Replaced ?release and memory? with ?the proposed parameter objects?

Replace ?release or memory? with ?parameter objects?

Replace ?references? with ?a reference?

In

IllegalAssignmentError456 - Thrown if this object cannot hold references to release and memory the proposed parameter objects, or the release or memory parameter objects cannot hold references a reference to this.

setIfFeasible(scheduling, release, memory, group) method

            119.         change

Rename ?sched? to ?scheduling? in the declaration

            120.         change

Replaced: ?new ReleaseParameters , MemoryParameters. And ProcessingGroupParameters? With: ?proposed parameter objects ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?ReleaseParameters, MemoryParameters andProcessingGroupParameters ? With: ?parameters of this ?

Replaced: ?new parameters? With: ?proposed ones?

In

The This method first performs a feasibility analysis using the new ReleaseParameters , MemoryParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters, MemoryParameters and ProcessingGroupParameters parameters of this with the new parametersproposed ones. 

            121.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            122.         change

Inserted: ?schedulable object?s ?

Inserted: ?. Also thrown if this this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.?

In

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.

            123.         change

Deleted: ?object ?

Replaced: ?all three ? With: ?the proposed ?

Replaced: ?objects ? With: ?objects, ?

Replaced: ?parameters ? With: ?parameter objects ?

Replaced: ?references ? With: ?a reference ?

In

IllegalAssignmentError - Thrown if this object cannot hold references to all three the proposed parameter objects objects, or the parameters parameter objects cannot hold references a reference to this.

            124.         change

Deleted: ?, or if sched is not compatible with the scheduler associated with this.?

In

java.lang.IllegalThreadStateException - Thrown if the new release parameters change the schedulable object from periodic scheduling to some other protocol and the schedulable object is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible() , or if sched is not compatible with the scheduler associated with this. 

setMemoryParameters(memory) method

            125.         change

Replaced: ?schedule? With: ?system?

In

Since this affects the constraints expressed in the memory parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.

            126.         change

Inserted: ?. Also thrown if this this schedulable object is no-heap and memory is located in heap memory.?

In

java.lang.IllegalArgumentException - Thrown if memory is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is no-heap and memory is located in heap memory.

setMemoryParametersIfFeasible(memory) method

            127.         change

?The ? With: ?This ?

Replaced: ?given memory parameters ? With: ?proposed parameter object ?

Replaced: ?replacements ? With: ?replacement ?

Replaced: ?memory parameters ? With: ?current parameter ?

Replaced: ?this ? With: ?this. ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?memory parameters ? With: ?parameter ?

Replaced: ?new memory parameters? With: ?proposed one?

In

The This method first performs a feasibility analysis using the given memory parameters proposed parameter object as replacements replacement for the memory parameters current parameter of this this. If the resulting system is feasible the feasible, this method replaces the current memory parameters parameter of this with the new memory parametersproposed one.

            128.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            129.         change

Replaced: ?memory ? With: ?the parameter value ?

Inserted: ?schedulable object?s ?

Inserted: ?. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when memory the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory.

            130.         change

Deleted ?object ?

Replaced: ?memory ? With: ?the proposed parameter object,?

Replaced: ?memory ? With: ?the parameter object ?

In

IllegalAssignmentError456 - Thrown if this object cannot hold a reference to memory the proposed parameter object, or memory the parameter object cannot hold a reference to this.

setProcessingGroupParameters(group) method

            131.         change

Replaced: ?schedule? With: ?system?

In

Since this affects the constraints expressed in the processing group parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.

            132.         change

Replaced: ?at ? With: ?as determined by ?

Replaced: ?next release of this? With: ?associated scheduler?

In

group - A ProcessingGroupParameters object which will take effect at as determined by the next release of thisassociated scheduler. If null, the default value is governed by the associated scheduler (a new object is created if the default value is not null). (See PriorityScheduler .)

            133.         change

Inserted: ?. Also thrown if this schedulable object is no-heap and group is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when group is not compatible with the scheduler for this schedulable object. Also thrown if this schedulable object is no-heap and group is located in heap memory.

setProcessingGroupParametersIfFeasible(group) method

            134.         change

Replaced: ?The ? With: ?This ?

Replaced: ?new ProcessingGroupParameters ? With: ?proposed parameter object ?

Deleted: ?a ?

Replaced: ?parameters ? With: ?parameter ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?ProcessingGroupParameters ? With: ?parameter of this ?

Replaced: ?new parameters. The changes ...? With: ?proposed one?

In

The This method first performs a feasibility analysis using the new ProcessingGroupParameters proposed parameter object as a replacement for the current parameters parameter of this. If the resulting system is feasible the feasible, this method replaces the current ProcessingGroupParameters parameter of this with the new parameters. The changes take place at the schedulable object?s next releaseproposed one.

            135.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            136.         change

Replaced: ?ProcessingGroupParameters object? With: ?proposed processing group parameters?

In

group - The ProcessingGroupParameters objectproposed processing group parameters. If null, the default value is governed by the associated scheduler (a new object is created if the default value is not null). (See PriorityScheduler .)

            137.         change

Replaced: ?group ? With: ?the parameter value ?

Inserted: ?schedulable object?s ?

            138.         change

Inserted: ?. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when group the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory.

            139.         change

Deleted: ?object ?

Replaced: ?group ? With: ?the proposed parameter object, ?

Replaced: ?group ? With: ?the parameter object ?

In

IllegalAssignmentError - Thrown if this object cannot hold a reference to group the proposed parameter object, or group the parameter object cannot hold a reference to this.

setReleaseParameters(release) method

            140.         change

Replaced: ?schedule? With: ?system?

In

Since this affects the constraints expressed in the release parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.

            141.         change

Inserted: ?, and take effect as determined by the associated scheduler?

In

release - A ReleaseParameters object which will become the release parameters associated with this after the method call,

and take effect as determined by the associated scheduler. If null, the default value is governed by the associated scheduler (a new object is created if the default value is not null). (See PriorityScheduler .)

            142.         change

Inserted: ?associated ?

Inserted: ?. Also thrown if this schedulable object is no-heap and release is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when release is not compatible with the associated scheduler. Also thrown if this schedulable object is no-heap and release is located in heap memory.

setReleaseParametersIfFeasible(release) method

            143.         change

Replaced: ?The ? With: ?This ?

Replaced: ?new ReleaseParameters ? With: ?proposed parameter object ?

Deleted: ?a ?

Replaced: ?parameters ? With: ?parameter ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?ReleaseParameters ? With: ?parameter of this ?

Replaced: ?new parameters? With: ?proposed one?

In

The This method first performs a feasibility analysis using the new ReleaseParameters proposed parameter object as a replacement for the current parameters parameter of this. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters parameter of this with the new parametersproposed one.

            144.         change

Moved from one paragraph down: ?This change becomes effective under conditions determined by the scheduler controlling the schedulable object. For instance, the change may be immediate or it may be delayed until the next release of the schedulable object. See the documentation for the scheduler for details.?

            145.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            146.         change

Replaced: ?ReleaseParameters object? With: ?proposed release parameters?

Inserted: ?the ?

Replaced: ?release parameters for ? With: ?value is governed by ?

Deleted: ?are used ?

Inserted: ?. (See PriorityScheduler) ?

In

release - The ReleaseParameters objectproposed release parameters. If null, the default release parameters for value is governed by the associated scheduler are used (a new object is created if the default value is not null). (See PriorityScheduler.)

            147.         change

Replaced: ?release ? With: ?the parameter value ?

Inserted: ?schedulable object?s ?

            148.         change

Inserted: ?. Also thrown if this schedulable object is no-heap and release is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when release the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory.

            149.         change

Deleted: ?object ?

Replaced: ?release ? With: ?the proposed parameter object, ?

Replaced: ?release ? With: ?the parameter object ?

In

IllegalAssignmentError - Thrown if this object cannot hold a reference to release the proposed parameter object, or release the parameter object cannot hold a reference to this.

setScheduler(scheduler) method

            150.         change

Replace: ?Sets the reference to the Scheduler object. The timing of the change is under the control of the new scheduler. In the case of the default scheduler, the change is made immediately. If this schedulable object has been admitted to the feasible set (e.g., by addToFeasibility()) it remains in the feasible set after the change in scheduler. This change in the scheduler may affect the feasibility of the current schedule.?

With

?Sets the reference to the Scheduler object. The timing of the change must be agreed between the scheduler currently associated with this schedulable object, and scheduler.?

            151.         change

Deleted: ?the new ?

Inserted: ?. Also thrown if this schedulable object is no-heap and release is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when scheduler is null, or the schedulable object?s existing parameter values are not compatible with the new scheduler. Also thrown if this schedulable object is no-heap and scheduler is located in heap memory.

setScheduler(scheduler, scheduling, release, memoryParameters, group) method

            152.         change

Replaced: ?is under the control of the new scheduler. In the case of? With: ?must be agreed between ?

Deleted: ?default scheduler, the ?

            153.         change

Replaced: ?and scheduling parameters take control immediately? With: ?currently associated with this schedulable object?

Replaced: ?the release and processing group parameters take effect the next time the schedulable is released? With: ?scheduler.?

In

Sets the scheduler and associated parameter objects. The timing of the change is under the control of the new scheduler. In the case of must be agreed between the default scheduler, the scheduler and scheduling parameters take control immediatelycurrently associated with this schedulable

object, and the release and processing group parameters take effect the next time the schedulable is released. scheduler.

            154.         change

Deleted: ?If this schedulable object has been admitted to the feasible set (e.g., by addToFeasibility() ) it remains in the feasible set after the change in scheduler. This change in the scheduler may affect the feasibility of the current schedule.?

            155.         change

Replaced: ?the ? With: ?scheduler. Also thrown when this schedulable object is no-heap and?

            156.         change

Inserted: ?, scheduling release, memoryParameters, or group is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when scheduler is null or the parameter values are not compatible with the scheduler. Also thrown when this schedulable object is no-heap and scheduler, scheduling release, memoryParameters, or group is located in heap memory.

setSchedulingParameters(scheduling) method

            157.         change

Replaced: ?schedule? With: ?system?

In

Since this affects the scheduling parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.

            158.         change

Inserted: ?associated ?

            159.         change

Inserted: ?. Also thrown if this schedulable object is no-heap and scheduling is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when scheduling is not compatible with the associated scheduler. Also thrown if this schedulable object is no-heap and scheduling is located in heap memory.

setSchedulingParametersIfFeasible(scheduling) method

            160.         change

Replaced: ?The ? With: ?This ?

Replaced: ?given scheduling parameters ? With: ?proposed parameter object ?

Replaced: ?replacements ? With: ?replacement ?

Replaced: ?scheduling parameters ? With: ?current parameter ?

Replaced: ?this ? With: ?this. ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?scheduling parameters ? With: ?parameter ?

Replaced: ?new scheduling parameters? With: ?proposed one?

In

The This method first performs a feasibility analysis using the given scheduling parameters proposed parameter object as replacements replacement\ for the scheduling parameters current parameter of this this. If the resulting system is feasible the feasible, this method replaces the current scheduling parameters parameter of this with the new scheduling parametersproposed one.

            161.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            162.         change

Deleted: ?SchedulingParameters are set to the?

Replaced: ?SchedulingParameters for ? With: ?value is governed by ?

Inserted: ?a new object is created ?

Replaced: ?null a new object is created? With: ?null?

Inserted: ?. (See PriorityScheduler )?

In

scheduling - The proposed scheduling parameters. If null, the SchedulingParameters are set to the default SchedulingParameters for value is governed by the associated

scheduler (a new object is created if the default value is not null a new object is creatednull). (See PriorityScheduler108 .)

            163.         change

Replaced: ?scheduling ? With: ?the parameter value ?

Inserted: ?schedulable object?s ?

            164.         change

Inserted: ?. Also thrown if this schedulable object is no-heap and the proposed parameter object is located in heap memory?

In

java.lang.IllegalArgumentException - Thrown when scheduling the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is no-heap and the proposed parameter object is located in heap memory.

            165.         change

Deleted: ?object ?

Replaced: ?scheduling ? With: ?the proposed parameter object, ?

Replaced: ?scheduling ? With: ?the parameter object ?

In

IllegalAssignmentError456 - Thrown if this object cannot hold a reference to scheduling the proposed parameter object, or scheduling the parameter object cannot hold a reference to this.

Scheduler class

            166.         change

Replaced: ?schedule? With: ?system?

In

An instance of Scheduler manages the execution of schedulable objects and implements a feasibility algorithm. The feasibility algorithm determines if the known set of schedulable objects, given their particular execution ordering (or priority assignment), is a feasible schedulesystem.

addToFeasibility(schedulable) method

            167.         change

Deleted: ?(as expressed in the the associated instances?

Deleted: ?SchedulingParameters , ReleaseParameters MemoryParameters , and ProcessingGroupParameters ) of?

Replaced: ?feasible ? With: ?feasibility ?

In

Inform this scheduler and cooperating facilities that the resource demands (as expressed in the associated instances of SchedulingParameters, ReleaseParameters , MemoryParameters , and ProcessingGroupParameters ) of the given instance of Schedulable83 will be considered in the feasibility analysis of the associated

Scheduler101 until further notice. Whether the resulting system is feasible or not, the addition is completed. If the object is already included in the feasible feasibility set, do nothing.

            168.         change

Inserted: ?, or if schedulable is not associated with this; that is schedulable.getScheduler() != this?

In

java.lang.IllegalArgumentException - Thrown if schedulable is null, or if schedulable is not associated with this; that is schedulable.getScheduler() != this.

isFeasible() method

            169.         change

Replaced: ?set of scheduling and release characteristics? With: ?system ?

Inserted: ?. The definitions of ?feasible? and ?system? are the responsibility of the feasibility algorithm of the actual Scheduler subclass?

In

Queries the system about the feasibility of the set of scheduling and release characteristics system currently being considered. The definitions of ?feasible? and ?system? are the responsibility of the feasibility algorithm of the actual Scheduler subclass.

removeFromFeasibility(schedulable) method

            170.         change

Replaced: ?the ? With: ?this ?

Replaced: ?demands, as expressed in ? With: ?demands of ?

Replaced: ?associated instances of SchedulingParameters , ReleaseParameters, MemoryParameters , and ProcessingGroupParameters , of this? With: ?given ?

In

Inform the this scheduler and cooperating facilities that the resource demands, as expressed in demands of the associated instances of SchedulingParameters , ReleaseParameters, MemoryParameters , and ProcessingGroupParameters , of this given instance of Schedulable should no longer be considered in the

feasibility analysis of the associated Scheduler . Whether the resulting system is feasible or not, the removal is completed. 

            171.         change

Inserted: ?Parameters: schedulable - A reference to the given instance of Schedulable?

 

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

In

Returns: True, if the removal was successful. False, if the schedulable object cannot be removed from the scheduler?s feasible feasibility set; e.g., the schedulable object is not part of the scheduler?s feasible feasibility set.

setDefaultScheduler(scheduler) method

            172.         change

Replaced: ?constructed? With: ?constructed by a Java thread?

In

Sets the default scheduler. This is the scheduler given to instances of schedulable objects when they are constructedconstructed by a Java thread. The default scheduler is set to the required PriorityScheduler at startup.

 

            173.         change

Inserted: ?schedulable objects created by Java ?

In

scheduler - The Scheduler that becomes the default scheduler assigned to new schedulable objects created by Java threads. If null nothing happens.

setIfFeasible(schedulable, release, memory)

            174.         change

Replaced: ?new ReleaseParameters and MemoryParameters? With: ?proposed parameter objects ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?ReleaseParameters and MemoryParameters ? With: ?parameters of schedulable ?

Replaced: ?new parameters? With: ?proposed ones?

In

This method first performs a feasibility analysis using the new ReleaseParameters and MemoryParameters proposed parameter objects as replacements for the current parameters of schedulable. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters and MemoryParameters parameters of chedulable with the new parametersproposed ones.

            175.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            176.         change

Inserted: ?of this scheduler?

Replaced: ?governed by the associated scheduler ? With: ?used ?

In

release - The proposed release parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)

            177.         change

Inserted: ?of this scheduler ?

Replaced: ?governed by the associated scheduler ? With: ?used ?

In

memory - The proposed memory parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)

            178.         change

Inserted: ?schedulable is null, or schedulable is not associated with this scheduler, or?

Inserted: ?proposed ?

Replaced: ?the schedulable object?s ? With: ?this ?

Deleted: ?, or if schedulable is null?

In

java.lang.IllegalArgumentException - Thrown if schedulable is null, or schedulable is not associated with this scheduler, or the proposed parameters are not compatible

with the schedulable object?s this scheduler, or if schedulable is null.

            179.         change

Deleted: ?the ?

Inserted: ?proposed ?

Replaced: ?if either ? With: ?the ?

Replaced: ?object is unable to ? With: ?objects cannot ?

IllegalAssignmentError422 - Thrown if the schedulable cannot hold references to the proposed parameter objects, or if either the parameter object is unable to objects cannot hold a reference to schedulable.

            180.         change

Inserted: java.lang.IllegalThreadStateException - Thrown if the new release parameters change schedulable from periodic scheduling to some other protocol and schedulable is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible().

setIfFeasible(schedulable, release, memory, group)

            181.         change

Replaced: ?new ReleaseParameters MemoryParameters and ProcessingGroupParameters? With: ?proposed parameter objects ?

Replaced: ?feasible the ? With: ?feasible, this ?

Replaced: ?ReleaseParameters MemoryParameters and ProcessingGroupParameters ? With: ?parameters of schedulable ?

Replaced: ?new parameters? With: ?proposed ones?

In

This method first performs a feasibility analysis using the new ReleaseParameters MemoryParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of schedulable. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters MemoryParameters and ProcessingGroupParameters parameters of schedulable with the new parametersproposed ones. 

            182.         change

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?feasible ? With: ?feasibility ?

Replaced: ?schedule ? With: ?system ?

In

This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.

            183.         change

Replaced: ?instance of Schedulable ? With: ?schedulable object ?

In

schedulable - The instance of Schedulable85 schedulable object for which the changes are proposed.

            184.         change

Inserted: ?of this scheduler ?

Replaced: ?governed by the associated scheduler ? With: ?used ?

In

release - The proposed release parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)

            185.         change

Inserted: ?of this scheduler ?

Replaced: ?governed by the associated scheduler ? With: ?used ?

In

memory - The proposed memory parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)

            186.         change

Inserted: ?of this scheduler ?

            187.         change

Replaced: ?governed by the associated scheduler ? With: ?used ?

In

group - The proposed processing group parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)

            188.         change

Inserted: ?schedulable is null, or schedulable is not associated with this scheduler, or?

Inserted: ?proposed ?

Replaced: ?the schedulable object?s ? With: ?this ?

Deleted: ?, or if schedulable is null?

In

java.lang.IllegalArgumentException - Thrown if schedulable is null, or schedulable is not associated with this scheduler, or the proposed parameters are not compatible with the schedulable object?s this scheduler, or if schedulable is null.

            189.         change

Deleted: ?the ?

Inserted: ?proposed ?

Deleted: ?if any of ?

Replaced: ?is unable to ? With: ?cannot ?

In

IllegalAssignmentError - Thrown if the schedulablecannot hold references to the proposed parameter objects, or ifany of the parameter objects is unable to cannot hold a referenceto schedulable.

            190.         change

Inserted:

java.lang.IllegalThreadStateException - Thrown if the new release parameters change schedulable from periodic scheduling to some other protocol and schedulable is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible()

 

setIfFeasible(schedulable, scheduling, release, memory, group)

            191.         change

New method

public abstract boolean setIfFeasible(javax.realtime.Schedulable schedulable,

javax.realtime.SchedulingParameters scheduling,

javax.realtime.ReleaseParameters release,

javax.realtime.MemoryParameters memory,

javax.realtime.ProcessingGroupParameters group)

This method first performs a feasibility analysis using the proposed parameter objects as replacements for the current parameters of schedulable. the resulting system is feasible, this method replaces the current parameters schedulable with the proposed ones.

 

This method does not require that the schedulable object be in the feasibility set before it is called. If it is not initially a member of the feasibility set will be added if the resulting system is feasible.

 

Parameters:

schedulable - The schedulable object for which the changes are proposed.

scheduling - The proposed scheduling parameters. If null, the default value of this scheduler is used (a new object is created the default value is not null). (See PriorityScheduler.)

release - The proposed release parameters. If null, the default value of this scheduler is used (a new object is created if the default value is not null). (See PriorityScheduler.)

memory - The proposed memory parameters. If null, the default value of this scheduler is used (a new object is created if the default value is not null). (See PriorityScheduler.)

group - The proposed processing group parameters. If null, the default value of this scheduler is used (a new object is created the default value is not null). (See PriorityScheduler.)

 

Returns: True, if the resulting system is feasible and the changes are made. False, if the resulting system is not feasible and no changes are made.

 

Throws:

java.lang.IllegalArgumentException - Thrown if schedulable is null, or schedulable is not associated with this scheduler, or the proposed parameters are not compatible with this scheduler.

IllegalAssignmentError - Thrown if schedulable cannot hold references to the proposed parameter objects, or the parameter objects cannot hold a reference to schedulable.

java.lang.IllegalThreadStateException - Thrown if the new release parameters change schedulable from periodic scheduling to some other protocol and schedulable is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible()

 

PriorityScheduler class

Description

            192.         change

Replaced: ?required priority ? With: ?base ?

In

Class which represents the required (by the RTSJ) priority-based scheduler. The default instance is the required priority base scheduler which does fixed priority, preemptive scheduling.

            193.         change

Inserted:

Note that the system contains one instance of the PriorityScheduler which is the system?s base scheduler and is returned by PriorityScheduler.instance(). It may, however, contain instances of subclasses of PriorityScheduler and even additional instances of PriorityScheduler itself created through this class? protected constructor. The instance returned by the instance() method is the base scheduler and is returned by Scheduler.getDefaultScheduler() unless the default scheduler is reset with Scheduler.setDefaultScheduler(Scheduler).

instance() method

            194.         change

Replaced: ?Return a reference to the singleton instance of PriorityScheduler.? With: ?Return a reference to the distinguished instance of PriorityScheduler which is the system?s base scheduler.?

            195.         change

Replaced: ?singleton ? With: ?distinguished ?

In

Returns: A reference to the singleton distinguished instance PriorityScheduler

isFeasible() method

            196.         change

Deleted: ?Override the isFeasible method from Scheduler providing feasibility analysis appropriate to the priority scheduler?

Replaced: ?the system ? With: ?this scheduler ?

Replaced: ?scheduling and release characteristics ? With: ?schedulable objects ?

Replaced: ?being considered.? With: ?in the feasibility set. ?

In

Override the isFeasible method from Scheduler providing feasibility analysis appropriate to the priority scheduler. Queries the system this scheduler about the feasibility of the set of scheduling and release characteristics schedulable objects currently being considered. in the feasibility set.

            197.         change

Inserted:

Implementation Notes:

The default feasibility test for the PriorityScheduler considers a set of schedulable objects with bounded resource requirements, to always be feasible. This covers all schedulable objects with release parameters of types PeriodicParameters and SporadicParameters.

 

If any schedulable object within the feasibility set has release parameters of the exact type AperiodicParameters135 (not a subclass thereof), then the feasibility set is not feasible, as aperiodic release characteristics require unbounded resources. In that case, this method will return false and all methods in the setIfFeasible family of methods will also return false. Consequently, any call to a setIfFeasible method that passes a schedulable object which has release parameters of type AperiodicParameters, or passes proposed release parameters of type AperiodicParameters, will return false. The only time a set IfFeasible method can return true, when there exists in the feasibility set a schedulable object with release parameters of type AperiodicParameters, is when the method will change those parameters to not be AperiodicParameters.

 

Implementations may provide a feasibility test other than the default just described. In which case the details of that test should be documented here in place of this description of the default implementation.

SchedulingParameters class

clone() method 

            198.         change

Inserted: ?clones of ?

            199.         change

Replaced: ?visible ? With: ?high-resolution time ?

In

Return a clone of this. This method should behave effectively as if it constructed a new object with clones of the visible high-resolution time values of this.

            200.         change

Inserted: ? The new object has clones of all high-resolution time values (deep copy).

? References to event handlers are copied (shallow copy.)?

ReleaseParameters class

Description

            201.         change

Replaced: ?The implementation may use copy semantics for each HighResolutionTime parameter value. For instance the value returned by getCost() must be equal to the value passed in by setCost, but it need not be the same object.

? With:

?Release parameters use HighResolutionTime values for cost, and deadline. Since the times are expressed as a HighResolutionTime318 values, these values use accurate timers with nanosecond granularity. The actual resolution available and even the quantity the timers measure depend on the clock associated with each time value.

 

The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained. For instance, the value returned by getCost() must be the same object passed in by setCost(), but any changes made to the time value of the cost must not take effect in the associated ReleaseParameters instance unless they are passed to the parameter object again, e.g. with a new invocation of setCost.?

Second Constructor

            202.         change

Insert: ?IllegalAssignmentError - Thrown if cost, deadline, overrunHandler, or missHandler cannot be stored in this.?

clone() method

            203.         change

Inserted: ?clones of ?

            204.         change

Replaced: ?visible ? With: ?high-resolution time ?

In

Return a clone of this. This method should behave effectively as if it constructed a new object with clones of the visible high-resolution time values of this.

            205.         change

Insert: ? The new object has clones of all high-resolution time values (deep copy).

? References to event handlers are copied (shallow copy.)?

setCost(cost) method

            206.         change

Insert: ?IllegalAssignmentError - Thrown if cost cannot be stored in this.?

setCostOverrunHandler(handler) method

            207.         change

Insert ?Throws: IllegalAssignmentError - Thrown if handler cannot be stored in this.?

setDeadline(deadline) method

            208.         change

Deleted: ?if ?

In

java.lang.IllegalArgumentException - Thrown if deadline is null, if the time value of deadline is less than or equal to zero,

or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.

            209.         change

Insert: ?IllegalAssignmentError - Thrown if deadline cannot be stored in this.?

setDeadlineMissHandler(handler) method 

            210.         change

Insert: ?Throws: IllegalAssignmentError - Thrown if handler cannot be stored in this.

setIfFeasible(cost, deadline) method

            211.         change

Insert: ?IllegalAssignmentError - Thrown if cost or deadline cannot be stored in this.?

PeriodicParameters class

Description

            212.         change

Replaced: ?The implementation may use copy semantics for each HighResolutionTime parameter value. For instance the value returned by getCost() must be equal to the value passed in by setCost, but it need not be the same object.?

With: ?Periodic parameters use HighResolutionTime values for period and startime. Since these times are expressed as a HighResolutionTime values, thesevalues use accurate timers with nanosecond granularity. The actual resolution available and even the quantity the timers measure depend on the clock associated with each time value.

The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained. For instance, the value returned by getCost() must be the same object passed in by setCost(), but any changes made to the time value of the cost must not take effect in the associated PeriodicParameters instance unless they are passed to the parameter object again, e.g. with a new invocation of setCost.?

First Constructor

            213.         change

Inserted: ?IllegalAssignmentError - Thrown if start or period cannot be stored in this.?

Second Constructor

            214.         change

Inserted: ?IllegalAssignmentError - Thrown if start period cost, deadline, overrunHandler or missHandler cannot be stored in this.?

Third Constructor

            215.         change

Inserted: ?IllegalAssignmentError - Thrown if period cannot be stored in this.?

setDeadline(deadline) method

            216.         change

Added override, replacing: ?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. The default value of the deadline must be controlled by the classes that extend ReleaseParameters.? With:

?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. If deadline is null, the deadline is set to a new instance of RelativeTime equal to period.?

            217.         change

Added override Replacing: ?java.lang.IllegalArgumentException - Thrown if deadline is null, if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?

With:

?java.lang.IllegalArgumentException - Thrown if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?

setIfFeasible(period, cost, deadline) method

            218.         change

Inserted ?IllegalAssignmentError - Thrown if period, cost or deadline cannot be stored in this.?

setStart(start) method

            219.         change

Replaced: ?Changes to the start time of a real-time thread are only effective until invocation of the start method. Changes to the start time after invocation of start are silently ignored.?

With:

?The effect of changing the start time for any schedulable objects associated with this parameter object is determined by the scheduler associated with each schedulable object.?

            220.         change

Replaced: ?start - Time at which the first release begins (i.e. the schedulable object becomes eligible for execution. If a RelativeTime, this time is relative to the first time the schedulable object becomes activated (that is, when start() is called on a real-time thread or when an associated event handler is first fired). If an AbsoluteTime, then the first release is the maximum of the start parameter and the time of the call to the associated RealtimeThread.start() method (or the first firing of an associated event). If null, the default value is a new instance of RelativeTime(0,0).?

With:

?start - The new start time. If null, the default value is a new instance of RelativeTime(0,0).?

            221.         change

Inserted: ?IllegalAssignmentError - Thrown if start cannot be stored in this.?

AperiodicParameters class

Description

            222.         change

Replaced: ?The implementation may use copy semantics for each HighResolutionTime parameter value. For instance the value returned by getCost() must be equal to the value passed in by setCost, but it need not be the same object.?

With:

?The implementation must use modified copy semantics for each HighResolutionTime318 parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained. For instance, the value returned by getCost() must be the same object passed in by setCost(), but any changes made to the time value of the cost must not take effect in the associated AperiodicParameters instance unless they are passed to the parameter object again, e.g. with a new invocation of setCost.?

Second Constructor

            223.         change

Inserted: ?IllegalAssignmentError - Thrown if cost, deadline, overrunHandler or missHandler cannot be stored in this.?

setDeadline(deadline) method

            224.         change

Added override, replacing: ?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. The default value of the deadline must be controlled by the classes that extend ReleaseParameters.? With:

?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. If deadline is null, the deadline is set to a new instance of RelativeTime(Long.MAX_VALUE, 999999).?

            225.         change

Added override Replacing: ?java.lang.IllegalArgumentException - Thrown if deadline is null, if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?

With:

?java.lang.IllegalArgumentException - Thrown if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?

setIfFeasible(cost, deadline) method

            226.         change

Replace: ?Returns: True, if the resulting system is feasible and the changes are made. False, if the resulting system is not feasible and no changes are made.?

With:

?Returns: false. Aperiodic parameters never yield a feasible system. (Subclasses of AperiodicParameters, such as SporadicParameters, need not return false.)?

            227.         change

Inserted: ?IllegalAssignmentError - Thrown if cost or deadline cannot be stored in this.?

SporadicParameters class

Description

            228.         change

Inserted: ?The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained.?

Before

Only changes to a SporadicParameters object caused by methods on that object cause the change to propagate to all schedulable objects using the parameter object.

            229.         change

In the default value table,

Replaced the default for deadline ?Long.MAX_VALUE, 999999)? With: ?mit?

 

First Constructor

            230.         change

Inserted: ?IllegalAssignmentError - Thrown if minInterarrival cannot be stored in this.?

Second Constructor

            231.         change

Replaced: ?Long.MAX_VALUE, 999999? With: ?mit?

In

deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. For a minimum implementation for purposes of feasibility analysis, the deadline is equal to the minimum interarrival interval. Other implementations may use this parameter to compute execution eligibility. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit).

 

Inserted: ?IllegalAssignmentError - Thrown if minInterarrival, cost, deadline, overrunHandler or missHandler cannot be stored in this.?

setIfFeasible(cost, deadline) method

            232.         change

added override

Replaced: ?Long.MAX_VALUE, 999999? With: ?mit?

In

deadline - The proposed deadline. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit)

setIfFeasible(interarrival, cost, deadline) method

            233.         change

Replaced: ?Long.MAX_VALUE, 999999? With: ?mit?

In

deadline - The proposed deadline. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit).

            234.         change

Inserted: ?IllegalAssignmentError - Thrown if interarrival, cost or deadline cannot be stored in this.?

setMinimumInterarrival(minimum) method

            235.         change

Inserted: ?IllegalAssignmentError - Thrown if minimum cannot be stored in this.?

ProcessingGroupParameters class

Description

            236.         change

Replaced: ?cannot measure execution time? With: ?do not support processing group parameters?

In

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. On implementations which cannot measure execution timedo not support processing group parameters, this class may be used as a hint to the feasibility algorithm.

            237.         change

Inserted: ?Processing group parameters use HighResolutionTime values for cost, deadline, period and start time. Since those times are expressed as a HighResolutionTime, the values use accurate timers with nanosecond granularity. The actual resolution available and even the quantity it measures depends on the clock associated with each time value.?

            238.         change

Inserted: ?The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained.?

Before

Only changes to a ProcessingGroupParameters object caused by methods on that object are immediately visible to the scheduler.

First Constructor

            239.         change

Inserted: ?if cost is null, ?

            240.         change

Inserted: ?if ?

            241.         change

Inserted: ?than zero and less than or equal to the period. If the implementation does not support processing

group deadline less than period, deadline less?

            242.         change

Replaced: ?zero? With: ?period will cause IllegalArgumentException to be thrown?

In

java.lang.IllegalArgumentException - Thrown if the period is null or its time value is not greater than zero, if cost is null, or if the time value of cost is less than zero, if start is an instance of RelativeTime and its value is negative, or if the time value of deadline is not greater than zero and less than or equal to the period. If the implementation does not support processing group deadline less than period, deadline less than zeroperiod will cause IllegalArgumentException to be thrown.

            243.         change

Inserted: ?IllegalAssignmentError - Thrown if start, period, cost, deadline, overrunHandler or missHandler cannot be stored in this.?

clone() method

            244.         change

Inserted: ?clones of ?

            245.         change

Replaced: ?visible ? With: ?high-resolution time ?

            246.         change

Inserted: ?The new object has clones of all high-resolution time values (deep copy).

? References to event handlers are copied (shallow copy.)?

In

Return a clone of this. This method should behave effectively as if it constructed a new object with clones of the visible high-resolution time values of this.

? The new object is in the current allocation context.

? clone does not copy any associations from this and it does not

implicitly bind the new object to a SO.

? The new object has clones of all high-resolution time values (deep copy).

? References to event handlers are copied (shallow copy.)

setCost(cost) method

            247.         change

Inserted: ?IllegalAssignmentError - Thrown if cost cannot be stored in this.?

setCostOverrunHandler(handler) method

            248.         change

Inserted: ?Throws: IllegalAssignmentError - Thrown if handler cannot be stored in this.?

setDeadline(deadline) method

            249.         change

Inserted: ?Throws:

java.lang.IllegalArgumentException - Thrown if deadline has a value less than zero or greater than the period. Unless the implementation supports deadline less than period in processing groups, IllegalArgumentException is also thrown if deadline is less than the period.

IllegalAssignmentError - Thrown if deadline cannot be stored in this.?

setDeadlineMissHandler(handler) method

            250.         change

Inserted: ?Throws:

IllegalAssignmentError - Thrown if handler cannot be stored in this.?

setIfFeasible(period, cost, deadline) method

            251.         change

Inserted: ?IllegalAssignmentError - Thrown if period cost deadline cannot be stored in this.?

setPeriod(period) method

            252.         change

Inserted: ?. If the implementation does not support processing group deadline less than period, and period is not equal to the current value of the processing group?s deadline, the deadline is set to a clone of period created in the same memory area as period.?

In

java.lang.IllegalArgumentException - Thrown if period is null, or its time value is not greater than zero. If the implementation does not support processing group deadline less than period, and period is not equal to the current value of the processing group?s deadline, the deadline is set to a clone of period created in the same memory area as period.

            253.         change

Inserted: ?IllegalAssignmentError - Thrown if period cannot be stored in this.?

setStart(start) method

            254.         change

Inserted: ?alters the value of this object?s start time property, but?

            255.         change

Inserted: ?other ?

In

Sets the value of start. If the processing group is already started this method alters the value of this object?s start time property, but has no other effect.

            256.         change

Replaced: ?java.lang.IllegalStateException ? With: ?IllegalAssignmentError ?

            257.         change

Replaced: ?the processing group is already started? With: ?start cannot be stored in this?

In

java.lang.IllegalStateException IllegalAssignmentError456 - Thrown if the processing group is already startedstart cannot be stored in this.

            258.         change

Inserted: ?java.lang.IllegalArgumentException Thrown if start is a relative time value and less than zero.?

Memory Management Chapter

Semantics and Requirements

Semantic 2

            259.         change

Replaced: ?spend ? With: ?spent ?

In

Execution time of object constructors, and time spend spent in class loading and static initialization are not governed by bounds on object allocation in this specification, but?

Semantic 3

            260.         change

Replaced: ?area ? With: ?area, m, ?

Replaced: ?the ? With: ?m.?

Inserted: ?(or another ?

Inserted: ?from the family ?

Replaced: ?the instance, the memory area? With: ?enter-like methods in MemoryArea or ScopedMemory) m?

In

A memory area is represented by an instance of a subclass of the MemoryArea class. When a memory area area, m, is entered by calling the m.enter (or another method from the family of the instance, the memory area enter-like methods in MemoryArea or ScopedMemory) m becomes the allocation context of the current schedulable object. When control returns from the enter method, the allocation context is restored to the value it had immediately before enter was called.

Semantic 5

This semantic is a modified version of what was semantic 11

            261.         change

Inserted: ?The initial allocation context for a schedulable object when it is first released, is the memory area that was designated the initial memory area when the schedulable object was constructed. This initial allocation context becomes the current allocation context for that schedulable object when the schedulable object first becomes eligible for execution. For async event handlers, the initial allocation context is the same on each release; for real-time threads, in releases subsequent to the first, the allocation context is the same as it was when the real-time thread became blocked-for-release-event.?

Semantic 6

            262.         change

Inserted: ?, but note that allocation can be performed in a specific memory area using the

newInstance and newArray methods.?

In

All object allocation through the new keyword will use the current allocation context, but note that allocation can be performed in a specific memory area using the newInstance and newArray methods.?

Deleted Semantics

The concept of ?enclosing allocation context has been replaced with a more formal model of Scope Stack. The contained semantics are relocated to the semantics in Maintaining the Scope Stack

            263.         change

Deleted:

7 The enclosing allocation context of a memory area, mem for a schedulable object, t, is the allocation context in effect for t immediately before it calls mem.enter.

8. The structure of enclosing allocation contexts, the scope stack, is accessible through a set of static methods on RealtimeThread. These methods allow outer allocation contexts to be accessed by their index number. The algorithms for maintaining the scope stack are given in ?Maintaining the Scope Stack.?

Relocated Semantics:

            264.         change

Consolidated with ?Maintaining the Scope Stack semantic 4

9. The executeInArea method may only be used on memory areas that are outer scopes on the current schedulable object?s scope stack.

New Semantics

The following semantics pertain to the scope stack

            265.         change

Inserted:

10 Schedulable objects behave as if they stored their memory area context in a structure called the scope stack. This structure is manipulated by creation of schedulable objects, and the following methods from the MemoryArea and ScopedMemory classes: all the enter and joinAndEnter methods, executeInArea, and both newInstance methods. See the semantics in Maintaining the Scope Stack for details.

            266.         change

Inserted

11. The scope stack is accessible through a set of static methods on RealtimeThread. These methods allow outer allocation contexts to be accessed by their index number. Memory areas on a scope stack may be referred to as inner or outer relative to other entries in that scope stack. An ?outer scope? is further from the current allocation context on the current scope stack and has a lower index.

            267.         change

Inserted

12. The executeInArea, newInstance and newArray methods, when invoked on an instance of ScopedMemory require that instance to be an outer allocation context on the current schedulable object?s current scope stack.

Inserted

            268.         change

13. An instance of ScopedMemory is said to be in use if it has a non-zero reference count as defined by semantic (17) below.

The Parent Scope

            269.         change

Inserted subsection. Parent Scope

Semantic 14

            270.         change

Replaced: ?If ? With: ?When ?

Inserted: ?becomes in use, its parent?

Replaced: ?in use and ? With: ?the nearest ScopedMemory object outside it on the current scope stack. If?

Replaced: ?enclosing scoped memory? With: ?outside ScopedMemory object in the current scope stack?

Deleted: ?ScopedMemory objects in this class. For all other?

Deleted: ?, the parent is the nearest ScopedMemory object outside it on the current schedulable object?s scope stack.?

In

Instances of ScopedMemory have special semantics including definition of parent. If a ScopedMemory object is not in use, it has no parent scope. If When a Scoped- Memory object becomes in use, its parent is in use and the nearest ScopedMemory object outside it on the current scope stack. If there is no enclosing scoped memoryoutside ScopedMemory object in the current scope stack, the parent is the primordial scope which is not actually a memory area, but only a marker that constrains the parentage of ScopedMemory objects in this class. For all other ScopedMemory objects, the parent is the nearest ScopedMemory object outside it on the current schedulable object?s scope stack.

Semantic 15

            271.         change

Replaced: ?are made current by entering them or passing them as the initial memory area for a new schedulable object? With: ?become in use ?

            272.         change

Replaced: ?9. ? With: ?(11.) ?

In

Instances of ScopedMemory that are made current by entering them or passing them as the initial memory area for a new schedulable object become in use must satisfy the single parent rule which requires that each scoped memory has a unique parent as defined in semantic 9. (11.)

Semantic 16

            273.         change

New semantic: ?Pushing a scoped memory onto a scope stack is always subject to the single parent rule.?

Semantic 17

            274.         change

Inserted: ?execution of ?

In

Each schedulable object has an initial memory area which is that object?s initial allocation context. The default initial memory area is the current allocation context in effect during execution of the schedulable object?s constructor, but schedulable objects may supply constructors that override the default.

Semantic 18

            275.         change

Now redundant with to Maintaining the Scope Stack semantic 2 -- deleted:

If a schedulable object, t, creates a schedulable object, nt, in a ScopedMemory object?s allocation area, nt inherits the stack of nested memory areas associated with t at the time nt is constructed including all entries from up to and including the memory area containing nt. If nt is created in heap, immortal, or immortal physical memory, nt is created with a scope stack containing only heap, immortal, or immortal physical memory respectively.

Semantic 19

            276.         change

Replaced: ?An instance of java.lang.Thread? With: ?A Java thread ?

Replaced: ?an instance of java.lang.Thread? With: ?a Java thread ?

Inserted: ?a ?

Inserted: ?area ?

In

An instance of java.lang.Thread A Java thread cannot have a scope stack; consequently it can only be created and execute within heap or immortal memory. An attempt to create an instance of java.lang.Thread a Java thread in a scoped memory area throws IllegalAssignmentError.

Semantic 20

            277.         change

Replaced: ?An instance of java....? With: ?A Java thread ?

            278.         change

Replaced: ?13? With: ?15?

In

An instance of java.lang.Thread A Java thread may use executeInArea, and the newInstance and newArray methods from the ImmortalMemory and Heap- Memory classes. These methods allow it to execute with an immortal current allocation context, but semantic (1315) applies even during execution of these methods. .

Semantic 21

            279.         change

Inserted: ?Each instance of the class ScopedMemory or its subclasses must maintain a referencecount which is greater than zero if and only if either:?

Deleted: ?Each instance of the class ScopedMemory or its subclasses must maintain a reference count which is greater than zero if and only if the?

Replaced: ?. For purposes of this semantic? With: ?; or else ?

            280.         change

Inserted:

? the scoped memory area is the initial memory area for a schedulable object. In this context, a schedulable objects ceases to be a source of a non-zero reference count on its initial memory area when either:

? the schedulable object is a RealtimeThread and it terminates; or else

? the schedulable object is de-allocated from its memory area.

For purposes of this semantic the following are treated as execution contexts:?

            281.         change

Inserted: ?been started and have ?

Deleted: ?and ?

Deleted: ?are treated as execution contexts.?

In

21. Each instance of the class ScopedMemory or its subclasses must maintain a reference

count which is greater than zero if and only if either:

? Each instance of the class ScopedMemory or its subclasses must maintain a reference count which is greater than zero if and only if the scoped memory area is the current allocation context or an outer allocation context for one or more execution contexts. For purposes of this semantic, ; or else

? the scoped memory area is the initial memory area for a schedulable object. In this context, a schedulable objects ceases to be a source of a non-zero reference count on its initial memory area when either:

? the schedulable object is a RealtimeThread and it terminates; or else

? the schedulable object is de-allocated from its memory area.

For purposes of this semantic the following are treated as execution contexts:

? RealtimeThread objects that have been started and have not terminated,

? AsyncEventHandler objects that are currently in a released state,

? AsyncEvent objects that are bound to happenings,

? Timer objects that have been started and have not been destroyed, and

? other schedulable objects that control an execution engine

Semantic 22

            282.         change

Inserted: ?still ready to be decremented to?

            283.         change

Inserted: ?then it is decremented to zero and?

In

When the reference count for an instance of the class ScopedMemory is ready to be decremented from one to zero, all unfinalized objects within that area are considered ready for finalization. If after the finalizers for all unfinalized objects in the scoped memory area run to completion, the reference count for the memory area is still ready to be decremented to zero, then it is decremented to zero and the memory scope is emptied of all objects. The RTSJ implementation must complete finalization of objects in the scope and, if the reference count is zero after finalizers run, deletion of the objects in the scope before that memory scope can again become the current allocation context for any schedulable object. (This is a special case of the finalization implementation specified in The Java Language Specification, second edition, section 12.6.1)

Semantic 27

            284.         change

Inserted: ?. Static initializers are executed executed effectively as if the current thread performed ImmortalMemory.instance().executeInArea(r) where r is a Runnable that executes the <clinit> method of the class being initialized.?

In

Class objects, the associated static memory, and interned Strings behave effectively as if they were allocated in immortal memory with respect to reference rules, assignment rules, and preemption delays by no-heap schedulable objects. Static initializers are executed effectively as if the current thread performed ImmortalMemory.instance().executeInArea(r) where r is a Runnable that executes the <clinit> method of the class being initialized.

Assignment Rule Table

            285.         change

Replaced each: ?Yes? With: ?Permit?

            286.         change

For Local Variable: Replaced ?Yes, if the reference is from the same scope, or an outer scope? with ?Permit?

            287.         change

Replaced each: ?No? With: ?Forbid?

Semantic 28

            288.         change

Replaced: ?area? With: ?are?

In

For this table, ImmortalMemory and ImmortalPhysicalMemory are equivalent, and all sub-classes of ScopedMemory area are equivalent.

Semantic 29

            289.         change

Inserted: ?Checks for operations on local variables are not required because a potentially invalid reference would be captured by the other checks before it reached a local variable.?

In

An implementation must ensure that the above checks are performed on every assignment statement before the statement is executed. (This includes the possibility of static analysis of the application logic). Checks for operations on local variables are not required because a potentially invalid reference would be captured by the other checks before it reached a local variable.

Maintaining the Scope Stack

            290.         change

Replaced: ?Five ? With: ?Four ?

            291.         change

Replaced: ?method ? With: ?methods ?

            292.         change

Replaced: ?MemoryArea? With: ?MemoryArea and ScopedMemory?

            293.         change

Deleted: ?starting a schedulable object, ?

            294.         change

Deleted: ?all ?

            295.         change

Inserted:

?1. The memory area at the top of a schedulable object?s scope stack is the schedulable object?s current allocation context.

2. When a schedulable object, t, creates a schedulable object, nt, in a ScopedMemory object?s allocation area, nt acquires a copy of the scope stack associated with t at the time nt is constructed including all entries from up to and including the memory area containing nt. If nt is created in heap, immortal, or immortal physical memory, nt is created with a scope stack containing only heap, immortal, or immortal physical memory respectively.

3. When a memory area, ma, is entered by calling a ma.enter method, ma is pushed on the scope stack and becomes the allocation context of the current schedulable object. When control returns from the enter method, the allocation context is popped from the scope stack

4. When a memory area, m, is entered by calling m?s executeInArea method or one of the m.newInstance methods the scope stack before the method call is preserved and replaced with a scope stack constructed as follows:

? If ma is a scoped memory area the new scope stack is a copy of the schedulable object?s previous scope stack up to and including ma.

? If ma is not a scoped memory area the new scope stack includes only ma.

When control returns from the executeInArea method, the scope stack is restored to the value it had before ma.executeInArea or ma.newInstance was called.?

In

Five Four operations effect the scope stack: the enter method methods in MemoryAreaMemoryArea and ScopedMemory, construction of a new schedulable object, starting a schedulable object, the executeInArea method in MemoryArea, and all the new instance methods in MemoryArea.

1. The memory area at the top of a schedulable object?s scope stack is the schedulable object?s current allocation context.

2. When a schedulable object, t, creates a schedulable object, nt, in a ScopedMemory object?s allocation area, nt acquires a copy of the scope stack associated with t at the time nt is constructed including all entries from up to and including the memory area containing nt. If nt is created in heap, immortal, or immortal physical memory, nt is created with a scope stack containing only heap, immortal, or immortal physical memory respectively.

3. When a memory area, ma, is entered by calling a ma.enter method, ma is pushed on the scope stack and becomes the allocation context of the current schedulable object. When control returns from the enter method, the allocation context is popped from the scope stack

4. When a memory area, m, is entered by calling m?s executeInArea method or one of the m.newInstance methods the scope stack before the method call is preserved and replaced with a scope stack constructed as follows:

? If ma is a scoped memory area the new scope stack is a copy of the schedulable object?s previous scope stack up to and including ma.

? If ma is not a scoped memory area the new scope stack includes only ma.

When control returns from the executeInArea method, the scope stack is restored to the value it had before ma.executeInArea or ma.newInstance was called.

Pseudocode for enter

            296.         change

Replace

For ma.enter(logic):

if entering ma would violate the single parent rule

throw ScopedCycleException

push ma on the scope stack belonging to the current

schedulable object

execute logic.run method

pop ma from the scope stack

 

With

For ma.enter(logic):

push ma on the scope stack belonging to the current

schedulable object -- which may throw

ScopedCycleException

execute logic.run method

pop ma from the scope stack

 

Construct and Start a Schedulable Object

            297.         change

Rename section to Construct a Schedulable Object

 

            298.         change

Replace

if cma is heap, immortal or ImmortalPhysicalMemory

create a new scope stack containing cma

else

start a new scope stack containing the

entire current scope stack

if ima != cma

push ima on new scope stack

which may throw ScopedCycleException

 

To start the schedulable object:

for every scoped memory area in the

schedulable object's scope stack

increment the reference count

run the new schedulable object with the

new scope stack

when the schedulable object terminates

every memory area pushed by the

schedulable object will have been popped

for every scoped memory area in the scope stack

decrement the reference count

discard the schedulable objects scope stack.

With

if cma is heap, immortal or ImmortalPhysicalMemory

create a new scope stack containing cma

else

start a new scope stack containing the

entire current scope stack

if ima != cma

push ima on new scope stack --

which may throw ScopedCycleException

 

            299.         change

Delete: ?Note that freeing and terminating a schedulable object are symmetrical to constructing and starting it except that the memory area pushed in the constructor is popped when the schedulable object terminates.?

The Single Parent Rule

            300.         change

Replaced: ?below ? With: ?outside ?

In

For all other scoped memory areas, the parent is the first scoped memory area below outside it on the scope stack. .

On Scope Stack Push of ma

            301.         change

Deleted: ?ma.refCount++?

In

precondition: ma.parent is set to the correct parent

(either a scoped memory area or the primordial scope) or to noParent

t.scopeStack is the scope stack of the current schedulable object

if ma is scoped

parent = findFirstScope(t.scopeStack)

if ma.parent == noParent

ma.parent = parent

else if ma.parent != parent

throw ScopedCycleException

else

t.scopeStack.push(ma)

ma.refCount++


On Scope Stack Pop of ma

            302.         change

Replace ?refCount == 0? With: ?!ma in use?

The Rationale

            303.         change

Deleted: ?is a stack that ?

Replaced: ?Both of those inferences are ? With: ?This is ?

Replaced: ?With executeInArea and thread creation the scope stack can easily become a tree, and although? With: ?Although ?

            304.         change

Inserted: ?. Also, although the scope stack?s behavior is specified as a stack, an implementation is free to use any data structure that preserves the stack semantics?

In

The term scope stack might mislead a reader to infer that it is a stack that contains only scoped memory areas. Both of those inferences are This is incorrect. With executeInArea and thread creation the scope stack can easily become a tree, and although Although the scope stack may contain scoped memory references, it may also contain heap and immortal memory areas. Also, although the scope stack?s behavior is specified as a stack, an implementation is free to use any data structure that preserves the stack semantics.

MemoryArea class

Second Constructor

            305.         change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules?

In

IllegalAssignmentError456 - Thrown if storing logic in this would violate the assignment rules. 

Fourth Constructor

            306.         change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules?

In

IllegalAssignmentError456 - Thrown if storing logic in this would violate the assignment rules.

enter() method

            307.         change

Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?

In

java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.

            308.         change

Inserted: ?ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.?

In

ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.

enter(logic) method

            309.         change

Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?

In

java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.

 

            310.         change

Inserted: ?ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.?

In

ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.

 

executeInArea(logic) method

            311.         change

Replaced: ?If the memory area is a scoped memory type, this method behaves as if it had moved? With: ?The effect of executeInArea on ?

Deleted: ?allocation context down the ?

Replaced: ?to ? With: ?is specified in ?

            312.         change

Replaced: ?occurrence ? With: ?subclasses ?

            313.         change

Replaced: ?the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stack? With: ?MemoryArea?

In

Execute the run method from the logic parameter using this memory area as the current allocation context. If the memory area is a scoped memory type, this method behaves as if it had moved The effect of executeInArea on the allocation context down the scope stack to is specified in the occurrence subclasses of the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stackMemoryArea.

            314.         change

Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack?

newArray(type, number) method

            315.         change

Inserted: ?. To create an array of a primitive type use a type such as Integer?

            316.         change

Inserted: ?(which would call for an array of the primitive int type.)?

In

type - The class of the elements of the new array. To create an array of a primitive type use a type such as Integer.TYPE (which would call for an array of the primitive int type.)

            317.         change

Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack.?

newInstance(type) method

            318.         change

Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack.?

newInstance(c, args) method

            319.         change

Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack.?

HeapMemory class

executeInArea(logic) method

            320.         change

Insert method override:

Giving

 

public void executeInArea(java.lang.Runnable logic)

Execute the run method from the logic parameter using heap as the current allocation context. For a schedulable object, this saves the current scope stack and replaces it with one consisting only of the HeapMemory instance; restoring the original scope stack upon completion.

 

Overrides: executeInArea in class MemoryArea

 

Parameters:

logic - The runnable object whose run() method should be executed.

 

Throws:

java.lang.IllegalArgumentException - Thrown if logic is null.

ImmortalMemory class

executeInArea(logic) method

            321.         change

Insert method override

Giving

public void executeInArea(java.lang.Runnable logic)

Execute the run method from the logic parameter using this memory area as the current allocation context. For a schedulable object, this saves the

current scope stack and replaces it with one consisting only of the ImmortalMemory instance; restoring the original scope stack upon completion.

 

Overrides: executeInArea in class MemoryArea

 

Parameters:

logic - The runnable object whose run() method should be executed.

 

Throws:

java.lang.IllegalArgumentException - Thrown if logic is null.

 

SizeEstimator class

reserveArray(length) method

            322.         change

Inserted: ?Throws: java.lang.IllegalArgumentException - Thrown if length is negative.?

reserveArray(length, type) method

            323.         change

Inserted: ?length is negative or ?

In

Throws:

java.lang.IllegalArgumentException - Thrown if length is negative or type does not represent a primitive type.

ScopedMemory class

Description

            324.         change

Deleted: ?When logic.run() is complete, the scoped memory area is no longer active, and its reference count will be decremented.?

Second Constructor

            325.         change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Fourth Constructor

            326.         change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

enter() method

            327.         change

Replaced: ?when enter ? With: ?if the caller ?

            328.         change

Deleted: ?invoked from ?

In

java.lang.IllegalThreadStateException - Thrown when enter if the caller is invoked from a Java thread.

enter(logic) method

            329.         change

Replaced: ?when enter ? With: ?if the caller ?

            330.         change

Deleted: ?invoked from ?

In

java.lang.IllegalThreadStateException - Thrown when enter if the caller is invoked from a Java thread.

executeInArea(logic) method

            331.         change

Deleted: ?Description copied from class: : javax.realtime.MemoryArea?

            332.         change

Replaced: ?If the memory area is a scoped memory type, this? With: ?This ?

            333.         change

Replaced: ?had moved ? With: ?moves ?

            334.         change

Replaced: ?the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stack? With: ?this?

In

Description copied from class: javax.realtime.MemoryArea

Execute the run method from the logic parameter using this memory area as the current allocation context. If the memory area is a scoped memory type, this This method behaves as if it had moved moves the allocation context down the scope stack to the occurrence of the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stackthis.

            335.         change

Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?

In

java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.

getPortal() method

            336.         change

Replaced: ?the value from the portal is to an object in a scope that? With: ?this ?

IllegalAssignmentError - Thrown if a reference to the portal object cannot be stored in the caller?s allocation context; that is, if the value from the portal is to an object in a scope that this is ?inner? relative to the current allocation context.

            337.         change

Inserted: ?java.lang.IllegalThreadStateException - Thrown if the caller is a Java thread.?

join(time) method

            338.         change

Inserted: ?Since the time is expressed as a HighResolutionTime , this method is an accurate timer with nanosecond granularity. The actual resolution of the timer and even the quantity it measures depends on the clock associated with time. The delay time may be relative or absolute. If relative, then the delay is the amount of time given by time, and measured by its associated clock. If absolute, then the delay is until the indicated value is reached by the clock. If the given absolute time is less than or equal to the current value of the clock, the call to join returns immediately.?

            339.         change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?

joinAndEnter() method

            340.         change

Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.

Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?

joinAndEnter(time) method

            341.         change

Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.

 

Since the time is expressed as a HighResolutionTime, this method has an accurate timer with nanosecond granularity. The actual resolution of the timer and even the quantity it measures depends on the clock associated with time. The delay time may be relative or absolute. If relative, then the calling thread is blocked for at most the amount of time given by time, and measured by its associated clock. If absolute, then the time delay is until the indicated value is reached by the clock. If the given absolute time is less than or equal to the current value of the clock, the call to joinAndEnter returns immediately.

 

Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.? 

            342.         change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?

joinAndEnter(logic) method

            343.         change

Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.

 

Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?

joinAndEnter(logic, time) method

            344.         change

Inserted: ?Since the time is expressed as a HighResolutionTime , this method is an accurate timer with nanosecond granularity. The actual resolution of the timer and even the quantity it measures depends on the clock associated with time. The delay time may be relative or absolute. If relative, then the delay is the amount of time given by time, and measured by its associated clock. If absolute, then the delay is until the indicated value is reached by the clock. If the given absolute time is less than or equal to the current value of the clock, the call to join returns immediately.? 

            345.         change

Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.?

 

Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?

            346.         change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?

newArray(type, number) method

            347.         change

Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?

In

java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.

newInstance(type) method

            348.         change

Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?

In

java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.

newInstance(c, args) method

            349.         change

Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?

In

java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.

setPortal(object) method

            350.         change

Inserted: ?IllegalThreadStateException is thrown when called by a Java thread even when the invocation could also throw IllegalArgumentException.?

            351.         change

Replaced: ?the ? With: ?this ?

In

InaccessibleAreaException - Thrown if the this memory area is not in the caller?s scope stack.

LTMemory class

Third Constructor

            352.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Fourth Constructor

            353.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Sixth Constructor

            354.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Eighth Constructor

            355.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

VTMemory class

Description

            356.       change

Replaced: ?VTMemory? With: ?LTMemory?

In

VTMemory is similar to VTMemoryLTMemory except that the execution time of an allocation from a VTMemory area need not complete in linear time.

Third Constructor

            357.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Fourth Constructor

            358.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Sixth Constructor

            359.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Eighth Constructor

            360.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

PhysicalMemoryManager class

Description

            361.       change

Replaced: ?The base implementation will provide a PhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes that correctly identify memory classes that are standard for the (OS, JVM, and processor) platform.?

With: ?The base implementation will provide a PhysicalMemoryManager.?

onRemoval(base, size, ae) method

            362.       change

Replaced: ?aysnc ? With: ?async ?

In

ae - The aysnc async event to register.

PhysicalMemoryTypeFilter class

onRemoval(base, size, ae) method

            363.       change

Replaced: ?aysnc ? With: ?async ?

In

ae - The aysnc async event to register.

ImmortalPhysicalMemory class

Third Constructor

            364.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Fourth Constructor

            365.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Sixth Constructor

            366.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Eighth Constructor

            367.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

LTPhysicalMemory class

Third Constructor

            368.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Fourth Constructor

            369.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Sixth Constructor

            370.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Eighth Constructor

            371.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

VTPhysicalMemory class

Third Constructor

            372.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Fourth Constructor

            373.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Sixth Constructor

            374.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

Eighth Constructor

            375.       change

Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?

RawMemoryAccess class

getByte(offset) method

            376.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getBytes(offset, bytes, low, number) method

            377.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getInt(offset) method

            378.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getInts(offset, ints, low, number) method

            379.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getLong(offset) method

            380.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getLongs(offset, longs, low, number) method

            381.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getShort(offset) method

            382.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getShorts(offset, shorts, low, number) method

            383.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setByte(offset, value) method

            384.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setBytes(offset, bytes, low, number) method

            385.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setInt(offset, value) method

            386.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setInts(offset, ints, low, number) method

            387.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setLong(offset. value) method

            388.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setLongs(offset, longs, low, number) method

            389.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setShort(offset, value) method

            390.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setShorts(offset, shorts, low, number) method

            391.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

unmap() method

            392.       change

Replaced: ?block until one load or store completes? With: ?throw an IllegalStateException?

Replaced: ?It ? With: ?The unmap method ?

In

If an unmap is requested while another schedulable object is accessing the raw memory, the unmap will block until one load or store completesthrow an IllegalStateException. It The unmap method can interrupt an array operation between entries.

RawMemoryFloatAccess class

getDouble(offset) method

            393.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getDoubles(offset, doubles, low, number) method

            394.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getFloat(offset) method

            395.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

getFloats(offset, floats, low, number) method

            396.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setDouble(offset, value) method

            397.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setDoubles(offset, doubles, low, number) method

            398.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setFloat(offset, value) method

            399.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

setFloats(offset, floats, low, number) method

            400.       change

Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?

MemoryParameters class

Second Constructor

            401.       change

Replaced: ?allocationrate ? With: ?allocationRate ?

In

allocationRate - A limit on the rate of allocation in the heap. Units are in bytes per second of wall clock time. If allocationrate allocationRate is zero, no allocation is allowed in the heap.

Synchronization chapter

            402.       change

Replaced: ?default ? With: ?base ?

In

The classes in this section establish a framework for priority inversion management that applies to priority-oriented schedulers in general, and a specific set of requirements for the default base priority scheduler.

Semantics and Requirements section

Semantics for the Default Priority Scheduler subsection

            403.       change

In the subsection title

Replaced: ?Default ? With: ?Base ?

            404.       change

Replaced: ?default ? With: ?base ?

In

The following list defines the main terms and establishes the general semantics and requirements that apply to threads and schedulable objects managed by the default base priority scheduler when they synchronize on objects governed by monitor control policies defined in this section.

            405.       change

Inserted: ?A thread or schedulable object that holds a lock on a PCE-governed object also has a ceiling priority.?

In

1. Each thread or schedulable object has a base priority and an active priority. A thread or schedulable object that holds a lock on a PCE-governed object also has a ceiling priority.

            406.       change

Deleted: ?an instance of ?

In

? t.setPriority(prio)

if t is an instance of java.lang.Thread the new base priority is the lesser of prio, Thread.MAX_PRIORITY, and the maximum priority for t?s thread group. If t is an instance of a schedulable object, the new base priority is prio.

            407.       change

Inserted: ?modification of the priority of the priority of t through?

In

3. When t does not hold any locks, its active priority is the same as its base priority. In such a situation modification of the priority of t through an invocation of any of the above priority-setting methods for t causes t to be placed at the tail of its relevant queue (ready, blocked on a particular object, etc.) at its new priority.

            408.       change

Replaced: ?for ? With: ?resulting from ?

Replaced: ?section ? With: ?section, ?

Replaced: ?entity t ? With: ?object t, ?

In

4. When t holds one or more locks, then t has a set of priority sources. The active priority for t at any point in time is the maximum of the priorities associated with all of these sources. The priority sources for resulting from the monitor control policies defined in this section section, and their associated priorities for a schedulable entity t object t, are as follows:

            409.       change

Inserted: ?either synchronously or ?

In

Note: This may have been changed (either synchronously or asynchronously) while t has been holding its lock(s).

            410.       change

Replaced: ?the active ? With: ?a ?

Replaced: ?t (see ? With: ?t. This value is ...?

Replaced: ?description of the setMonitorControl instance method?

With: ?ceiling priority ?

Replaced: ?a definition of ?active monitor control policy? With: ?t?

Deleted: ??)?

In

Associated priority: The maximum value ceil such that ceil is the ceiling for the active a PriorityCeilingEmulation policy governing an object locked by t (see t. This value is also referred to as the description of the setMonitorControl instance method ceiling priority for a definition of ?active monitor control policyt.?)

            411.       change

Inserted: ?Source: Each thread or schedulable object that is attempting to synchronize on an object locked by t and governed by a PriorityCeilingEmulation policy.

Associated priority: The maximum active priority over all such threads and schedulable objects

Note: This rule, which in effect allows a PriorityCeilingEmulation lock to behave like a PriorityInheritance lock, helps avoid unbounded priority inversions that could otherwise occur in the presence of nested synchronizations involving a mix of PriorityCeilingEmulation and Priority-Inheritance policies. ?

            412.       change

Replaced: ?should ? With: ?must ?

            413.       change

Inserted: ?, if the implementation is supporting PriorityCeilingEmulation. If the implementation is not supporting PriorityCeilingEmulation then t should be placed at the head of the ready queue at its new active priority?

Inserted: ?If the implementation is not supported?

Replaced: ?In any event ? With: ?If PriorityCeilingEmulation is not supported,?

Inserted: ?queue placement ?

            414.       change

Replaced: ?preferred. ? With: ?recommended.?

In

6. The removal of a priority source for t either leaves t?s active priority unchanged, or decreases it. If t?s active priority is unchanged, then t?s status in its relevant queue (e.g. blocked waiting for some object) is not affected. If t?s active priority is decreased and t is either ready or running, then t should must be placed at the head of the ready queue at its new active priority level, if the implementation is supporting PriorityCeilingEmulation. If the implementation is not supporting PriorityCeilingEmulation then t should be placed at the head of the ready queue at its new active priority (Note the ?should?: this behavior is optional.) In  any event If PriorityCeilingEmulation is not supported, the implementation must document the queue placement effect. If t?s active priority is decreased and

t is blocked, then t is placed in the corresponding queue at its new active priority level. Its position in the queue is implementation defined, but placement at the tail is preferred. recommended.

            415.       change

Replaced: ?5? With: ?4?

            416.       change

Replaced: ?5? With: ?4.a, 4?

            417.       change

Replaced: ?a ? With: ?c ?

            418.       change

Replaced: ?5? With: ?4?

            419.       change

Replaced: ?c ? With: ?d ?

In

? A thread or schedulable object t?s priority sources from 54.b are added and removed synchronously; i.e., they are established based on t?s entering or leaving synchronized code. However, priority sources from 54.a, 4.a c and 54.c d may be added and removed asynchronously, as an effect of actions by other threads or schedulable objects. .

            420.       change

Replaced: ?It is a consequence of other rules that if a thread or schedulable object t holds a PriorityCeilingEmulation lock, then it will not inherit a priority, nor have a new priority assigned, that exceeds the lock?s ceiling. Unless otherwise stated, the unqualified term ?priority? hereafter means ?active priority? rather than ?base priority?.?

With: ?It is a consequence of other rules that, when a thread or schedulable object t attempts to synchronize on an object obj governed by a PriorityCeilingEmulation policy with ceiling ceil, then t?s active priority may exceed ceil but t?s base priority must not. In contrast, once t has successfully synchronized on obj then t?s base priority may also exceed obj?s monitor control policy?s ceiling. Note that t?s base priority and/or obj?s monitor control policy may have been dynamically modified.?

            421.       change

Replaced: ?default ? With: ?base ?

In:

The following list establishes the semantics and requirements that apply to threads or schedulable objects managed by a scheduler other than the default base priority scheduler when they synchronize on objects with monitor control policies defined in this section.

Rationale

            422.       change

Replaced: ?priority inversions ? With: ?dependencies ?

Replaced: ?result (to prevent heap corruption when the garbage collector has been preempted) when the object is governed by PriorityInheritance? With: ?result?

In

Since the same object may be accessed from synchronized code by both a NoHeapRealtimeThread and an arbitrary thread or schedulable object, unwanted priority inversions dependencies may result (to prevent heap corruption when the garbage collector has been preempted) when the object is governed by PriorityInheritanceresult. To avoid this problem, this specification provides three wait-free queue classes as an alternative means for safe, concurrent data accesses without priority inversion.

MonitorControl class

getMonitorControl(obj) method

            423.       change

Deleted: ?base ?

In

Returns: The base monitor control policy of the obj parameter.

            424.       change

Replaced: ?monitor ? With: ?obj ?

In

java.lang.IllegalArgumentException - Thrown if monitor obj is null.

setMonitorControl(policy) method

            425.       change

Replaced: ?Unlike ? With: ?Like ?

In

Unlike Like the per-object method (see setMonitorControl(Object, MonitorControl)289 , the setting of the default monitor control policy occurs immediately.

            426.       change

Replaced: ?SecurityException ? With: ?IllegalArgumentException ?

Replaced: ?the caller ? With: ?policy ?

Replaced: ?permitted to alter the default monitor control policy? With: ?in immortal memory?

In

java.lang.SecurityException IllegalArgumentException - Thrown if the caller policy is not permitted to alter the default monitor control policyin immortal memory.

            427.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if policy is not a supported monitor control policy.?

setMonitorControl(obj, policy) method

            428.       change

Replaced: ?Sets policy as the base monitor control policy for obj. The base policy becomes the active monitor control policy when obj is in the unlocked state and has an empty wait set. Since the behavior of a monitor is defined by its active policy, these rules guarantee that the behavior is not modified dynamically while the monitor is still locked, even if this method is called by the thread or schedulable object that currently is synchronized on obj. Unless otherwise noted, the term ?monitor control policy for object obj? means obj?s active rather than base policy.?

With: ?Immediately sets policy as the monitor control policy for obj.

A thread or schedulable object that is queued for the lock associated with obj, or is in obj?s wait set, is not rechecked (e.g., for a CeilingViolationException) under policy, either as part of the execution of setMonitorControl or when it is awakened to (re)acquire the lock. The thread or schedulable object invoking setMonitorControl must already hold the lock on obj.?

            429.       change

Deleted: ?active ?

In

Returns: The current active MonitorControl policy for obj, which will be replaced.

            430.       change

Deleted: ?java.lang.IllegalArgumentException - Thrown when monitor is null.?

            431.       change

Inserted: ?java.lang.IllegalArgumentException - Thrown when obj is null or policy is not in immortal memory.?

            432.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if policy is not a supported monitor control policy.?

            433.       change

Inserted: ?java.lang.IllegalMonitorStateException - Thrown if the caller does not hold a lock on obj.?

 

PriorityCeilingEmulation class

Description section

            434.       change

Inserted: ?In order for this protocol to have the desired effect in terms of avoiding unbounded priority inversions and preventing deadlock, the implementation must perform the following checks when a thread or schedulable object t attempts to synchronize on a target object governed by a PriorityCeilingEmulation policy with ceiling ceil:

? t?s base priority does not exceed ceil

? t?s ceiling priority (if t is holding any other PriorityCeilingEmulation locks) does not exceed ceil.?

Deleted: ?In order for this protocol to have the desired effect in terms of controlling priority inversions, the active priority of a thread or schedulable object attempting to synchronize on, or already synchronized on, a target object governed by a PriorityCeilingEmulation policy, must not exceed that policy?s ceiling.?

            435.       change

Replaced: ?setMonitorControl(? With: ?MonitorControl.setMonitorControl(Object, MonitorControl?

Replaced: ?highest active priority ? With: ?maximum ?

Replaced: ?any thread or schedulable object that could synchronize on targetObj.?

With: ?the following values:

? the highest base priority of any thread or schedulable object that could synchronize on targetObj

? the maximum ceiling priority value that any thread or schedulable object could have when it attempts to synchronize on targetObj.?

In

Thus for any object targetObj that will be governed by priority ceiling emulation, the programmer needs to provide (via setMonitorControlMonitorControl.setMonitorControl(Object, MonitorControl)) a PriorityCeilingEmulation policy whose ceiling is at least as high as the highest active priority maximum of any thread or schedulable object that could synchronize on targetObj. the following values:

? the highest base priority of any thread or schedulable object that could synchronize on targetObj

? the maximum ceiling priority value that any thread or schedulable object could have when it attempts to synchronize on targetObj.

            436.       change

Deleted: ?If a thread or schedulable object t whose active priority is p1 attempts to synchronize on an object governed by a PriorityCeilingEmulation policy with ceiling p2, where p1>p2, then a CeilingViolationException is thrown in t. Further, if a thread or schedulable object t2 is synchronized on an object governed by a PriorityCeilingEmulation policy with ceiling p2, and is also synchronized on an object obj governed by a PriorityInheritance policy, then if some other thread or schedulable object t1 whose active priority p1 exceeds p2 attempts to synchronize on obj, then a CeilingViolationException is thrown in t1 (and thus t2?s active priority remains at the ceiling value p2).?

            437.       change

Replaced: ?t1 ? With: ?t whose base priority is p1?

Replaced: ?set the priority of a thread or schedulable object t2 to a value p1, while t2 holds a lock? With: ?synchronize ?

Replaced: ?t1? With: ?t?

Replaced: ?(See the rules ? With: ?A CeilingViolationException is likewise thrown ?

Replaced: ?the Semantics ? With: ?t if t is holding a PriorityCeilingEmulation lock?

Replaced: ?Requirements section in this chapter for the list of the three priority-setting methods.)? With: ?has a ceiling priority exceeding p1?

In

? If a thread or schedulable object t1 t whose base priority is p1 attempts to set the priority of a thread or schedulable object t2 to a value p1, while t2 holds a lock

synchronize on an object governed by a PriorityCeilingEmulation policy with ceiling p2, where p1>p2, then a CeilingViolationException is thrown in t1t. (See the rules A CeilingViolationException is likewise thrown in the Semantics t if t is holding a PriorityCeilingEmulation lock and Requirements section in this chapter for the list of the three priority-setting methods.) has a ceiling priority exceeding p2.

            438.       change

Inserted: ?A consequence of the above rule is that a thread or schedulable object may nest synchronizations on PriorityCeilingEmulation-governed objects as long as the ceiling for the inner lock is not less than the ceiling for the outer lock. The possibility of nested synchronizations on objects governed by a mix of PriorityInheritance and PriorityCeilingEmulation policies requires one other piece of behavior in order to avoid unbounded priority inversions. If a thread or schedulable object holds a PriorityInheritance lock, then any PriorityCeilingEmulation lock that it either holds or attempts to acquire will exhibit priority inheritance characteristics. This rule is captured above in the definition of priority sources (4.d).?

 

Deleted: ?This invocation sets obj? obj?s base policy, which becomes the active policy when obj is unlocked and has an empty wait set. (See class MonitorControl).?

Deleted: ?Note that when defining the ceiling for a given object obj, the programmer cannot simply use the maximum of the base priorities of all threads and schedulable objects that could lock obj; the active priorities of such threads and schedulable objects — in particular the inheritance of priority from other threads and schedulable objects — needs to be taken into account.?

getMaxCeiling() method

            439.       change

Deleted: ?with ?

In

All invocations with of this method return a reference to the same object.

PriorityInheritance class

instance() method

            440.       change

Replaced: ?Note: The PriorityInheritance shall be allocated in memory (e.g., immortal memory) that is unexceptionally referenceable from every execution context; most significantly heap and non-heap.?

With: ?The PriorityInheritance instance shall be allocated in ImmortalMemory.?

WaitFreeWriteQueue class

Description section

            441.       change

Deleted (actually moved down): ?WaitFreeWriteQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management. ?

            442.       change

Inserted: ?A queue that can be non-blocking for producers.?

In

A queue that can be non-blocking for producers. The WaitFreeWriteQueue class is intended for single-writer multiple-reader communication, although it may also be used (with care) for multiple writers.

            443.       change

Inserted (actually moved from above): ?WaitFreeWriteQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?

 

Third Constructor

            444.       change

Inserted: ?and both Runnables are non-null?

            445.       change

Replaced: ?find a ? With: ?select the nearest common scoped parent?

Replaced: ?area that ? With: ?area, or if there ?

Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?

Replaced: ?queues ? With: ?queue ?

In

The writer and reader parameters, if non-null, are checked to insure that they are compatible with the MemoryArea specified by memory (if non-null.)

If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queues queue will be allocated in immortal memory.

            446.       change

Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?

force(object) method

            447.       change

Replaced: ?MemoryScopeException - Thrown if a memory access error occurs.?

With:

?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?

read() method

            448.       change

Replaced: ?read ? With: ?thread ?

            449.       change

Replaced: ?AIE? With: ?AsynchronouslyInterruptedException?

Inserted: ? during the time between calling this method and returning from it?

In

java.lang.InterruptedException - Thrown if the read thread is interrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.

 

write() method

            450.       change

Replaced: ?MemoryScopeException - Thrown if a memory access error occurs.?

With: ?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?

WaitFreeReadQueue class

Description section

            451.       change

Deleted (actually moved): ?WaitFreeReadQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?

            452.       change

Inserted: ?A queue that can be non-blocking for consumers.?

In:

A queue that can be non-blocking for consumers. The WaitFreeReadQueue class is intended for single-reader multiple-writer communication, although it may also be used (with care) for multiple readers

            453.       change

Inserted (actually moved): ?WaitFreeReadQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?

Third Constructor

            454.       change

Changed the type of the reader and writer arguments from Thread to Runnable.

            455.       change

Inserted: ?and both Runnables are non-null,?

            456.       change

Replaced: ?find a ? With: ?select the nearest common scoped parent?

Replaced: ?area that ? With: ?area, or if there ?

Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?

In

If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queue will be allocated in immortal memory.

            457.       change

Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?

Fourth Constructor

            458.       change

Changed the type of the reader and writer arguments from Thread to Runnable

            459.       change

Inserted: ?and both Runnables are non-null?

            460.       change

Replaced: ?find a ? With: ?select the nearest common scoped parent?

Replaced: ?area that ? With: ?area, or if there ?

Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?

In

The writer and reader parameters, if non-null, are checked to insure that they are compatible with the MemoryArea specified by memory (if non-null.)

If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queue will be allocated in immortal memory.

            461.       change

Replaced: ?If ? With: ?Thrown if ?

In

java.lang.IllegalArgumentException - If Thrown if an argument holds an invalid value.

            462.       change

Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?

waitForData() method

            463.       change

Replaced: ?method ? With: ?thread ?

            464.       change

Replaced: ?AIE? With: ?AsynchronouslyInterruptedException?

            465.       change

Inserted: ? during the time between calling this method and returning from it.?

In

java.lang.InterruptedException - Thrown if the method thread is interrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.

write(object) method

            466.       change

Replaced: ?write ? With: ?thread ?

            467.       change

Replaced: ?AIE? With: ?AsynchronouslyInterruptedException?

            468.       change

Inserted: ? during the time between calling this method and returning from it?

In

java.lang.InterruptedException - Thrown if the write thread is interrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.

            469.       change

Inserted: ?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?

WaitFreeDequeue class

Description section

            470.       change

Deleted (actually moved): ?WaitFreeDequeue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?

 

Inserted (actually moved): ?WaitFreeDequeue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?

Constructor

            471.       change

Changed the type of the writer and reader arguments from Thread to Runnable

            472.       change

Inserted: ?and both Runnables are non...?

Replaced: ?find a ? With: ?select the nearest common scoped parent?

Replaced: ?area that ? With: ?area, or if there ?

Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?

In

The writer and reader parameters, if non-null, are checked to insure that they are compatible with the MemoryArea specified by memory (if nonnull.)

If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queue will be allocated in immortal memory.

            473.       change

Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?

blockingRead() method

            474.       change

Added ?throws InterruptedException?

            475.       change

Inserted: ?java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?

            476.       change

Deleted: ?MemoryScopeException - Thrown if the memory area containing the queues is incompatible with the current context.?

blockingWrite(object) method

            477.       change

Added ?throws InterruptedException?

            478.       change

Replaced: ?MemoryScopeException - If the write causes an access or assignment violation.?

With:  ?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?

            479.       change

Inserted: ?java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?

force(object) method

            480.       change

Inserted: ?Throws:

MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?

nonBlockingRead() method

            481.       change

Replaced: ?MemoryScopeException - If the write causes an access or assignment violation.?

With:

?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?

Time Chapter

Definitions section

            482.       change

Replace: ?The following terms and abbreviations will be used:

A time object is an instance of AbsoluteTime, RelativeTime, or RationalTime.

A time object is always associated with a clock. By default it is associated with the real-time clock.

The Epoch is the standard base time, conventionally January 1 00:00:00 GMT 1970. It is the point from which the real-time clock measures absolute time.

The time value representation is a compound format composed of 64 bits of millisecond timing, and 32 bits of nanoseconds within a millisecond. The millisecond constituent uses the 64 bits of a Java long while the nanosecond constituent uses the

The normalized (canonical) form for time objects uniquely specifies the values for the millisecond and nanosecond components of a point in time, including the case of 0 milliseconds or 0 nanoseconds, and a negative time value, according to the following three rules:?

With:

?The following terms and abbreviations will be used:

A time object is an instance of AbsoluteTime, RelativeTime, or RationalTime.

A time object is always associated with a clock. By default it is associated with the real-time clock.

The Epoch is the standard base time, conventionally January 1 00:00:00 GMT 1970. It is the point from which the real-time clock measures absolute time.

The time value representation is a compound format composed of 64 bits of millisecond timing, and 32 bits of nanoseconds within a millisecond. The millisecond constituent uses the 64 bits of a Java long while the nanosecond constituent uses the 32 bits of a Java int.

The normalized (canonical) form for time objects uniquely specifies the values for the millisecond and nanosecond components of a point in time, including the case of 0 milliseconds or 0 nanoseconds, and a negative time value, according to the following three rules:?

            483.       change

Inserted: ?Operations are executed using the appropriate arithmetic precision.?

            484.       change

Replaced: ?the ? With: ?an ?

In:

b. Normalization is also performed on the result of operations by methods that perform time object addition and subtraction. Operations are executed using the appropriate arithmetic precision. If the final result of the an operation can be represented in normalized form, then the operation must not throw arithmetic exceptions while producing intermediate results.

HighResolutionTime Class

equals(time) method

            485.       change

Replaced: ? Equality includes clock association? With: ?Equality includes clock association. ?

equals(object) method

            486.       change

Replaced: ? Equality includes clock association? With: ?Equality includes clock association. ?

set(time) method

            487.       change

Inserted: ?time parameter is null this method will throw IllegalArgumentException. If the?

            488.       change

Replaced: ?This method ignores the possible discrepancy between the? With: ?The ?

Replaced: ?and ? With: ?is set to be ?

Deleted: ?, retaining the original clock clock association with this?

In:

Change the value represented by this to that of the given time. If the time parameter is null this method will throw IllegalArgumentException. If the type of this and the type of the given time are not the same this method will throw ClassCastException. This method ignores the possible discrepancy between the The clock associated with this and is set to be the clock associated with the time parameter, retaining the original clock association with this.

            489.       change

Inserted: ?java.lang. IllegalArgumentException - Thrown the parameter time is null.

waitForObject(target, time) method

            490.       change

Inserted: ?As for target.wait(), there is the possibility of spurious wakeup behavior.

The wait time may be relative or absolute, and it is controlled by the clock associated with it. If the wait time is relative, then the calling thread is blocked waiting on target for the amount of time given by time, and measured by the associated clock. If the wait time is absolute, then the calling thread is blocked waiting on target until the indicated time value is reached by the associated clock.?

            491.       change

Replaced: ?

java.lang.InterruptedException - Thrown if another thread or AIE.fire() interrupts this thread while it is waiting.

With:

java.lang.InterruptedException - Thrown if this schedulable object is interrupted by RealtimeThread.interrupt() or AsynchronouslyInterruptedException.fire() while it is waiting.?

            492.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?

AbsoluteTime class

AbsoluteTime() constructor

            493.       change

Deleted: ?The clock association is implicitly made with the real-time clock.

Equivalent to new AbsoluteTime(0,0).?

add(millis, nanos) method

            494.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

The result will have the same clock association as this. An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            495.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

add(millis, nanos, dest) method

            496.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

The result will have the same clock association as this, and the clock association with dest is ignored. An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            497.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

add(time) method

            498.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An IllegalArgumentException is thrown if the time parameter is null. An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            499.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

add(time, dest) method

            500.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            501.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

relative(clock) method

            502.       change

Replaced: ?computation of ? With: ?the result does not fit in?

Replaced: ?relative time gives an overflow after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if computation of the result does not fit in the relative time gives an overflow after normalizationnormalized format.

relative(clock, dest) method

            503.       change

Replaced: ?computation of ? With: ?the result does not fit in?

Replaced: ?relative time gives an overflow after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if computation of the result does not fit in the relative time gives an overflow after normalizationnormalized format.

set(date) method

            504.       change

Replaced: ?UnsupportedOperationException ? With: ?IllegalArgumentException ?

Inserted: ?parameter date is null. The?

Replaced: ?associated ? With: ?association is implicitly made?

Deleted: ?this does not have ?

Replaced: ?concept of date? With: ?real-time clock?

In

An UnsupportedOperationException Illegal- ArgumentException is thrown if the parameter date is null. The clock associated association is implicitly made with this does not have the concept of datereal-time clock.

            505.       change

Deleted: ?UnsupportedOperationException Thrown if the clock associated with this does not have the concept of date?

            506.       change

Inserted: ?IllegalArgumentException Thrown if the parameter date is null?

subtract(abstime) method

            507.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            508.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

subtract(time, dest) method

            509.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            510.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

subtract(reltime) method

            511.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            512.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

subtract(reltime, dest) method

            513.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            514.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

toString() method

            515.       change

Replaced: ?reprepresentation ? With: ?representation ?

In

The string shall be a decimal reprepresentation representation of the milliseconds and nanosecond values; formatted as follows ?(2251 ms, 750000 ns)?

RelativeTime class

Description section

            516.       change

Deleted: ?Although logically, and correctly, this may represent time before the epoch, an instance of RelativeTime representing time before the epoch may cause some methods to throw an IllegalArgumentException?

From

A negative interval relative to now represents time in the past. Although logically, and correctly, this may represent time before the epoch, an instance of RelativeTime representing time before the epoch may cause some methods to throw an IllegalArgumentException. For add and subtract negative values behave as they do in arithmetic.

absolute(clock) method

            517.       change

Inserted: ?Throws:

java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.?

absolute(clock, dest) method

            518.       change

Inserted: ?Throws:

java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.

add(millis, nanos) method

            519.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            520.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

add(millis, nanos, dest) method

            521.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            522.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

add(reltime) method

            523.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            524.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

add(reltime, dest) method

            525.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            526.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

subtract(time) method

            527.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            528.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

subtract(time, dest) method

            529.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

            530.       change

Replaced: ?there is an overflow ? With: ?the result does not fit ?

Replaced: ?result after normalization? With: ?normalized format?

In

java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.

toString()

            531.       change

Replaced: ?reprepresentation ? With: ?representation ?

In

The string shall be a decimal reprepresentation representation of the milliseconds and nanosecond values; formatted as follows ?(2251 ms, 750000 ns)?

RationalTime class

Description section

            532.       change

Deleted: ?If the value of any of the millisecond or nanosecond fields is negative the variable is set to negative value. Although logically this may represent time before the epoch, invalid results may occur if an instance of AbsoluteTime representing time before the epoch is given as a parameter to the a method.?

Clocks and Timers Chapter

Definitions section

            533.       change

Replace: ?The counting time is the time accumulated while active by a Timer whose initial firing time has been specified as a RelativeTime. The counting time is zeroed at the occurrence of any firing or skipping.

NOTE: A PeriodicTimer whose initial firing has been specified as an AbsoluteTime self-reschedules in an absolute manner, even if the interval or period is always specified as a RelativeTime, by adding the interval or period to the time of the last firing or skipping.?

With: ?The counting time is the time accumulated while active by a Timer created or rescheduled using a RelativeTime to specify the initial firing/skipping time. The counting time is zeroed at the beginning of an activation, or when rescheduled, while active, before the initial firing/skipping of an activation.?

Semantics and Requirements section

            534.       change

Deleted: ?In this model, start is understood as defining ?now? and start counting, stop is understood as stop counting. start after stop may be understood as start counting again from where stopped, or start from scratch after resetting the count. In both cases a delay is introduced. An RTSJ Timer, when using the counter model, resets the count when it is re-started after being stopped.

? Timer modeled as counter: The timer is viewed as if every clock interrupt increments a count up to the firing count, initially given by either an instance of RelativeTime or computed as the difference between an instance of AbsoluteTime and a semantically specified ?now? (using the same clock).?

            535.       change

Made a list bullet of:  ?An RTSJ Timer, when using the counter model, resets the count when it is re-started after being stopped.?

            536.       change

Deleted: In this model, start is understood as start comparing, and possibly the first start is understood as defining ?now?. stop is understood as stop comparing. start after stop may be understood as start comparing again. In this case no delay is introduced.

? Timer modeled as comparator: The timer is viewed as if every clock interrupt forces a comparison between an absolute time and a firing time, initially given either as an instance of AbsoluteTime or computed as the sum of an instance of RelativeTime and a semantically specified ?now? (using the same clock).?

            537.       change

Replaced: ?The first firing or skipping of a PeriodicTimer shall be at the beginning of the first interval, however specified. Subsequently, the PeriodicTimer timer will fire or skip at period times set or measured from the last firing or skipping.?

With: ?The initial firing, or skipping, of a PeriodicTimer occurs in response to the invocation of its start method, in accordance with the start time passed to its constructor. This initial firing, or skipping, may be rescheduled by a call to the reschedule method, in accordance with the time passed to that method.?

            538.       change

Replaced ?If a timer is made active after the initial firing or skipping is due, the first firing or skipping shall occur immediately.

NOTE: The transition to not-active by a timer with an initial firing time specified as a RelativeTime causes the counting time to reset, effectively preventing a timer with an initial firing time specified as a RelativeTime from firing immediately, unless given a time value of 0.?

With: ?For a PeriodicTimer:

a. Let S be the absolute time at which the initial firing or skipping of a PeriodicTimer is scheduled to occur:

i. If the start, or reschedule, time was given as an absolute time, A, and that time is in the future when the timer is made active, then S equals A. Otherwise, if the absolute time has passed when the timer is made active, then S equals the time at which the timer was made active.

ii. If the start, or reschedule, time was given as a relative time, R, then S equals the time at which the counting time, started when the timer was made active, equals R.

NOTE: The transition to not-active by this timer causes the counting time to reset, effectively preventing this kind of timer from firing immediately, unless given a time value of 0.

b. The firings, or skippings, of a PeriodicTimer are scheduled to occur according to S+nT, for n = 0, 1, 2 ..., where S is as just specified, and T is the interval of the periodic timer.?

            539.       change

Insert semantic: ?A Timer object will not fire before its due time.?

Clock class

getRealtimeClock() method

            540.       change

Replaced: ?a ? With: ?the system ?

            541.       change

Replaced: ?clock that advances in sync with the external world? With: ?clock?

In

There is always at least one clock object available: a the system real-time clock that advances in sync with the external worldclock. This is the default Clock.

setResolution(resolution) method

            542.       change

Replaced: ?resolution - The new resolution of this. The clock association of the resolution parameter is ignored?

With: ?resolution - The new resolution of this, if the requested value is supported by this clock. If resolution is smaller than the minimum resolution supported by this clock then it throws IllegalArgumentException. If the requested resolution is not available and it is larger than the minimum resolution, then the clock will be set to the closest resolution that the clock supports, via truncation. The value of the resolution parameter is not altered. The clock association of the resolution parameter is ignored.?

            543.       change

Inserted: ?java.lang.IllegalArgumentException - Thrown if resolution is null, or if the requested resolution is smaller than the minimum resolution supported by this clock.?

Timer class

Description section

            544.       change

Replaced: ?relative ? With: ?according ?

In

A timer is a timed event that measures time relative according to a given Clock

Pseudo-Code Representation of State Transitions for Timer

            545.       change

Inserted: ?The pseudo-code is a model, it should be interpreted as running continuously, with instructions that take no time.?

            546.       change

Replaced: ?startTime? With: ?targetTime?

Replaced: ?currentTime? With: ?nextTargetTime?

Replaced: ?and? With: ?[if?

Deleted: ?set ?

Replaced: ?=? With: ?<?

Replaced: ?nextTargetTime? With: ?currentTime?

Replaced: ?go? With: ?set?

Replaced: ?to? With: ?targetTime?

Replaced: ?state? With: ?=?

Replaced: ?{active, enabled, absolute}? With: ?currentTime?

Inserted: ?then go to state {active, enabled, absolute}]?

Replaced: ?startTime? With: ?countingTime?

Replaced: ?currentTime? With: ?0?

Replaced: ?countingTime? With: ?durationTime?

Replaced: ?0? With: ?nextDurationTime?

Deleted: ?and set durationTime = nextDurationTime?

In

start ->

  [if last_rescheduled_with_AbsoluteTime

    then

      [set startTimetargetTime = currentTimenextTargetTime

        and[if set targetTime =< nextTargetTimecurrentTime

         then goset totargetTime state= {active, enabled, absolute}cur rentTime]

         then go to state {active, enabled, absolute}]

    else

      [set startTimecountingTime = currentTime0

       and set countingTimedurationTime = 0nextDurationTime

       and set durationTime = nextDurationTime

       then go to state {active, enabled, relative}]]

 

            547.       change

Replaced: ?startTime? With: ?targetTime?

Replaced: ?currentTime? With: ?nextTargetTime?

Replaced: ?set? With: ?if?

Replaced: ?startTime? With: ?targetTime?

Replaced: ?=? With: ?<?

Replaced: ?and? With: ? then?

Replaced: ?nextTargetTime? With: ?currentTime]?

Deleted: ? else?

Replaced: ? [set startTime = currentTime? With: ?else?

Replaced: ? and ? With: ?[?

In

startDisabled ->

  [if last_rescheduled_with_AbsoluteTime

    then

      [set startTimetargetTime = currentTimenextTargetTime

       [setif startTimetargetTime =< currentTime

       and then set targetTime = nextTargetTimecurrentTime]

       then go to state {active, disabled, absolute}]

  else

    [set startTime = currentTimeelse

      and [set countingTime = 0

       and set durationTime = nextDurationTime

       then go to state {active, disabled, relative}]]

 

            548.       change

Inserted: ?[set targetTime = nextTargetTime?

Replaced: ?set? With: ?if?

Replaced: ?startTime? With: ?targetTime?

Replaced: ?=? With: ?<?

Replaced: ?and? With: ? then?

Replaced: ?nextTargetTime? With: ?currentTime]?

Replaced: ? [set startTime = currentTime? With: ?else?

Replaced: ? and ? With: ?[?

In

start ->

  [if last_rescheduled_with_AbsoluteTime

    then

      [set targetTime = nextTargetTime

      [setif startTimetargetTime =< currentTime

        and then set targetTime = nextTargetTimecurrentTime]

       then go to state {active, enabled, absolute}]

      [set startTime = currentTimeelse

       and [set countingTime = 0

       and set durationTime = nextDurationTime

       then go to state {active, enabled, relative}]]

 

            549.       change

Replaced: ?startTime? With: ?targetTime?

Replaced: ?currentTime? With: ?nextTargetTime?

Replaced: ?and? With: ?[if?

Deleted: ?set ?

Replaced: ?=? With: ?<?

Replaced: ?nextTargetTime? With: ?currentTime?

Replaced: ?go? With: ?set?

Replaced: ?to? With: ?targetTime?

Replaced: ?state? With: ?=?

Replaced: ?{active, disabled, absolute? With: ?currentTime?

Inserted: ?then go to state {active, disabled, absolute}]?

Replaced: ?startTime? With: ?countingTime?

Replaced: ?currentTime? With: ?0?

Replaced: ?countingTime? With: ?durationTime?

Replaced: ?0? With: ?nextDurationTime?

Deleted: ?and set durationTime = nextDurationTime?

In

startDisabled ->

  [if last_rescheduled_with_AbsoluteTime

  then

    [set startTimetargetTime = currentTimenextTargetTime

     and[if set targetTime =< nextTargetTimecurrentTime

     then goset totargetTime state= {active, disabled, absolute} crrentTime]

     then go to state {active, disabled, absolute}]

  else

    [set startTimecountingTime = currentTime0

     and set countingTimedurationTime = 0nextDurationTime

     and set durationTime = nextDurationTime

     then go to state {active, disabled, relative}]]

            550.       change

Inserted: ?via targetTime = (targetTime + period)?

Replaced: ?enabled? With: ?enable?

In

{active, enabled, absolute}

  [if currentTime >= targetTime

    then

      [if PeriodicTimer

        then

        [if period > 0

          then

          [fire

            and set fired_or_skipped_in_current_activation = TRUE

            and self reschedule

                via targetTime = (targetTime + period)

            and re-enter current state]

        else

          [fire

           and go to state {not-active, disabled, absolute}]]

      else

        [it is a OneShotTimer so

          fire

          and go to state {not-active, disabled, absolute}]]]

    enabledenable -> no state change, do nothing

    disable -> go to state {active, disabled, absolute}

    stop -> [go to state {not-active, disabled, absolute}

         and return TRUE]

    start -> throws IllegalStateException

    isRunning -> return TRUE

            551.       change

Inserted: ?[reset the durationTime to relativeTime arg?

Deleted: ?[reset?

Replaced: ?the? With: ?and?

Replaced: ?durationTime? With: ?set?

Replaced: ?to? With: ?countingTime?

Replaced: ?relativeTime? With: ?=?

Replaced: ?arg? With: ?0?

In

reschedule ->

  [if NOT fired_or_skipped_in_current_activation

    then

      [if using an instance of AbsoluteTime

        then

          [reset the targetTime to absoluteTime arg

           and re-enter current state]

    else

      [reset the durationTime to relativeTime arg

      [reset theand durationTimeset tocountingTime relativeTime= arg0

       and go to state {active, enabled, relative}]]

    else

      [if using an instance of AbsoluteTime

        then

        [reset the nextTargetTime to absoluteTime arg

          and set last_rescheduled_with_AbsoluteTime = TRUE

          and no state change]

      else

        [reset the nextDurationTime to relativeTime arg

          and set last_rescheduled_with_AbsoluteTime = FALSE

          and no state change]]]

 

            552.       change

Replaced: ?and? With: ? via  durationTime =?

Replaced: ?re-enter? With: ?(durationTime?

Replaced: ?current? With: ?+?

Replaced: ?state]? With: ?period)?

Replaced: ?enabled? With: ?enable?

In

 [if countingTime >= durationTime

  then

    [if PeriodicTimer

      then

        [if period > 0

        then

          [fire

            and set fired_or_skipped_in_current_activation = TRUE

            and self reschedule

            and via durationTime = reenter(

            durationTime current+ state]period)

            and re-enter current state]

        else

          [fire

          and go to state {not-active, disabled, relative}]]

    else

      [it is a OneShotTimer so

        fire

         and go to state {not-active, disabled, relative}]]]

  enabledenable -> no state change, do nothing

 

            553.       change

Replaced: ?re-enter? With: ?set countingTime?

Replaced: ?current? With: ?=?

Replaced: ?state]]? With: ?0?

Inserted: ?and re-enter current state]]?

In

[if using an instance of AbsoluteTime

  then

    [reset the targetTime to absoluteTime arg

     and go to state {active, enabled, absolute}]

  else

    [reset the durationTime to relativeTime arg

     and re-enterset countingTime current= state]]0

     and re-enter current state]]

            554.       change

Deleted: ? return (startTime + durationTime)?

Deleted: ?getFireTime?

Deleted: ?->?

Replaced: ?startTime? With: ?currentTime?

Inserted: ? - countingTime?

In

[if using an instance of AbsoluteTime

  then

    [reset the nextTargetTime to absoluteTime arg

    and set last_rescheduled_with_AbsoluteTime = TRUE

    and no state change]

  else

    [reset the nextDurationTime to relativeTime arg

    and set last_rescheduled_with_AbsoluteTime = FALSE

    and no state change]]]

  getFireTime -> return (startTime + durationTime)

  getFireTime -> return (startTimecurrentTime + durationTime -countingTime)

  destroy -> go to state {destroyed}

  startDisabled -> throws IllegalStateException

 

            555.       change

Replaced: ?and? With: ? via targetTime =?

Replaced: ?re-enter? With: ?(targetTime?

Replaced: ?current? With: ?+?

Replaced: ?state]? With: ?period)?

Inserted: ?and re-enter current state]?

In

[if period > 0

  then

    [skip

      and set fired_or_skipped_in_current_activation = TRUE

      and self reschedule

      and via targetTime = reenter(

      targetTime current+ state]period)

      and re-enter current state]

 

            556.       change

Replaced: ?disabled? With: ?disable?

In

enable -> go to state {active, enabled, absolute}

disableddisable -> no state change, do nothing

stop -> [go to state {not-active, disabled, absolute}

 

 

            557.       change

Replaced: ?go? With: ?set?

Replaced: ?to? With: ?countingTime?

Replaced: ?state? With: ?=?

Replaced: ?{active, disabled, relative}]]? With: ?0?

Inserted: ?and go to state {active, disabled, relative}]]?

reschedule ->

  [if NOT fired_or_skipped_in_current_activation

    then

      [if using an instance of AbsoluteTime

        then

          [reset the targetTime to absoluteTime arg

            and re-enter current state]

        else

          [reset the durationTime to relativeTime arg

            and goset tocountingTime state= {active, disabled, relative}]]0

            and go to state {active, disabled, relative}]]

 

            558.       change

Replaced: ?and? With: ? via durationTime =?

Replaced: ?reenter? With: ?(durationTime?

Replaced: ?current? With: ?+?

Replaced: ?state]? With: ?period)?

In

{active, disabled, relative}

  [if countingTime >= durationTime

    then

      [if PeriodicTimer

        then

          [if period > 0

            then

             [skip

                and set fired_or_skipped_in_current_activation = TRUE

                and self reschedule

                and via durationTime = reenter(

                durationTime current+ state]period)

                and re-enter current state]

            else

              [skip

                and go to state {not-active, disabled, relative}]]

        else

          [it is a OneShotTimer so

            skip

            and go to state {not-active, disabled, relative}]]]

 

 

            559.       change

Replaced: ?disabled? With: ?disable?

In

enable -> go to state {active, enabled, relative}

disableddisable -> no state change, do nothing

stop -> [go to state {not-active, disabled, relative}

 

            560.       change

Inserted: ?[reset the durationTime to relativeTime arg?

Deleted: ?[reset?

Replaced: ?the? With: ?and?

Replaced: ?durationTime? With: ?set?

Replaced: ?to? With: ?countingTime?

Replaced: ?relativeTime? With: ?=?

Replaced: ?arg? With: ?0?

In

reschedule ->

  [if NOT fired_or_skipped_in_current_activation

    then

      [if using an instance of AbsoluteTime

        then

          [reset the targetTime to absoluteTime arg

          and go to state {active, disabled, absolute}]

        else

          [reset the durationTime to relativeTime arg

          [reset theand durationTimeset tocountingTime relativeTime= arg0

          and re-enter current state]]

 

            561.       change

Inserted: ? getFireTime ->?

Deleted: ?getFireTime?

Deleted: ?->?

Replaced: ?startTime? With: ?currentTime?

Inserted: ? - countingTime?

In

getFireTime ->

getFireTime -> return (startTimecurrentTime + durationTime -

countingTime)

destroy -> go to state {destroyed}

startDisabled -> throws IllegalStateException

 

            562.       change

Replaced: ?disabled? With: ?disable?

In

{destroyed}

  enable | disableddisable | stop | start | isRunning

  | reschedule | getFireTime | destroy

  | startDisabled -> throws IllegalStateException

 

Timer Constructor

            563.       change

Inserted: ?. The clock associated with the parameter time is always ignored?

In

clock - The clock on which to base this timer, overriding the clock associated with the parameter time. If null, the system Realtime clock is used. The clock associated with the parameter time is always ignored.

            564.       change

Inserted:  ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the given clock.?

addHandler(handler) method

            565.       change

added override and Inserted: ?Throws:

java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

bindTo() method

            566.       change

Added override: ?Should not be called.

Throws:

java.lang.UnsupportedOperationException - Thrown if bindTo is called on a Timer.?

createReleaseParameters() method

            567.       change

Replaced: ?block ? With: ?object ?

In:

Create a ReleaseParameters block object appropriate to the timing characteristics of this event.

destroy() method

            568.       change

Inserted: ?remove from it all the associated handlers if any?

In

Stop this from counting or comparing if active, remove from it all the associated handlers if any, and release as many of its resources as possible back to the system. Every method invoked on a Timer that has been destroyed will throw IllegalStateException.

            569.       change

Inserted: ?Throws: java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

disable() method

            570.       change

Replaced: ?not enabled? With: ?already disabled, whether it it is active or not-active?

In

These semantics imply also that firings are not queued. Using the above example, if enable was called at time 43 no firing will occur, since at time 42 this was disabled. If the Timer is not enabledalready disabled, whether it is active or not-active, this method does nothing.

enable() method

            571.       change

Replaced: ?not disabled? With: ?already enabled, this method does nothing. If the Timer is not-active?

In

Re-enable this timer after it has been disabled. (See disable()374 .) If the

Timer is not disabledalready enabled, this method does nothing. If the Timer is not-active, this method does nothing

getFireTime() method

            572.       change

Replaced ?Returns: An instance of AbsoluteTime object representing the absolute time at which this is expected to fire or to skip. If the timer has been created or re-scheduled (see reschedule(HighResolutionTime) ) using an instance of RelativeTime for its time parameter then it will return the sum of such time and the start time. The clock association of the returned time is the clock on which this timer is based.?

With: ?Returns: The absolute time at which this is expected to fire or to skip, in a newly allocated AbsoluteTime object. If the timer has been created or re-scheduled (see reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will return the sum of the current time and the RelativeTime remaining time before the timer is expected to fire/skip. The clock association of the returned time is the clock on which this timer is based.?

            573.       change

Inserted: ?java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.?

getFireTime(fireTime) method

            574.       change

Added method:

Get the time at which this Timer is expected to fire. If the Timer is disabled, the returned time is that of the skipping of the firing. If the Timer is

not-active it throws IllegalStateException.

Parameters:

fireTime - The instance of AbsoluteTime which will be updated in place and returned. The clock association of the

fireTime parameter is ignored. When fireTime is null a new object is allocated for the result.

Returns: The instance of AbsoluteTime passed as parameter, with time values representing the absolute time at which this is expected to fire or to skip. If the fireTime parameter is null the result is returned in a newly allocated object. If the timer has been created or re-scheduled (see reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will return the sum of the current time and the RelativeTime remaining time before the timer is expected to fire/skip. The clock association of the returned time is the clock on which this timer is based.

Throws:

java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.

java.lang.IllegalStateException - Thrown if this Timer has been destroyed, or if it is not-active.

handledBy() method

            575.       change

Added override

Inserted ?Throws:

java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

isRunning() method

            576.       change

Inserted: ?Throws:

java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

removeHandler() method

            577.       change

Added override

Inserted ?Throws:

java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

 

reschedule() method

            578.       change

Replaced: ?re-scheduling ? With: ?rescheduling ?

In

The re-scheduling rescheduling will take place between the invocation and the return of the method.

 

            579.       change

Deleted: ? NOTE: While the scheduled time is changed as described above, the rescheduling itself is applied only on the first firing (or on the first skipping if disabled) or a timer?s activation. ?

 

Inserted: ?NOTE: While the scheduled time is changed as described above, the rescheduling itself is applied only on the first firing (or on the first skipping if disabled) of a timer?s activation. If reschedule is invoked after the current activation timer?s firing, then the rescheduled time will be effective only upon the next start or startDisabled command (which may need to be preceded by a stop command).

If reschedule is invoked with a RelativeTime time on an active timer before its first firing/skipping, then the rescheduled firing/skipping time is relative to the time of invocation.?

            580.       change

Inserted: ?. The clock associated with the parameter time is always ignored?

In

time - The time to reschedule for this event firing. If time is null, the previous time is still the time used for the Timer firing. The clock associated with the parameter time is always ignored.

            581.       change

Inserted: ?java.lang.IllegalArgumentException - Thrown if time is a negative RelativeTime value.?

setHandler() method

            582.       change

Added override.

 

Inserted: ?java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

OneShotTimer class

Description section

            583.       change

Replaced: ?retains the enabled or disabled state it had at expiration time? With: ?disabled?

In

After expiration, the OneShotTimer becomes not-active and retains the enabled or disabled state it had at expiration timedisabled. If the clock time has already passed the timeout time, it will fire immediately after it is started or after it is rescheduled while active

 

First Constructor

            584.       change

Replaced: ?at which ? With: ?used to determine when to fire?

Replaced: ?handler is released? With: ?event?

Replaced: ?null ? With: ?time ?

Replaced: ?time ? With: ?null ?

Replaced: ?relative time ? With: ?RelativeTime ?

Inserted: ?, and in this case case the Timer fires immediately upon a call to start()?

In

time - The time at which used to determine when to fire the handler is releasedevent. A null time value of time null is equivalent to a relative time RelativeTime of 0, and in this case the Timer fires immediately upon a call to start().

            585.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the clock associated with time.?

Second Constructor

            586.       change

Replaced: ?at which ? With: ?used to determine when to fire?

Replaced: ?handler is released? With: ?event?

Replaced: ?null ? With: ?time ?

Replaced: ?time ? With: ?null ?

Replaced: ?relative time ? With: ?RelativeTime ?

Inserted: ?, and in this case case the Timer fires immediately upon a call to start()?

In

time - The time at which used to determine when to fire the handler is releasedevent. A null time value of time null is equivalent to a relative time RelativeTime of 0, and in this case the Timer fires immediately upon a call to start().

            587.       change

Replaced: ?clock - The timer will be based on this clock. If the clock is null, the default Realtime clock is used.?

With: ?clock - The clock on which to base this timer, overriding the clock associated with the parameter time. If null, the system Realtime clock is used. The clock associated with the parameter time is always ignored.?

            588.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the given clock.?

PeriodicTimer class

Description section

            589.       change

Deleted: ?the system guarantees that?

Replaced: ?interval time units after the last firing? With: ?periodically?

Deleted: ?for?

In:

?If an interval greater than 0 is given, the system guarantees that the timer will fire interval time units after the last firingperiodically. If an interval of 0 is given, the PeriodicTimer will only fire once, unless restarted after expiration, behaving like for a OneShotTimer. In all cases, if the timer is disabled when the firing time is reached, that particular firing is lost (skipped). If enabled at a later time, it will fire at its next scheduled time.?

            590.       change

Insert a paragraph break after ?immediately after it is started?

In:

If the clock time has already passed the beginning of the first period, the PeriodicTimer will fire immediately after it is started.

 

If one of the HighResolutionTime argument types is RationalTime (now deprecated)?

 

First Constructor

            591.       change

Replaced: ?If ? With: ?A ?

Inserted: ?value of null ?

Replaced: ?null then ? With: ?equivalent to a RelativeTime of 0, and in this case?

Replaced: ?first interval will start ? With: ?Timer fires ?

In

start - The time that specifies when the first interval begins, based on the clock associated with it. If A start value of null is null then equivalent to a RelativeTime of 0, and in this case the first interval will start Timer fires immediately upon a call to start().

            592.       change

Replaced: ?zero? With: ?zero or null?

Deleted: ?is the one of a OneShotTimer . For a PeriodicTimer the method Timer.getClock() returns the clock to which the interval is associated with, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer?

In

interval - The period of the timer. Its usage is based on the clock associated with it. If interval is zerozero or null, the period is ignored and the firing behavior of the PeriodicTimer is the one of a OneShotTimer . For a PeriodicTimer the method Timer.getClock() returns the clock to which the interval is associated with, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer.

            593.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the clock associated with start or the clock associated with interval.?

Second Constructor

            594.       change

Replaced: ?If ? With: ?A ?

Inserted: ?value of null ?

Replaced: ?null then ? With: ?equivalent to a RelativeTime of 0, and in this case?

Replaced: ?first interval will start ? With: ?Timer fires ?

In

start - The time that specifies when the first interval begins, based on the clock associated with it. If A start value of null is null then equivalent to a RelativeTime of 0, and in this case the first interval will start Timer fires immediately upon a call to start().

            595.       change

Replaced: ?zero? With: ?zero or null?

Replaced: ?the one ? With: ?that ?

In

interval - The period of the timer. Its usage is based on the clock specified by the clock parameter. If interval is zerozero or null, the period is ignored and the firing behavior of the PeriodicTimer is the one that of a OneShotTimer.

            596.       change

Replaced: ?clock - The clock to be used to time the interval. For a PeriodicTimer the method Timer.getClock() returns the clock used to time the interval, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer.?

With: ?clock - The clock to be used to time the interval. If null, the system Realtime clock is used. The Clock association of the parameter interval is always ignored.?

 

            597.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the clock associated with start or the given clock.?

createReleaseParameters() method

            598.       change

Replaced: ?Create a ReleaseParameters object with the next fire time as the start time and the interval of this as the period.?

With: ?Create a release parameters object with new objects containing copies of the values corresponding to this timer. When the PeriodicTimer interval is greater than 0, create a PeriodicParameters object with a start time and period that correspond to the next firing (or skipping) time, and interval, of this timer. When the interval is 0, create an AperiodicParameters object, since in this case the timer behaves like a OneShotTimer.

 

If this timer is active, then the start time is the next firing (or skipping) time returned as an AbsoluteTime. Otherwise, the start time is the initial firing (or skipping) time, as set by the last call to reschedule, or if there was no such call, by the constructor of this timer.?

            599.       change

Replaced: ?Returns: A new instance of ReleaseParameters with a value corresponding to the release characteristics of this timer.?

With ?Returns: A new release parameters object with new objects containing copies of the values corresponding to this timer. If the interval is greater than zero, return a new instance of PeriodicParameters. If the interval is zero return a new instance of AperiodicParameters.?

 

getClock() method

            600.       change

Inserted override of getClock

Inserted: ?Returns the instance of Clock that the PeriodicTimer interval is associated with at the time of the call, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer.

 

Returns: The instance of Clock that the interval is associated with at the time of the call.

 

Throws:

java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?

 

getFireTime() method

            601.       change

Replaced: ?Gets the absolute time this will next fire.?

With: ?Get the time at which this PeriodicTimer is next expected to fire or to skip. If the PeriodicTimer is disabled, the returned time is that of the skipping of the firing. If the PeriodicTimer is not-active it throws IllegalStateException.?

            602.       change

Replaced: ?Returns: A new AbsoluteTime instance with the value at which this is expected to fire.?

With: ?Returns: The absolute time at which this is next expected to fire or to skip, in a newly allocated AbsoluteTime object. If the timer has been created or re-scheduled (see Timer.reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will return the sum of the current time and the RelativeTime remaining time before the timer is expected to fire/skip. Within a periodic timer activation, the returned time is associated with the start clock before the first fire (or skip) time, and associated with the interval clock otherwise.?

            603.       change

Inserted: ?java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.?

            604.       change

Replaced: ?in a not-active state? With: ?not-active?

In

java.lang.IllegalStateException - Thrown if this PeriodicTimer has been destroyed, or if it is in a not-active statenot-active.

getInterval() method

            605.       change

Replaced: ?A new? With: ?The?

In

A newThe RelativeTime instance with the value of this timer?s interval.

 

setInterval(interval) method

            606.       change

Replaced: ?The semantics of the update are the same? With: ?A null interval is interpreted ?

Replaced: ?for updating the period of a real-time thread? With: ?RelativeTime?

Replaced: ?See the semantics of the priority scheduler? With: ?0,0.?

In

interval - A RelativeTime object which is the interval used to reset this Timer. The semantics of the update are the same A null interval is interpreted as for updating the period of a real-time thread. RelativeTime(See the semantics of the priority scheduler.0,0).

            607.       change

Inserted: ?The interval does not affect the first firing (or skipping) of a timer?s activation. At each firing (or skipping), the next fire (or skip) time of an active periodic timer is established based on the interval currently in use. Resetting the interval of an active periodic timer only effects future fire (or skip) times after the next.?

Asynchrony Chapter

Semantics and Requirements for Asynchronous Events and their Handlers section

            608.       change

Inserted: ?active ?

In

2. The release of attached handlers occurs in execution eligibility order (priority order with the default PriorityScheduler) and at the active priority of the schedulable object that invoked the fire method.

            609.       change

Deleted: ?If an AI-method is attempting to acquire an object lock when an associated AIE is generated, the attempt to acquire the lock is abandoned immediately?

And Inserted as a new semantic: ?If an AI-method is attempting to acquire an object lock when an associated AIE is generated, the attempt to acquire the lock is abandoned.?

AsyncEvent class

addHandler(handler) method

            610.       change

Replaced: ?schedule? With: ?system?

In

Since this affects the constraints expressed in the release parameters of an existing schedulable object, this may change the feasibility of the current schedulesystem.

removeHandler(handler) method

            611.       change

Replaced: ?schedule? With: ?system?

In

Since this affects the constraints expressed in the release parameters of an existing schedulable object, this may change the feasibility of the current schedulesystem.

setHandler(handler) method

            612.       change

Replaced: ?schedule? With: ?system?

In

Since this affects the constraints expressed in the release parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.

AsyncEventHandler class

Description section

            613.       change

Deleted: ?default ?

Deleted: ?default ?

In

The default scheduler for an asynchronous event handler is inherited from the thread/schedulable object that created it. If it was created from a Java thread, the default scheduler is the current default scheduler.

BoundAsyncEventHandler class

Second constructor

            614.       change

Replaced: ?BAEH?s ? With: ?BAEH?s ?

In

release - A ReleaseParameters object which will be associated with the constructed instance. If null, this will have default ReleaseParameters for the BAEH?s BAEH?s scheduler.

 

Replaced: ?BAEH?s ? With: ?BAEH?s ?

In

logic - The java.lang.Runnable object whose run() method is executed by AsyncEventHandler.handleAsyncEvent(). If null, the logic will default to the BAEH?s BAEH?s run method.

AsynchronouslyInterruptedException class

clear() method

            615.       change

Replaced: ?current exception is this ? With: ?currently executing schedulable object, ?

Inserted: ?if so, ?

Replaced: ?the exception ? With: ?it ?

Replaced: ?pending if it is current? With: ?pending?

In

Atomically see if this is pending on the current exception is this currently executing schedulable object, and if so, make the exception it nonpending if it is currentpending.

            616.       change

Replaced: ?the current exception? With: ?pending?

Replaced: ?the current exception? With: ?pending?

In

Returns: True if this was the current exceptionpending. False if this was not the current exceptionpending.

doInterruptible() method

            617.       change

Inserted: ?The run method of given Interruptible is always entered with the exception in the enabled state, but that state can be modified with enable() and disable() and the state can be observed with isEnabled().?

 

isEnabled() method

            618.       change

Inserted: ?This method is valid only when the caller has a call to doInterruptible() in progress. If invoked when no call to doInterruptible() is in progress, enable returns false and does nothing.?

            619.       change

Replaced: ?with ? With: ?in the context of ?

Replaced: ?) in progress? With: ?)?

In

Returns: True if this is enabled and the method call was invoked with in the context of the associated doInterruptible() in progress). False otherwise.

System and Options Chapter

POSIXSignalHandler class

Description section

            620.       change

Replaced: ?AsyncEvent? With: ?AsyncEventHandler?

In

Use instances of AsyncEvent398AsyncEventHandler402 to handle POSIX signals.

addHandler(signal, handler) method

            621.       change

Deleted: ?AsyncEvent of the ?

In

Add the given AsyncEventHandler to the list of handlers of the AsyncEvent of the given signal.

            622.       change

Replaced: ?class? With: ?class or if handler is null?

In

java.lang.IllegalArgumentException - Thrown if signal is not known by this classclass or if handler is null.

 

Replaced: ?IllegalArgumentException ? With: ?UnsupportedOperationException ?

Deleted: ?not ?

Replaced: ?by ? With: ?to ?

Inserted: ?, but not supported on this implementation?

In

java.lang.IllegalArgumentException UnsupportedOperationException - Thrown if signal is not known by to this class, but not supported on this implementation.

removeHandler(signal, handler) method

            623.       change

Deleted: ?of the AsyncEvent?

In

Remove the given AsyncEventHandler402 from the list of handlers of the AsyncEvent of the given signal.

            624.       change

Replaced: ?class? With: ?class or if handler is null?

In

java.lang.IllegalArgumentException - Thrown if signal is not known by this classclass or if handler is null.

 

setHandler(signal, handler) method

            625.       change

Deleted: ?AsyncEvent of the ?

In

Set the given AsyncEventHandler as the handler of the AsyncEvent of the given signal.

            626.       change

Inserted: ?java.lang.UnsupportedOperationException - Thrown if signal is known to this class, but not supported on this implementation.?

RealtimeSystem class

setMaximumConcurrentLocks(numLocks) method

            627.       change

Replaced: ?effect? With: ?effect other than on the value returned by getMaximumConcurrentLocks()?

In

numLocks - An integer whose value becomes the number of locks that can be in simultaneous use without incurring an execution time increase. If number is less than or equal to zero nothing happens. If the system does not use this hint this method has no effecteffect other than on the value returned by

getMaximumConcurrentLocks().

setMaximumConcurrentLocks(numLocks, hard) method

            628.       change

Replaced: ?effect? With: ?effect other than on the value returned by getMaximumConcurrentLocks()?

In

If the system does not use this hint this method has no effecteffect other than on the value returned by getMaximumConcurrentLocks().

Exceptions chapter

ArrivalTimeQueueOverflowException class

Description section

            629.       change

Replaced: ?a this? With: ?an instance of this class?

In

If an arrival time occurs and should be queued but the queue already holds a number of times equal to the initial queue length defined by this then the fire() method shall throw a thisan instance of this class.

CeilingViolationException class

Description section

            630.       change

Replaced: ?active ? With: ?base ?

In

This exception is thrown when a schedulable object or java.lang.Thread attempts to lock an object governed by an instance of PriorityCeilingEmulation and the thread or SO?s active base priority exceeds the policy?s ceiling.

getCallerPriority() method

            631.       change

Replaced: ?active? With: ?base?

In

Gets the active base priority of the SO or thread whose attempt to synchronize resulted in the throwing of this.

 

Replaced: ?active? With: ?base?

In

Returns: The synchronizing thread?s active base priority.

getCeiling() method

            632.       change

Inserted: base

In

Gets the ceiling of the PriorityCeilingEmulation policy which was exceeded by the base priority of an SO or thread that attempted to synchronize on an object governed by the policy, which resulted in throwing of this.