Proposed
Change list RSTJ 1.0.1(a) to 1.0.1(b)

Note that changes to inherited methods are only itemized inthe 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 inthis 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. Where such semantics are mentioned, the change list includes enough text from the semantic to identify it.

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 �

Timely execution of schedulable objects means that the programmer can determine byanalysis of the program, testing the program on particular implementations, orboth whether particular threads will always complete execution before a giventimeliness constraint.

3. change

Replaced: threads

With :

schedulable objects

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

4. change

Replaced thread

With

schedulable object

Priority is typically an integer associated with a schedulable object;

5. change

Replaced

�to�

With

�that may help�

However, the base scheduler also inherits methods from itssuperclass that may help determinefeasibility.

Memory Management

Subsection Memory Areas

6. change

Inserted

�real-time�

specifically including no-heap real-timethreads and no-heap asynchronous event handlers.

Subsection Scoped Memory

7. change

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

Replaced �areaeffectively maintains�

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

Replaced: �that� With �each�

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 finalizersexecute to completion before the next use (calling enter() or in a constructor)of the scoped memory area� With �complete�

The contents of a scoped memory arediscarded when no object in the scope can be referenced. This is done by atechnique similar to reference counting the scope. A conformant implementationmight maintain a count of the number ofexternal references to each memory area. Thereference count for a ScopedMemoryarea would be increased by entering a new scope throughthe enter() method of MemoryArea, by the creation of a schedulableobject using the particular ScopedMemory area,or by the opening of an inner scope. The reference count for a ScopedMemory area wouldbe decreased when returning from the enter() method, when the schedulable object using the ScopedMemory terminates, or when an inner scopereturns from its enter()method. When the countdrops to zero, the finalize method for each object in the memory would be executed to completion. Reuse of the scope isblocked until finalization is complete.

8. change

Replaced �Enclosing� With �Outer�

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

Synchronization section

Priority Inversion Avoidance subsection

9. change

Replaced

�Asecond policy, priority ceiling emulation protocol (or highest lockerprotocol), is also specified for systems that support it. The highest lockerprotocol is also a well known algorithm in the literature, and it has thefollowing effect:

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

�As soon as a thread enters synchronized code, its priority is raised to themonitor�s ceiling priority.

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

Notethat while the RTSJ requires that the execution of non-heap schedulable objectsmust not be delayed by the execution of the garbage collector, an applicationcan cause a no-heap schedulable to wait for garbage collection by synchronizingusing an object between an heap-using thread or schedulable object and anon-heap schedulable object. The RTSJ provides three wait-free queue classes toprovide protected, non-blocking, shared access to objects accessed by bothregular Java threads and no-heap real-time threads. These classes are providedexplicitly to enable communication between the real-time execution of non-heapschedulable objects and regular Java threads.�

With

�A second policy, priority ceiling emulation protocol (orhighest locker protocol), is also specified for systems that support it. Thisprotocol is also a well-known algorithm in the literature; somewhat simplified, its effect is asfollows:

� A monitor is given a �priority ceiling� when it iscreated; the programmer should choose the highest priority of any thread thatcould 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 programmingerror, a thread has a higher base priority than the ceiling of the monitor itis attempting to enter, then an exception is thrown.

� On leaving the monitor, the thread has its active priorityreset. 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 basepriority while it was in the monitor) a

different value is possible

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

Asynchronous Event Handling section

10. change

Replaced �soft� With �execution time�

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

Asynchronous Transfer of Control section

Methodological Principles subsection

11. change

Replaced �methods� with �methods, static initializers�

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

Expressibility Principles subsection

12. change

Replaced �thread� With �schedulable object�

Code that responds to an ATC does not return to the point inthe schedulable object where the ATC wastriggered;

13. change

Replaced �thread� With �schedulable object�

Replaced �thread� With �thread or schedulable object�

Replaced �thread � with �thread or schedulable object�

A mechanism is needed through which an ATC can be explicitly triggered in a target schedulable object. This triggering may be direct (from a source thread or schedulable object) or indirect (through an asynchronous event handler).

It must be possible to trigger an ATC based on any asynchronous event including an external happening or an explicit event firing from another thread or schedulable object. In particular, it must be possible to base an ATC on a timer going off.

14. change

Inserted: �real-time�

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

Pragmatic Principles subsection

15. change

Inserted: �real-time�

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

16. change

Deleted

�ATCmust be implemented without inducing an overhead for programs that do not useit.�

Asynchronous Thread Termination section

17. change

Inserted: �Real-Time� in the title.

18. change

Replaced �is� With �would be�

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

19. change

deleted �would�

from

Withoutthis facility, a thread or set of threads wouldhave to be coded in such a manner so that their

computationalbehavior anticipated all of the possible transitions among possible states ofthe external system.

20. change

Inserted �real-time�

The RTSJ accommodates safe asynchronous real-time thread termination through a combinationof the asynchronous event handling and the asynchronous transfer of controlmechanisms.

21. change

Inserted �real-time�

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

22. change

Inserted �real-time�

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

23. change

Inserted �real-time�

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

24. change

Inserted �real-time�

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

25. change

Inserted �real-time�

Ultimately the run() methodof the real-time thread will completenormally.

26. change

Insert �real-time�

This idiom provides a quick (if coded to be so) but orderlyclean up and termination of the real-timethread.

Physical Memory Access section

27. change

Deleted

�The base implementation will provide aPhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes thatcorrectly identify memory classes that are standard for the (OS, JVM, andprocessor) platform.�

from

ThePhysicalMemoryManager is available for use by the various physical memoryaccessor objects (VTPhysicalMemory,LTPhysicalMemory, ImmortalPhysicalMemory, RawMemoryAccess, and RawMemoryFloatAccess)to create objects of the correct typethat are bound to areas of physical memory with the appropriate characteristics- or with appropriate accessor behavior. Examples of characteristics that mightbe 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 forthe (OS, JVM, and processor) platform.OEMs may provide PhysicalMemoryTypeFilter classes that allow additional characteristics ofmemory devices to be specified.

Requirements and Conventions

28. change

Inserted

�Subject to the usual assumptions, the methods injavax.realtime can safely be used concurrently by multiple threads unless it isotherwise documented.�

In the list of base requirements

Optional Facilities section

29. change

Replaced

�Allows the application to control the processor utilizationof a thread or group of threads.�

With

�Allows the application to control the processor utilizationof a schedulable object.�

In the description of the cost enforcement option

30. change

Insert the following option in the option table:

�ProcessingGroup Enforcement

Allows the application to control the processor utilizationof 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 groupdeadline �

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 aschedulable object creates objects in the heap.�

33. change

Inserted

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

34. change

Inserted

�If the processing group deadline less than period is notsupported, values passed to the constructor for ProcessingGroupParameters andits setDeadline method are constrained to be equal to the period. If the optionis supported, processing group deadlines less than the period must be supportedand function as specified.�

35. change

Replaced

�If cost enforcement is not supported, theProcessingGroupParameters class must not be present. If cost enforcement issupported, ProcessingGroupParameters must be implemented as specified.�

With

�If priority ceiling emulation is supported, PriorityCeilingEmulationmust be implemented as specified. If priority ceiling emulation is notsupported, PriorityCeilingEmulation must be present, but the implementation maynot 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 ceilingemulation is supported, PriorityCeilingEmulation must be implemented asspecified.�

With

�If heap allocation rate enforcement is supported, it mustbe implemented as specified. If heap allocation rate enforcement is notsupported, the allocation rate attribute of MemoryParameters must be checkedfor validity but otherwise ignored by the implementation.�

37. change

Inserted

�The following semantics are optional for an RTSJimplementation designed and licensed exclusively as a development tool:

� The priority scheduler need not support fixed-prioritypreemptive scheduling or priority inheritance. This does not excuse animplementation from fully supporting the relevant APIs. It only reduces therequired behavior of the underlying scheduler to the level of the scheduler inthe Java specification extended to at least 28 priorities.

� No semantics constraining timing beyond the requirementsof the Java specifications need be supported. Specifically, garbage collectionmay delay any thread without bound and any delay in delivering asynchronouslyinterrupted exceptions is permissible including never delivering the exception.Note, however, that if any AIE other than the generic AIE is delivered, it mustmeet the AIE semantics, and all heap-memory-related semantics other thanpreemption remain fully in effect. Further, relaxed timing does not implyrelaxed sequencing. For instance, semantics for scoped memory must be fullyimplemented.

� The RTSJ semantics that alter standard Java methodbehavior�such as the modified semantics for Thread.setPriority andThread.interrupt�are not required for a development tool, but suchdeviations from the RTSJ must be documented, and the implementation must beable to generate a run-time warning each time one of these methods deviatesfrom standard RTSJ behavior.

� These relaxed requirements set a floor for RTSJdevelopment system tool implementations. A development tool may choose toimplement semantics that are not required.�

Required Documentation section

38. change

Replaced �admission control� with �feasibility testing�

twice in

If the feasibility testingalgorithm is not the default, document the feasibilitytesting algorithm.

39. change

Replaced �the base� With �each other�

document the behavior of the scheduler and its interactionwith each other scheduler

40. change

Deleted

�3 An implementation of the RTSJ is permitted to spuriouslyrelease waiting threads, but it must document the circumstances under whichthat may happen.�

41. change

Deleted

�4. Threads that are preempted in favor of a thread withhigher execution eligibility may be given access to the processor at any timeas determined by a particular implementation. If the behavior does not matchthe POSIX specification, the implementation is required to providedocumentation stating exactly the algorithm used for granting such access.�

42. change

Inserted

�Placement at the front of the queue may be required in afuture version of this specification.�

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

43. change

Replaced �default� With �base�

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

44. change

Replaced �This� With �The�

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

45. change

Inserted the following documentation requirement

�An implementation may run finalizers for objects in scopedmemory before the scope is reentered and before it returns from any call togetReferenceCount() for that scope. It must, however, document when it runsthose finalizers.�

46. change

Insertedthe following documentation requirement

�For each supported clock, the documentation must specifywhether the resolution is settable, and if it is settable the documentationmust indicate the supported values.�

47. change

Inserted the following documentation requirement

�If an implementation includes any clocks other than therequired real-time clock, their documentation must indicate in what contextsthose clocks can be used.�

48. change

Deleted

�If we refer to other heaps, such as the heap used by the Clanguage runtime or the operating system�s heap, we will explicitly state whichheap.�

from

Throughoutthe RTSJ, when we use the word code,we mean code written in the Java programming language. When we mention the Javalanguage in the RTSJ, that also refers to the Java programming language. Theuse of the term heap in the RTSJwill 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 Clanguage runtime or the operating system�s heap, we will explicitly state whichheap.

Standard Java Chapter

Thread Groups section

49. change

Replaced

�Thread groups are rooted at a base ThreadGroup object whichis created in heap memory, and thread group objects hold references to alltheir member threads. Since no-heap threads cannot hold a reference to a heapobject they are not permitted to contain a reference to a thread group, andsince thread groups cannot hold references to threads created in scoped memorythey are also not permitted to have normal thread group membership. Inconsequence all no-heap threads and some plain real-time threads have nullthread group references.�

With

�Thread groups are rooted at a base ThreadGroup object whichmay be created in heap or immortal memory. All thread group object holdreferences to all their member threads, and subgroups, and a reference to theirparent group. Since heap and immortal memory can not hold references to scopedmemory, 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 referencedfrom any thread group, and consequently such threads are not part of any threadgroup and will hold a null thread group reference. Similarly, aNoHeapRealtimeThread can not be a member of a heap allocated thread group.�

50. change

Deleted

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

51. change

Insert new section �InterruptedException�

52. change

Inserted

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

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 thegarbage collector executing in the context of a Java thread with a lowerexecution eligibility.�

With

�Garbage collection executing in the context of a Javathread must not in itself block execution of a no-heap thread with a higherexecution eligibility, however application locks work as specified even whenthe lock causes synchronization between a heap-using thread and a no-heapthread.�

54. change

Inserted

�, and when an asynchronously interrupted exception�s firemethod is invoked between the time the real-time thread has entered thatexception�s doInterruptible method, and return from doInterruptible. (See theAsynchrony chapter.)�

Each real-time thread has an attribute which indicateswhether an AsynchronouslyInterruptedExceptionis pending. Thisattribute 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 invokedbetween the time the real-time thread has entered that exception�s doInterruptible method, and return from doInterruptible. (See the Asynchronychapter.)

Second RealtimeThread constructor

55. change

Replaced �default� With �associated�

java.lang.IllegalArgumentException - Thrown if thescheduling parameters are not compatible with the associatedscheduler.

Third RealtimeThread constructor

56. change

Replaced �default� With �associated�

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

Fourth RealtimeThread constructor

57. change

Inserted �The newly-created real-time thread is associatedwith 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�

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

59. change

In the description of the release parameter

Replaced �default � with �associated�

Replaced �copy� with �clone�

release - The ReleaseParameters associatedwith this (and possibly other instances of Schedulable). If release is nullthe new RealtimeThread will use a clone of thedefault ReleaseParameters for the associatedscheduler created in the memory area that contains the RealtimeThreadobject.

60. change

Replaced �The � with �This �

java.lang.IllegalArgumentException - Thrown if theparameters are not compatible with the associatedscheduler.

Text copied from the Schedulable interface is coveredwith that interface

currentRealtimeThread method

61. change

Replaced �notan instance of RealtimeThread or an asynch event handler�

with �that of a Java thread�

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

getCurrentMemoryArea method

62. change

Inserted

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

getInitialMemoryAreaIndex method

63. chang

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

64. change

Insert �may�

65. change

Delete �This method returns the position in the memory areastack of initial memory area.�

This method returns the position in the memoryarea stack of the initial memory area. Memory area stacks mayinclude inherited stacks from parent threads. The initial memory area for thecurrent 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 fixedproperty of the real-time thread. This method returnsthe 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 indexgetMemoryAreaStackDepth() - 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 isinterrupted by interrupt() or AsynchronouslyInterruptedException.fire() duringthe time between calling this method and returning from it.�

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

69. change

Replaced �not an instance of RealtimeThread or an asyncevent handler.� With �that of a Java thread.�

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

70. change

Replaced �java.lang.IllegalArgumentException - Thrown ifclock cannot represent calendar time, or if time is a relative time less thanzero.�

With

�java.lang.UnsupportedOperationException - Thrown if thesleep 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 musttolerate time instances that may not be stored in this.�

72. change

Replaced �ifinterrupted �

With �if the thread is interrupted by interrupt()36 orAsynchronouslyInterruptedException.fire() during the time between calling thismethod and returning from it.�

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

73. change

Replaced �notan instance of RealtimeThread or an async event handler.�

With �that of a Java thread.�

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

74. change

Replaced �java.lang.IllegalArgumentException - Thrown ifclock cannot represent calendar time, or if time is a relative time less thanzero.�

With

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

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

start() method

75. change

Inserted �it �

Set up the real-time thread�s environment and start it. Theset up might include delaying it until theassigned 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 allocatedin heap memory, or if this is in heap memory�

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 schedulingis allocated in heap memory, or if this is inheap memory.

Second constructor

77. change

Replaced �default� with �associated�

Deleted �or�

Inserted

�if area is null, if area is heap memory, if area, releaseor scheduling is allocated in heap memory, or if this is in heap memory.�

java.lang.IllegalArgumentException - Thrown if theparameters are not compatible with the associatedscheduler, if area is null,if area is heap memory, if area, release or schedulingis allocated in heap memory, or if this is inheap memory.

78. change

Deleted �release�

Replaced �area and group� with �release�

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 associatedwith 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, memoryor group is allocated in heap memory, if this is in heap memory, or if logic isin heap memory. �

java.lang.IllegalArgumentException - Thrown if theparameters are not compatible with the associatedscheduler, if areais null, if area is heap memory, if area, schedulingrelease, memory or group is allocated in heap memory, if this is inheap memory, or if logic is in heap memory.

81. change

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

IllegalAssignmentError422 - Thrownif the new NoHeapRealtimeThread instance cannot hold referencesto non-null values of the scheduling release, memory and group,

or if those parameters cannothold a reference to the new NoHeapRealtimeThread.

start() method

82. change

Replaced

�Checks if the NoHeapRealtimeThread is startable and startsit if it is. Checks that the parameters associated with this NHRT object arenot allocated in heap. Also checks if this object is allocated in heap. If anyof them are allocated, start() throws a MemoryAccessError�

with

�Checks if the NoHeapRealtimeThread is startable and startsit if it is.�

83. change

Delete the Throws: MemoryAccessError clause

Scheduling chapter

Definitions and Abbreviations section

84. change

Replaced �inherited�with �acquired�

Inserted �theaction of�

85. change

Replaced �inheritance � with �inversion avoidance algorithms�

86. change

Replaced �Synchronization � with �the Synchronization�

The active priority of a schedulable object, or a Java thread, is themaximum of its base priority and any priority it has acquireddue to the action of priority inversion avoidancealgorithms (see the SynchronizationChapter).

87. change

Replaced

�This specification does not require any particularfeasibility algorithm be implemented in the Scheduler object. The defaultalgorithm always returns success, as it assumes an adequately fast computer.�

With

�This specification does not require any particularfeasibility algorithm be implemented in the Scheduler object. The defaultalgorithm always returns success for sporadic and periodic schedulable objects,as it assumes adequate resources, but it always returns false for aperiodicschedulable objects since no pool of resources would render such a loadfeasible.�

Processing Groups subsection

88. change

Replaced �costenforcement � with �processinggroup enforcement�

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

89. change

Insert semantic

�Changes to the membership of the processing group takeeffect immediately�

Rationale section

90. change

Inserted �active �

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

Schedulable interface

addIfFeasible method

91. change

Replaced �The �with �This�

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

92. change

Deleted

�the scheduling release, and memory parameters of�

from

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

93. change

Replace �feasible� with �feasibility�

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

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

94. change

Replace �feasible� with �feasibility �

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 becausethere is no assigned instance of Scheduler.�

With

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

addToFeasibility method

96. change

Deleted: �theSchedulingParameters ReleaseParameters ReleaseParameters andMemoryParameters of�

from

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

97. change

Replaced �feasible � with �feasibility �

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

getScheduler() method

98. change

Replaced �current � with �associated�

Returns: A reference to the associated Scheduler object.

removeFromFeasibility() method

99. change

Deleted �theparameters of �

Inform the scheduler and cooperating facilities that the parameters of this instance of Schedulable82 should notbe considered infeasibility analysis until it is further notified.

100. change

Deleted �thereis no assigned instance of Scheduler or if�

Replaced �feasible � with �feasibility �

Returns: True,if the removal was successful. False, if there is no assigned instance of Scheduler , or if theschedulable object cannot be removedfrom 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

Themethod first performs a feasibility analysis using release and memory as replacements for the matching parameter values of this. If theresulting system is feasible the methodreplaces the current release and memory parametersof 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 �newparameters � with �proposed ones�

This method first performs a feasibility analysis using the proposed parameter objects as replacements forthe current parameters of this. If the resultingsystem is feasible, this method replaces thecurrent parameters of thiswith the proposed ones.

103. change

Replaced �feasible � with �feasibility�

Replaced �schedule � with �system�

This method does not require that the schedulable object bein the feasibility set before it is called. Ifit is not initially a member of the feasibilityset it will be added if the resulting systemis feasible.

104. change

Inserted

�Also thrown if this schedulable object is noheap and any ofthe proposed parameter objects are located in heap memory.�

java.lang.IllegalArgumentException - Thrown when theparameter values are not compatible with the schedulable object�s scheduler. Also thrown if this schedulable object is noheap and any ofthe 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 �areference �

IllegalAssignmentError - Thrown if this object cannot holdreferences to release and memory the proposedparameter objects, or the release or memory parameter objects cannot hold references areference to this.

setIfFeasible(release, memory, group) method

106. change

Replaced �The� with �This�

Replaced �new ReleaseParameters, MemoryParameters, andProcessingGroupParameters� 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�

The This method first performs a feasibility analysisusing the newReleaseParameters , MemoryParameters and

ProcessingGroupParameters proposed parameterobjects asreplacements for the current parameters of this. If the resulting system is feasible the feasible, this method replaces thecurrent release,memory and processing group parameters of this with the corresponding replacement parameters.proposed ones.

107. change

Replaced �feasible� with �feasibility�

Replaced �schedule� with �system�

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

108. change

Inserted �schedulable object�s�

Inserted �Also thrown if this schedulable object is noheapand any of the proposed parameter objects are located in heap memory�

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible withthe schedulable object�s scheduler. Also thrown if this schedulable object is noheap and anyof 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�

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

setIfFeasible(release, group) method

110. change

Replaced �The� with �This�

Replaced �new ReleaseParameters andProcessingGroupParameters� with �proposed parameter objects�

Replaced �the� with �this�

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

Replaced �new parameters� with �proposed ones�

The This method first performs a feasibility analysisusing the newReleaseParameters and ProcessingGroupParameters proposed parameter objects as replacements for thecurrent parameters of this. If the resulting system is feasible, the this method replaces thecurrent ReleaseParametersand ProcessingGroupParameters parameters of this with the new parametersproposed ones.

111. change

Replaced �feasible� with �feasibility�

Replaced �schedule� with �system�

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

112. change

Inserted �schedulable object�s�

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

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible withthe schedulable object�s scheduler. Also thrown if this schedulable object is noheap and anyof 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�

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

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 parameterobjects�

Replaced �matching parameter values� with �currentparameters�

Replaced �feasible the� with �feasibility, this�

Deleted "scheduling, release and memory�

Replaced �corresponding replacement parameters� with�proposed ones�

The This method first performs a feasibility analysisusing release and memory the proposed parameterobjects asreplacements for the matching parameter values current parameters of this. If the resulting system is feasible the feasible, this method replaces thecurrent scheduling,release andmemory parameters of this with the corresponding replacementparametersproposedones.

116. change

Replaced �feasible� with �feasibility�

Replaced �schedule� with �system�

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

117. change

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

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

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

118. change

Inserted �object�

Replaced �release and memory� with �the proposed parameterobjects�

Replace �release or memory� with �parameter objects�

Replace �references� with �a reference�

IllegalAssignmentError456 - Thrown if this object cannot holdreferences to release and memory the proposedparameter objects, or the release or memory parameter objects cannothold 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 parameterobjects �

Replaced: �feasible the � With:�feasible, this �

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

Replaced: �new parameters� With:�proposed ones�

The This method first performs a feasibility analysisusing the newReleaseParameters , MemoryParameters and ProcessingGroupParameters proposed parameterobjects asreplacements for the current parameters of this. If the resulting system is feasible the feasible, this method replaces thecurrent ReleaseParameters, MemoryParameters and ProcessingGroupParameters parameters of this with the new parametersproposed ones.

121. change

Replaced: �feasible � With:�feasibility �

Replaced: �schedule � With:�system �

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

122. change

Inserted: �schedulable object�s �

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

java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible withthe schedulable object�s scheduler. Also thrown if this schedulable object is noheap and anyof 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: �areference �

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

124. change

Deleted: �, or if sched is not compatible with the schedulerassociated with this.�

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

setMemoryParameters(memory) method

125. change

Replaced: �schedule� With:�system�

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

126. change

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

java.lang.IllegalArgumentException - Thrown if memory is notcompatible with the schedulable object�s scheduler. Also thrown ifthis schedulable object is no-heap and memory is located in heap memory.

setMemoryParametersIfFeasible(memory) method

127. change

�The � With: �This �

Replaced: �given memoryparameters � 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 memoryparameters� With: �proposed one�

The This method first performs a feasibility analysisusing the givenmemory parameters proposed parameter object as replacements replacement for the memory parameters current parameter of this this. If the resulting systemis feasiblethe feasible,this methodreplaces the current memory parameters parameter of this with the new memory parametersproposed one.

128. change

Replaced: �feasible � With: �feasibility �

Replaced: �schedule � With: �system �

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

129. change

Replaced: �memory � With: �the parameter value �

Inserted: �schedulable object�s �

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

java.lang.IllegalArgumentException - Thrown when memory theparameter value is notcompatible with the schedulableobject�s scheduler. Also thrown if this schedulable object is noheap and theproposed parameter object is located in heap memory.

130. change

Deleted �object �

Replaced: �memory � With: �theproposed parameter object,�

Replaced: �memory � With: �theparameter object �

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

setProcessingGroupParameters(group) method

131. change

Replaced: �schedule� With:�system�

Since this affects the constraints expressed inthe processing group parameters of the existing schedulable objects, this maychange the feasibility of the current schedulesystem.

132. change

Replaced: �at � With: �as determined by �

Replaced: �next release of this� With: �associatedscheduler�

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

133. change

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

java.lang.IllegalArgumentException - Thrown when group is not compatible withthe scheduler for this schedulable object. Also thrown if this schedulable object isno-heap and groupis locatedin heap memory.

setProcessingGroupParametersIfFeasible(group) method

134. change

Replaced: �The � With: �This �

Replaced: �newProcessingGroupParameters � 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. Thechanges ...� With: �proposed one�

The This method first performs a feasibility analysisusing the newProcessingGroupParameters proposed parameter objectas a replacement for thecurrent parametersparameter of this. If the resultingsystem is feasiblethe feasible,this methodreplaces the current ProcessingGroupParameters parameter of this with the new parameters. The changes take place at the schedulable object�snext releaseproposedone.

135. change

Replaced: �feasible � With:�feasibility �

Replaced: �schedule � With:�system �

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

136. change

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

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

137. change

Replaced: �group � With: �theparameter value �

Inserted: �schedulable object�s�

138. change

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

java.lang.IllegalArgumentException - Thrown when group the parametervalue is not compatible withthe schedulable object�s scheduler. Also thrown if this schedulable object is noheap and theproposed parameter object is located in heap memory.

139. change

Deleted: �object �

Replaced: �group � With: �theproposed parameter object, �

Replaced: �group � With: �theparameter object �

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

setReleaseParameters(release) method

140. change

Replaced: �schedule� With:�system�

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

141. change

Inserted: �, and take effect as determined by the associatedscheduler�

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

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

142. change

Inserted: �associated �

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

java.lang.IllegalArgumentException - Thrown when release is notcompatible with the associatedscheduler. Also thrown if this schedulable object isno-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�

The This method first performs a feasibility analysisusing the newReleaseParameters proposed parameter objectas a replacement for thecurrent parametersparameter of this. If the resultingsystem is feasiblethe feasible,this methodreplaces the current ReleaseParameters parameter of this with the new parametersproposed one.

144. change

Moved from one paragraph down: �This change becomeseffective under conditions determined by the scheduler controlling theschedulable object. For instance, the change may be immediate or it may bedelayed until the next release of the schedulable object. See the documentationfor the scheduler for details.�

145. change

Replaced: �feasible � With:�feasibility �

Replaced: �schedule � With:�system �

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

146. change

Replaced: �ReleaseParametersobject� With: �proposed release parameters�

Inserted: �the �

Replaced: �release parametersfor � With: �value is governed by �

Deleted: �are used �

Inserted: �. (See PriorityScheduler) �

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

147. change

Replaced: �release � With: �theparameter value �

Inserted: �schedulable object�s�

148. change

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

java.lang.IllegalArgumentException - Thrown when release the parameter value is not compatible withthe schedulableobject�s scheduler. Also thrown if thisschedulable object is noheap and the proposed parameter object is located inheap memory.

149. change

Deleted: �object �

Replaced: �release � With: �theproposed parameter object, �

Replaced: �release � With: �theparameter object �

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

setScheduler(scheduler) method

150. change

Replace: �Sets the reference to the Scheduler object. Thetiming of the change is under the control of the new scheduler. In the case ofthe default scheduler, the change is made immediately. If this schedulableobject has been admitted to the feasible set (e.g., by addToFeasibility()) itremains in the feasible set after the change in scheduler. This change in thescheduler may affect the feasibility of the current schedule.�

With

�Sets the reference to the Scheduler object. The timing ofthe change must be agreed between the scheduler currently associated with thisschedulable object, and scheduler.�

151. change

Deleted: �the new �

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

java.lang.IllegalArgumentException - Thrown when scheduler isnull, or the schedulable object�s existing parameter values are not compatiblewith 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 controlof the new scheduler. In the case of� With: �must be agreed between �

Deleted: �default scheduler, the�

153. change

Replaced: �and schedulingparameters take control immediately� With: �currently associated with thisschedulable object�

Replaced: �the release and processing group parameters takeeffect the next time the schedulable is released� With: �scheduler.�

Sets the scheduler and associated parameterobjects. The timing of the change is under the control of the new scheduler. In thecase of mustbe agreed between the default scheduler, the scheduler and scheduling parameters take control immediatelycurrently associated withthis schedulable

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

154. change

Deleted: �If this schedulable object has been admitted tothe feasible set (e.g., by addToFeasibility() ) it remains in the feasible setafter the change in scheduler. This change in the scheduler may affect thefeasibility of the current schedule.�

155. change

Replaced: �the � With: �scheduler. Also thrown when thisschedulable object is no-heap and�

156. change

Inserted: �, scheduling release, memoryParameters, or groupis located in heap memory�

java.lang.IllegalArgumentException - Thrown when scheduler isnull or the parameter values are not compatible with the scheduler. Alsothrown when this schedulable object is no-heap and scheduler, schedulingrelease, memoryParameters, or group is locatedin heap memory.

setSchedulingParameters(scheduling) method

157. change

Replaced: �schedule� With: �system�

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

158. change

Inserted: �associated �

159. change

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

java.lang.IllegalArgumentException - Thrown when scheduling isnot compatible with the associatedscheduler. Also thrown if this schedulable object isno-heap and scheduling is located in heap memory.

setSchedulingParametersIfFeasible(scheduling) method

160. change

Replaced: �The � With: �This �

Replaced: �given schedulingparameters � 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 schedulingparameters� With: �proposed one�

The This method first performs a feasibility analysisusing the givenscheduling parameters proposed parameter object as replacements replacement\ for the scheduling parameters current parameter of this this. If the resulting systemis feasiblethe feasible,this methodreplaces the current scheduling parameters parameter of this with the new scheduling parametersproposed one.

161. change

Replaced: �feasible � With:�feasibility �

Replaced: �schedule � With:�system �

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

162. change

Deleted: �SchedulingParametersare set to the�

Replaced: �SchedulingParametersfor � With: �value is governed by �

Inserted: �a new object iscreated �

Replaced: �null a new object iscreated� With: �null�

Inserted: �. (SeePriorityScheduler )�

scheduling - Theproposed scheduling parameters. If null, the SchedulingParameters are set to the default SchedulingParameters for value isgoverned by the associated

scheduler (a newobject is created if thedefault value is not null a newobject 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 isno-heap and the proposed parameter object is located in heap memory�

java.lang.IllegalArgumentException - Thrown when scheduling theparameter value is notcompatible with the schedulableobject�s scheduler. Also thrown if this schedulable object isno-heap and the proposed parameter object is located in heap memory.

165. change

Deleted: �object �

Replaced: �scheduling � With: �the proposed parameterobject, �

Replaced: �scheduling � With: �the parameter object �

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

Scheduler class

166. change

Replaced: �schedule� With:�system�

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

addToFeasibility(schedulable) method

167. change

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

Deleted: �SchedulingParameters , ReleaseParametersMemoryParameters , and ProcessingGroupParameters ) of�

Replaced: �feasible � With: �feasibility �

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

Scheduler101 until further notice. Whether the resultingsystem is feasible or not, the addition is completed. If the object is alreadyincluded in the feasible feasibility set, do nothing.

168. change

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

java.lang.IllegalArgumentException - Thrown if schedulableis null, or if schedulable is notassociated 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� arethe responsibility of the feasibility algorithm of the actual Schedulersubclass�

Queries the system about the feasibility of the set of scheduling andrelease characteristics system currently being considered. The definitions of �feasible� and �system� arethe responsibility of the feasibility algorithm of the actual Scheduler subclass.

removeFromFeasibility(schedulable) method

170. change

Replaced: �the � With: �this �

Replaced: �demands, as expressedin � With: �demands of �

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

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

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

171. change

Inserted: �Parameters: schedulable - A reference to thegiven instance of Schedulable�

Replaced: �feasible � With:�feasibility �

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

setDefaultScheduler(scheduler) method

172. change

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

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

173. change

Inserted: �schedulable objectscreated by Java �

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 ReleaseParametersand MemoryParameters� With: �proposed parameter objects �

Replaced: �feasible the � With:�feasible, this �

Replaced: �ReleaseParameters andMemoryParameters � With: �parameters of schedulable �

Replaced: �new parameters� With:�proposed ones�

This method first performs a feasibilityanalysis using the new ReleaseParameters and MemoryParameters proposed parameter objects as replacements for the current parameters of schedulable. If the resultingsystem is feasiblethe feasible,this methodreplaces the current ReleaseParameters and MemoryParameters parameters of chedulable with the new parametersproposed ones.

175. change

Replaced: �feasible � With:�feasibility �

Replaced: �schedule � With:�system �

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

176. change

Inserted: �of this scheduler�

Replaced: �governed by theassociated scheduler � With: �used �

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

177. change

Inserted: �of this scheduler �

Replaced: �governed by theassociated scheduler � With: �used �

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

178. change

Inserted: �schedulable is null, or schedulable is notassociated with this scheduler, or�

Inserted: �proposed �

Replaced: �the schedulableobject�s � With: �this �

Deleted: �, or if schedulable isnull�

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

with theschedulable object�s this scheduler, or if schedulableis 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 cannothold references to the proposedparameter objects, or if either the parameterobject is unable to objects cannot hold a reference to schedulable.

180. change

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

setIfFeasible(schedulable, release, memory, group)

181. change

Replaced: �new ReleaseParametersMemoryParameters and ProcessingGroupParameters� With: �proposed parameterobjects �

Replaced: �feasible the � With:�feasible, this �

Replaced: �ReleaseParametersMemoryParameters and ProcessingGroupParameters � With: �parameters ofschedulable �

Replaced: �new parameters� With:�proposed ones�

This method first performs a feasibilityanalysis using the new ReleaseParameters MemoryParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of schedulable. If the resultingsystem is feasiblethe feasible,this methodreplaces the current ReleaseParameters MemoryParameters and ProcessingGroupParameters parameters of schedulable with the new parametersproposed ones.

182. change

Replaced: �feasible � With:�feasibility �

Replaced: �schedule � With:�system �

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

183. change

Replaced: �instance ofSchedulable � With: �schedulable object �

schedulable -The instance of Schedulable85 schedulableobject for which the changesare proposed.

184. change

Inserted: �of this scheduler �

Replaced: �governed by theassociated scheduler � With: �used �

release - Theproposed 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 isnot null). (See PriorityScheduler.)

185. change

Inserted: �of this scheduler �

Replaced: �governed by the associatedscheduler � With: �used �

186. change

Inserted: �of this scheduler �

187. change

Replaced: �governed by theassociated scheduler � With: �used �

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

188. change

Inserted: �schedulable is null, or schedulable is notassociated with this scheduler, or�

Inserted: �proposed �

Replaced: �the schedulableobject�s � With: �this �

Deleted: �, or if schedulable isnull�

java.lang.IllegalArgumentException - Thrown if schedulableis null, or schedulable is not associated with this scheduler, orthe 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 �

IllegalAssignmentError - Thrown if the schedulablecannothold references to the proposedparameter objects, or ifany of the parameter objects is unable to cannothold a referenceto schedulable.

190. change

Inserted:

java.lang.IllegalThreadStateException - Thrown if the newrelease parameters change schedulable from periodic scheduling to some otherprotocol and schedulable is currently waiting for the next release inRealtimeThread.waitForNextPeriod() orRealtimeThread.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 afeasibility analysis using the proposed parameter objects as replacements forthe current parameters of schedulable. the resulting system is feasible, this method replaces thecurrent parameters schedulable with the proposed ones.

This method does not requirethat the schedulable object be in the feasibility set before it is called. Ifit is not initially a member of the feasibility set will be added if theresulting system is feasible.

Parameters:

schedulable - Theschedulable object for which the changes are proposed.

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

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

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

group - Theproposed processing group parameters. If null, the default value of thisscheduler is used (a new object is created the default value is not null). (SeePriorityScheduler.)

Returns: True, ifthe resulting system is feasible and the changes are made. False, if theresulting 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 - Thrownif schedulable cannot hold references to the proposed parameter objects, or theparameter objects cannot hold a reference to schedulable.

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

PriorityScheduler class

Description

192. change

Replaced: �required priority �With: �base �

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

193. change

Inserted:

Note that the system contains one instance of thePriorityScheduler which is the system�s base scheduler and is returned byPriorityScheduler.instance(). It may, however, contain instances of subclassesof PriorityScheduler and even additional instances of PriorityScheduler itselfcreated through this class� protected constructor. The instance returned by theinstance() method is the base scheduler and is returned by Scheduler.getDefaultScheduler()unless the default scheduler is reset withScheduler.setDefaultScheduler(Scheduler).

instance() method

194. change

Replaced: �Return a reference to the singleton instance ofPriorityScheduler.� With: �Return a reference to the distinguished instance ofPriorityScheduler which is the system�s base scheduler.�

195. change

Replaced: �singleton � With:�distinguished �

Returns: A reference to the singleton distinguished instance PriorityScheduler.

isFeasible() method

196. change

Deleted: �Override the isFeasible method from Schedulerproviding 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.�

Override the isFeasible method from Scheduler providing feasibility analysis appropriate to the priorityscheduler. Queriesthe system this scheduler about the feasibility ofthe set of schedulingand release characteristics schedulable objects currently being considered. in the feasibility set.

197. change

Inserted:

Implementation Notes:

The default feasibility test for the PrioritySchedulerconsiders a set of schedulable objects with bounded resource requirements, toalways be feasible. This covers all schedulable objects with release parametersof types PeriodicParameters and SporadicParameters.

If any schedulable object within the feasibility set hasrelease parameters of the exact type AperiodicParameters135 (not a subclassthereof), then the feasibility set is not feasible, as aperiodic releasecharacteristics require unbounded resources. In that case, this method willreturn false and all methods in the setIfFeasible family of methods will alsoreturn false. Consequently, any call to a setIfFeasible method that passes aschedulable object which has release parameters of type AperiodicParameters, orpasses proposed release parameters of type AperiodicParameters, will returnfalse. The only time a set IfFeasible method can return true, when there existsin the feasibility set a schedulable object with release parameters of typeAperiodicParameters, is when the method will change those parameters to not beAperiodicParameters.

Implementations may provide a feasibility test other thanthe default just described. In which case the details of that test should bedocumented 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 �

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

200. change

Inserted: ҥ The new object has clones of allhigh-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 foreach HighResolutionTime parameter value. For instance the value returned bygetCost() must be equal to the value passed in by setCost, but it need not bethe 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 actualresolution available and even the quantity the timers measure depend on theclock associated with each time value.

The implementation must use modified copy semantics for eachHighResolutionTime parameter value. The value of each time object should betreated 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 valuereturned by getCost() must be the same object passed in by setCost(), but anychanges made to the time value of the cost must not take effect in theassociated ReleaseParameters instance unless they are passed to the parameterobject 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 �

Return a clone of this. This method should behave effectively as if itconstructed 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-resolutiontime values (deep copy).

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

setCost(cost) method

206. change

Insert: �IllegalAssignmentError - Thrown if cost cannot bestored in this.�

setCostOverrunHandler(handler) method

207. change

Insert �Throws: IllegalAssignmentError - Thrown if handlercannot be stored in this.�

setDeadline(deadline) method

208. change

Deleted: �if �

java.lang.IllegalArgumentException - Thrown if deadlineis null, if the time value of deadlineis less than or equal tozero,

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

209. change

Insert: �IllegalAssignmentError - Thrown if deadline cannotbe stored in this.�

setDeadlineMissHandler(handler) method

210. change

Insert: �Throws: IllegalAssignmentError - Thrown if handlercannot be stored in this.

setIfFeasible(cost, deadline) method

211. change

Insert: �IllegalAssignmentError - Thrown if cost or deadlinecannot be stored in this.�

PeriodicParameters class

Description

212. change

With: �Periodic parameters use HighResolutionTime values forperiod and startime. Since these times are expressed as a HighResolutionTimevalues, thesevalues use accurate timers with nanosecond granularity. The actualresolution available and even the quantity the timers measure depend on theclock associated with each time value.

The implementation must use modified copy semantics for eachHighResolutionTime parameter value. The value of each time object should betreated 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 valuereturned by getCost() must be the same object passed in by setCost(), but anychanges made to the time value of the cost must not take effect in theassociated PeriodicParameters instance unless they are passed to the parameterobject again, e.g. with a new invocation of setCost.�

First Constructor

213. change

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

Second Constructor

214. change

Inserted: �IllegalAssignmentError - Thrown if start periodcost, deadline, overrunHandler or missHandler cannot be stored in this.�

Third Constructor

215. change

Inserted: �IllegalAssignmentError - Thrown if period cannotbe stored in this.�

setDeadline(deadline) method

216. change

Added override, replacing: �deadline - The latestpermissible completion time measured from the release time of the associatedinvocation of the schedulable object. The default value of the deadline must becontrolled by the classes that extend ReleaseParameters.� With:

�deadline - The latest permissible completion time measuredfrom the release time of the associated invocation of the schedulable object.If deadline is null, the deadline is set to a new instance of RelativeTimeequal to period.�

217. change

Added override Replacing:�java.lang.IllegalArgumentException - Thrown if deadline is null, if the timevalue of deadline is less than or equal to zero, or if the new value of thisdeadline is incompatible with the scheduler for any associated schedulableobject.�

With:

�java.lang.IllegalArgumentException - Thrown if the timevalue of deadline is less than or equal to zero, or if the new value of thisdeadline is incompatible with the scheduler for any associated schedulableobject.�

setIfFeasible(period, cost, deadline) method

218. change

Inserted �IllegalAssignmentError - Thrown if period, cost ordeadline cannot be stored in this.�

setStart(start) method

219. change

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

With:

�The effect of changing the start time for any schedulableobjects associated with this parameter object is determined by the schedulerassociated 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 becomesactivated (that is, when start() is called on a real-time thread or when anassociated event handler is first fired). If an AbsoluteTime, then the firstrelease is the maximum of the start parameter and the time of the call to theassociated RealtimeThread.start() method (or the first firing of an associatedevent). 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 anew instance of RelativeTime(0,0).�

221. change

Inserted: �IllegalAssignmentError - Thrown if start cannotbe stored in this.�

AperiodicParameters class

Description

222. change

With:

�The implementation must use modified copy semantics foreach HighResolutionTime318 parameter value. The value of each time objectshould be treated as if it were copied at the time it is passed to theparameter 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 theassociated AperiodicParameters instance unless they are passed to the parameterobject 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

225. change

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

With:

setIfFeasible(cost, deadline) method

226. change

Replace: �Returns: True, if the resulting system is feasibleand the changes are made. False, if the resulting system is not feasible and nochanges are made.�

With:

�Returns: false. Aperiodic parameters never yield a feasiblesystem. (Subclasses of AperiodicParameters, such as SporadicParameters, neednot return false.)�

227. change

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

SporadicParameters class

Description

228. change

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

Before

Only changes to a SporadicParameters object caused bymethods on that object cause the change to propagate to all schedulable objectsusing 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 ifminInterarrival cannot be stored in this.�

Second Constructor

231. change

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

deadline - Thelatest permissible completion time measured from the release time of theassociated invocation of the schedulable object. For a minimum implementationfor purposes of feasibility analysis, the deadline is equal to the minimuminterarrival interval. Other implementations may use this parameter to computeexecution eligibility. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit).

Inserted: �IllegalAssignmentError - Thrown ifminInterarrival, cost, deadline, overrunHandler or missHandler cannot be storedin this.�

setIfFeasible(cost, deadline) method

232. change

added override

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

deadline- The proposed deadline. If null, thedefault 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�

deadline - Theproposed 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 cannotbe stored in this.�

ProcessingGroupParameters class

Description

236. change

Replaced: �cannot measureexecution time� With: �do not support processing group parameters�

This is associated with one or more schedulableobjects for which the system guarantees that the associated objects will not begiven more time per period than indicated by cost. On implementations which cannot measure executiontimedo notsupport processing group parameters, this class may be used as a hint to thefeasibility algorithm.

237. change

Inserted: �Processing group parameters useHighResolutionTime values for cost, deadline, period and start time. Sincethose times are expressed as a HighResolutionTime, the values use accuratetimers with nanosecond granularity. The actual resolution available and eventhe quantity it measures depends on the clock associated with each time value.�

238. change

Before

Only changes to a ProcessingGroupParameters object caused by methods on that object areimmediately 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: �periodwill cause IllegalArgumentException to be thrown�

java.lang.IllegalArgumentException - Thrown if the period is nullor its time value is not greater than zero, if cost is null, or if the time value of cost is lessthan zero, if start is an instance of RelativeTimeand its value is negative, orif 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 deadlineless than period, deadline less than zeroperiod will cause IllegalArgumentExceptionto 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-resolutiontime values (deep copy).

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

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

� The new object is in the current allocationcontext.

� 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 allhigh-resolution time values (deep copy).

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

setCost(cost) method

247. change

Inserted: �IllegalAssignmentError - Thrown if cost cannot bestored in this.�

setCostOverrunHandler(handler) method

248. change

Inserted: �Throws: IllegalAssignmentError - Thrown ifhandler cannot be stored in this.�

setDeadline(deadline) method

249. change

Inserted: �Throws:

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

IllegalAssignmentError - Thrown if deadline cannot be storedin this.�

setDeadlineMissHandler(handler) method

250. change

Inserted: �Throws:

IllegalAssignmentError - Thrown if handler cannot be storedin this.�

setIfFeasible(period, cost, deadline) method

251. change

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

setPeriod(period) method

252. change

Inserted: �. If the implementation does not supportprocessing group deadline less than period, and period is not equal to the currentvalue of the processing group�s deadline, the deadline is set to a clone ofperiod created in the same memory area as period.�

java.lang.IllegalArgumentException - Thrown if periodis null, or its time value isnot greater than zero. If theimplementation does not support processing group deadline less than period, andperiod is not equal to the current value of theprocessing 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 cannotbe stored in this.�

setStart(start) method

254. change

Inserted: �alters the value of this object�s start timeproperty, but�

255. change

Inserted: �other �

Sets the value of start. If the processing group is already startedthis method altersthe 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 groupis already started� With: �start cannot be stored in this�

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

258. change

Inserted: �java.lang.IllegalArgumentException Thrown ifstart is a relative time value and less than zero.�

Memory Management Chapter

Semantics and Requirements

Semantic 2

259. change

Replaced: �spend � With: �spent�

Execution time of object constructors, and time spend spent in class loading andstatic initialization are not governed by bounds on object allocation in thisspecification, but�

Semantic 3

260. change

Replaced: �area � With: �area,m, �

Replaced: �the � With: �m.�

Inserted: �(or another �

Inserted: �from the family �

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

A memory area is represented by an instance of asubclass 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 memoryarea enter-likemethods in MemoryAreaor ScopedMemory) m becomes the allocationcontext ofthe current schedulable object. When control returns from the enter method, the allocationcontext 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 schedulableobject when it is first released, is the memory area that was designated theinitial memory area when the schedulable object was constructed. This initialallocation context becomes the current allocation context for that schedulableobject when the schedulable object first becomes eligible for execution. Forasync event handlers, the initial allocation context is the same on eachrelease; for real-time threads, in releases subsequent to the first, theallocation context is the same as it was when the real-time thread becameblocked-for-release-event.�

Semantic 6

262. change

Inserted: �, but note that allocation can be performed in aspecific memory area using the

newInstance and newArray methods.�

Allobject allocation through the newkeyword will use the current allocationcontext, but note that allocation can beperformed in a specific memory area using the newInstance and newArray methods.�

Deleted Semantics

The concept of �enclosing allocation context has beenreplaced with a more formal model of Scope Stack. The contained semantics arerelocated to the semantics in Maintaining the Scope Stack

263. change

Deleted:

7 The enclosing allocation context of a memoryarea, mem for a schedulable object, t, is the allocationcontext in effect for t immediatelybefore 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 allowouter allocation contexts to be accessed by their index number. The algorithmsfor 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 areouter 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 memoryarea context in a structure called the scope stack. This structure ismanipulated by creation of schedulable objects, and the following methods fromthe MemoryArea and ScopedMemory classes: all the enter and joinAndEntermethods, executeInArea, and both newInstance methods. See the semantics inMaintaining the Scope Stack for details.

266. change

Inserted

11. The scope stack is accessible through a set of staticmethods on RealtimeThread. These methods allow outer allocation contexts to beaccessed by their index number. Memory areas on a scope stack may be referredto as inner or outer relative to other entries in that scope stack. An �outerscope� is further from the current allocation context on the current scopestack 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 anouter allocation context on the current schedulable object�s current scopestack.

Inserted

268. change

13. An instance of ScopedMemory is said to be in use if ithas 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, itsparent�

Replaced: �in use and � With: �the nearest ScopedMemoryobject outside it on the current scope stack. If�

Replaced: �enclosing scoped memory� With: �outsideScopedMemory object in the current scope stack�

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

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

Instances of ScopedMemory have special semantics including definition of parent.If a ScopedMemory object is not in use, ithas 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 currentscope stack,the parent is the primordial scope which is not actually a memory area, but only amarker thatconstrainsthe parentage of ScopedMemory objects in this class. For all other ScopedMemory objects, the parent is thenearest ScopedMemoryobjectoutside it on the current schedulable object�s scope stack.

Semantic 15

271. change

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

272. change

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

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

Semantic 16

273. change

New semantic: �Pushing a scoped memory onto a scope stack isalways subject to the single parent rule.�

Semantic 17

274. change

Inserted: �execution of �

Each schedulable object has an initial memoryarea which is that object�s initial allocation context. The default initialmemory area is the current allocation context in effect during execution of the schedulable object�sconstructor, but schedulable objects may supply constructors that override thedefault.

Semantic 18

275. change

Now redundant with to Maintaining the Scope Stacksemantic 2 -- deleted:

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

Semantic 19

276. change

Replaced: �An instance ofjava.lang.Thread� With: �A Java thread �

Replaced: �an instance ofjava.lang.Thread� With: �a Java thread �

Inserted: �a �

Inserted: �area �

An instance of java.lang.Thread A Java thread cannot have a scopestack; consequently it can only be created and execute within heap or immortalmemory. 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 ofjava....� With: �A Java thread �

278. change

Replaced: �13� With: �15�

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 methodsallow it to execute with an immortal current allocation context, but semantic (1315) applies even duringexecution of these methods. .

Semantic 21

279. change

Inserted: �Each instance of the class ScopedMemory or itssubclasses must maintain a referencecount which is greater than zero if andonly if either:�

Deleted: �Each instance of the class ScopedMemory or itssubclasses must maintain a reference count which is greater than zero if andonly if the�

Replaced: �. For purposes ofthis semantic� With: �; or else �

280. change

Inserted:

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

� the schedulable object is a RealtimeThread and itterminates; or else

� the schedulable object is de-allocated from its memoryarea.

For purposes of this semantic the following are treated asexecution contexts:�

281. change

Inserted: �been started and have�

Deleted: �and �

Deleted: �are treated asexecution contexts.�

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

count which is greater than zero if and only ifeither:

� Each instance of the class ScopedMemory or its subclasses must maintain a reference countwhich is greater than zero if and only if the scoped memory area is the currentallocation context or an outer allocation context for one or more executioncontexts.For purposes of this semantic, ; or else

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

� the schedulable object is a RealtimeThread and it terminates; orelse

� the schedulable object is de-allocated from itsmemory area.

For purposes of this semantic the following aretreated as execution contexts:

� RealtimeThread objects that have been started and havenot terminated,

� AsyncEventHandler objects that are currently in a releasedstate,

� AsyncEvent objects that are bound to happenings,

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

� other schedulable objects that control anexecution engine

Semantic 22

282. change

Inserted: �still ready to bedecremented to�

283. change

Inserted: �then it isdecremented to zero and�

When the reference count for an instance of theclass ScopedMemoryis ready tobe decremented from one to zero, all unfinalized objects within that area areconsidered ready for finalization. If after the finalizers for all unfinalizedobjects in the scoped memory area run to completion, the reference count forthe memory area is still ready to be decremented to zero, then it is decremented to zero and the memory scope isemptied of all objects. The RTSJ implementation must complete finalization ofobjects 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 becomethe current allocation context for any schedulable object. (This is a specialcase of the finalization implementation specified in The Java LanguageSpecification, second edition, section 12.6.1)

Semantic 27

284. change

Inserted: �. Static initializers are executed executedeffectively as if the current thread performedImmortalMemory.instance().executeInArea(r) where r is a Runnable that executesthe <clinit> method of the class being initialized.�

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

Assignment Rule Table

285. change

Replaced each: �Yes� With: �Permit�

286. change

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

287. change

Replaced each: �No� With: �Forbid�

Semantic 28

288. change

Replaced: �area� With: �are�

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

Semantic 29

289. change

Inserted: �Checks for operations on local variables are notrequired because a potentially invalid reference would be captured by the otherchecks before it reached a local variable.�

An implementation must ensure that the abovechecks are performed on every assignment statement before the statement isexecuted. (This includes the possibility of static analysis of the applicationlogic). Checksfor operations on local variables are not required because a potentiallyinvalid reference would be captured by the other checks before it reached alocal 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 schedulableobject, �

294. change

Deleted: �all �

295. change

Inserted:

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

2. When a schedulable object, t, creates a schedulableobject, nt, in a ScopedMemory object�s allocation area, nt acquires a copy ofthe scope stack associated with t at the time nt is constructed including allentries from up to and including the memory area containing nt. If nt iscreated in heap, immortal, or immortal physical memory, nt is created with ascope stack containing only heap, immortal, or immortal physical memoryrespectively.

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

4. When a memory area, m, is entered by calling m�sexecuteInArea method or one of the m.newInstance methods the scope stack beforethe method call is preserved and replaced with a scope stack constructed asfollows:

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

� If ma is not a scoped memory area the new scope stackincludes only ma.

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

Five Four operations effect the scope stack: the enter method methods in MemoryAreaMemoryArea and ScopedMemory, construction of a newschedulable 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 schedulableobject�s scope stack is the schedulable object�s current allocation context.

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

3. When a memory area, ma, is entered by calling a ma.enter method, ma is pushed on the scopestack and becomes the allocation context of the current schedulable object. Whencontrol 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 stackbefore the method call is preserved and replaced with a scope stack constructedas follows:

� If ma is a scoped memory areathe new scope stack is a copy of the schedulable object�s previous scope stackup to and including ma.

� If ma is not a scoped memoryarea the new scope stack includes only ma.

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

Pseudocode for enter

296. change

Replace

Forma.enter(logic):

ifentering ma would violate the single parent rule

throwScopedCycleException

pushma on the scope stack belonging to the current

schedulableobject

executelogic.run method

popma from the scope stack

With

For ma.enter(logic):

push ma on the scope stack belonging to thecurrent

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

ifcma is heap, immortal or ImmortalPhysicalMemory

createa new scope stack containing cma

else

starta new scope stack containing the

entirecurrent scope stack

ifima != cma

pushima on new scope stack

whichmay throw ScopedCycleException

Tostart the schedulable object:

forevery scoped memory area in the

schedulableobject's scope stack

incrementthe reference count

runthe new schedulable object with the

newscope stack

whenthe schedulable object terminates

everymemory area pushed by the

schedulableobject will have been popped

forevery scoped memory area in the scope stack

decrementthe reference count

discardthe schedulable objects scope stack.

With

if cma is heap, immortal orImmortalPhysicalMemory

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 schedulableobject are symmetrical to constructing and starting it except that the memoryarea pushed in the constructor is popped when the schedulable objectterminates.�

The Single Parent Rule

300. change

Replaced: �below � With:�outside �

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

On Scope Stack Push of ma

301. change

Deleted: �ma.refCount++�

precondition:ma.parent is set to the correct parent

(eithera scoped memory area or the primordial scope) or to noParent

t.scopeStackis the scope stack of the current schedulable object

ifma is scoped

parent= findFirstScope(t.scopeStack)

ifma.parent == noParent

ma.parent= parent

elseif ma.parent != parent

throwScopedCycleException

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 scopestack can easily become a tree, and although� With: �Although �

304. change

Inserted: �. Also, although the scope stack�s behavior isspecified as a stack, an implementation is free to use any data structure thatpreserves the stack semantics�

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

MemoryArea class

Second Constructor

305. change

Inserted:�IllegalAssignmentError - Thrown if storing logic in this would violate theassignment rules�

IllegalAssignmentError456 - Thrown ifstoring logic in this would violatethe assignment rules.

Fourth Constructor

306. change

Inserted:�IllegalAssignmentError - Thrown if storing logic in this would violate theassignment rules�

IllegalAssignmentError456 - Thrown ifstoring logic in this would violatethe assignment rules.

enter() method

307. change

Replaced: �IllegalStateException� With: �IllegalThreadStateException �

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

308. change

Inserted: �ThrowBoundaryError - Thrown when the JVM needs topropagate an exception allocated in this scope to (or through) the memory areaof the caller. Storing a reference to that exception would cause anIllegalAssignmentError , so the JVM cannot be permitted to deliver theexception. The ThrowBoundaryError is allocated in the current allocationcontext and contains information about the exception it replaces.�

ThrowBoundaryError - Thrown when the JVM needs to propagate anexception allocated in this scope to (or through) the memory area ofthe 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 containsinformation about the exception it replaces.

enter(logic) method

309. change

Replaced: �IllegalStateException� With: �IllegalThreadStateException �

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

310. change

executeInArea(logic) method

311. change

Replaced: �If the memory area is a scoped memory type, thismethod 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 orimmortal memory, this method behaves as if the run method were running in thatmemory type with an empty scope stack� With: �MemoryArea�

Execute the run method from the logic parameter using thismemory 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 thememory area is heap or immortal memory, this method behaves as if the runmethod were running in that memory type with an empty scope stackMemoryArea.

314. change

Deleted: �InaccessibleAreaException - Thrown if the memoryarea 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 atype such as Integer�

316. change

Inserted: �(which would call for an array of the primitiveint type.)�

type - The classof 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 memoryarea is not in the schedulable object�s scope stack.�

newInstance(type) method

318. change

Deleted: �InaccessibleAreaException - Thrown if the memoryarea is not in the schedulable object�s scope stack.�

newInstance(c, args) method

319. change

Deleted: �InaccessibleAreaException - Thrown if the memoryarea is not in the schedulable object�s scope stack.�

HeapMemory class

executeInArea(logic) method

320. change

Insert method override:

Giving

publicvoid executeInArea(java.lang.Runnable logic)

Executethe run method from the logic parameter using heap as the current allocationcontext. For a schedulable object, this saves the current scope stack andreplaces it with one consisting only of the HeapMemoryinstance; restoring the original scopestack upon completion.

Overrides:executeInArea in class MemoryArea

Parameters:

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

Throws:

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

ImmortalMemory class

executeInArea(logic) method

321. change

Insert method override

Giving

publicvoid executeInArea(java.lang.Runnable logic)

Executethe run method from the logic parameter using this memory area as the currentallocation context. For a schedulable object, this saves the

currentscope 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() methodshould 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�

Throws:

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

ScopedMemory class

Description

324. change

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

Second Constructor

325. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Fourth Constructor

326. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

enter() method

327. change

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

328. change

Deleted: �invoked from �

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

enter(logic) method

329. change

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

330. change

Deleted: �invoked from �

java.lang.IllegalThreadStateException - Thrown when enter if the caller is invoked from aJava 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 orimmortal memory, this method behaves as if the run method were running in thatmemory type with an empty scope stack� With: �this�

Description copied from class: javax.realtime.MemoryArea

Execute the run method from the logic parameter using thismemory 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 contextdown the scope stack to the occurrence of the memory area. If the memory area is heap orimmortal memory, this method behaves as if the run method were running in thatmemory type with an empty scope stackthis.

335. change

Replaced: �IllegalStateException� With: �IllegalThreadStateException �

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

getPortal() method

336. change

Replaced: �the value from the portal is to an object in ascope that� With: �this �

IllegalAssignmentError - Thrown if areference to the portal object cannot be stored in the caller�s allocationcontext; that is, if the valuefrom 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 ifthe caller is a Java thread.�

join(time) method

338. change

Inserted: �Since the time is expressed as aHighResolutionTime , this method is an accurate timer with nanosecondgranularity. The actual resolution of the timer and even the quantity itmeasures depends on the clock associated with time. The delay time may berelative or absolute. If relative, then the delay is the amount of time givenby time, and measured by its associated clock. If absolute, then the delay isuntil the indicated value is reached by the clock. If the given absolute timeis less than or equal to the current value of the clock, the call to joinreturns immediately.�

339. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif the wait operation is not supported using the clock associated with time.�

joinAndEnter() method

340. change

Inserted: �If multiple threads are waiting in joinAndEnterfamily methods for a memory area, at most one of them will be released eachtime the reference count goes to zero.

Note that although joinAndEnter guarantees that thereference count is zero when the schedulable object is released for entry, itdoes not guarantee that the reference count will remain one for any length oftime. A subsequent enter could raise the reference count to two.�

joinAndEnter(time) method

341. change

Inserted: �If multiple threads are waiting in joinAndEnterfamily methods for a memory area, at most one of them will be released eachtime the reference count goes to zero.

Since the time is expressed as a HighResolutionTime, thismethod has an accurate timer with nanosecond granularity. The actual resolutionof the timer and even the quantity it measures depends on the clock associatedwith time. The delay time may be relative or absolute. If relative, then thecalling thread is blocked for at most the amount of time given by time, andmeasured by its associated clock. If absolute, then the time delay is until theindicated value is reached by the clock. If the given absolute time is lessthan or equal to the current value of the clock, the call to joinAndEnterreturns immediately.

342. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif the wait operation is not supported using the clock associated with time.�

joinAndEnter(logic) method

343. change

Inserted: �If multiple threads are waiting in joinAndEnterfamily methods for a memory area, at most one of them will be released eachtime the reference count goes to zero.

joinAndEnter(logic, time) method

344. change

Inserted: �Since the time is expressed as aHighResolutionTime , this method is an accurate timer with nanosecondgranularity. The actual resolution of the timer and even the quantity itmeasures depends on the clock associated with time. The delay time may berelative or absolute. If relative, then the delay is the amount of time given bytime, and measured by its associated clock. If absolute, then the delay isuntil the indicated value is reached by the clock. If the given absolute timeis less than or equal to the current value of the clock, the call to joinreturns immediately.�

345. change

Inserted: �If multiple threads are waiting in joinAndEnterfamily methods for a memory area, at most one of them will be released eachtime the reference count goes to zero.�

346. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif the wait operation is not supported using the clock associated with time.�

newArray(type, number) method

347. change

Replaced: �IllegalStateException� With: �IllegalThreadStateException �

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

newInstance(type) method

348. change

Replaced: �IllegalStateException� With: �IllegalThreadStateException �

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

newInstance(c, args) method

349. change

Replaced: �IllegalStateException� With: �IllegalThreadStateException �

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

setPortal(object) method

350. change

Inserted: �IllegalThreadStateException is thrown when calledby a Java thread even when the invocation could also throwIllegalArgumentException.�

351. change

Replaced: �the � With: �this �

InaccessibleAreaException - Thrown if the this memory areais not in the caller�s scope stack.

LTMemory class

Third Constructor

352. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Fourth Constructor

353. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Sixth Constructor

354. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Eighth Constructor

355. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

VTMemory class

Description

356. change

Replaced:�VTMemory� With: �LTMemory�

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

Third Constructor

357. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Fourth Constructor

358. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Sixth Constructor

359. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Eighth Constructor

360. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

PhysicalMemoryManager class

Description

361. change

Replaced: �The base implementation will provide aPhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes thatcorrectly identify memory classes that are standard for the (OS, JVM, andprocessor) platform.�

With: �The base implementation will provide aPhysicalMemoryManager.�

onRemoval(base, size, ae) method

362. change

Replaced:�aysnc � With: �async �

ae - The aysnc async event to register.

PhysicalMemoryTypeFilter class

onRemoval(base, size, ae) method

363. change

Replaced:�aysnc � With: �async �

ae - The aysnc async event to register.

ImmortalPhysicalMemory class

Third Constructor

364. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Fourth Constructor

365. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Sixth Constructor

366. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Eighth Constructor

367. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

LTPhysicalMemory class

Third Constructor

368. change

Inserted: �IllegalAssignmentError - Thrown if storinglogic in this would violate the assignment rules.�

Fourth Constructor

369. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Sixth Constructor

370. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Eighth Constructor

371. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

VTPhysicalMemory class

Third Constructor

372. change

Inserted: �IllegalAssignmentError - Thrown if storinglogic in this would violate the assignment rules.�

Fourth Constructor

373. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Sixth Constructor

374. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

Eighth Constructor

375. change

Inserted: �IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.�

RawMemoryAccess class

getByte(offset) method

376. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getBytes(offset, bytes, low, number) method

377. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getInt(offset) method

378. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getInts(offset, ints, low, number) method

379. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getLong(offset) method

380. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getLongs(offset, longs, low, number) method

381. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getShort(offset) method

382. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getShorts(offset, shorts, low, number) method

383. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setByte(offset, value) method

384. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setBytes(offset, bytes, low, number) method

385. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setInt(offset, value) method

386. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setInts(offset, ints, low, number) method

387. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setLong(offset. value) method

388. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setLongs(offset, longs, low, number) method

389. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setShort(offset, value) method

390. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setShorts(offset, shorts, low, number) method

391. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

unmap() method

392. change

Replaced:�block until one load or store completes� With: �throw anIllegalStateException�

Replaced: �It� With: �The unmap method �

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

RawMemoryFloatAccess class

getDouble(offset) method

393. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getDoubles(offset, doubles, low, number) method

394. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getFloat(offset) method

395. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

getFloats(offset, floats, low, number) method

396. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setDouble(offset, value) method

397. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setDoubles(offset, doubles, low, number) method

398. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setFloat(offset, value) method

399. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

setFloats(offset, floats, low, number) method

400. change

Inserted: �java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.�

MemoryParameters class

Second Constructor

401. change

Replaced:�allocationrate � With: �allocationRate �

allocationRate - A limit on the rate of allocation in theheap. 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 �

The classes in this section establish a framework for priorityinversion 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 thesubsection title

Replaced:�Default � With: �Base �

404. change

Replaced:�default � With: �base �

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

405. change

Inserted: �A thread or schedulable object that holds a lockon a PCE-governed object also has a ceiling priority.�

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

406. change

Deleted: �aninstance of �

� 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 maximumpriority for t�s thread group. If t is an instance of a schedulableobject, the new base priority is prio.

407. change

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

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

408. change

Replaced: �for� With: �resulting from �

Replaced:�section � With: �section, �

Replaced:�entity t � With: �object t, �

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

409. change

Inserted:�either synchronously or �

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

410. change

Replaced: �theactive � With: �a �

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

Replaced:�description of the setMonitorControl instance method�

With: �ceilingpriority �

Replaced: �adefinition of �active monitor control policy� With: �t�

Deleted: ��)�

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

411. change

Inserted: �Source: Each thread or schedulable object that isattempting to synchronize on an object locked by t and governed by aPriorityCeilingEmulation policy.

Associated priority: The maximum active priority over allsuch threads and schedulable objects

Note: This rule, which in effect allows aPriorityCeilingEmulation lock to behave like a PriorityInheritance lock, helpsavoid unbounded priority inversions that could otherwise occur in the presenceof nested synchronizations involving a mix of PriorityCeilingEmulation andPriority-Inheritance policies. �

412. change

Replaced:�should � With: �must �

413. change

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

Inserted: �Ifthe implementation is not supported�

Replaced: �Inany event � With: �If PriorityCeilingEmulation is not supported,�

Inserted:�queue placement �

414. change

Replaced:�preferred. � With: �recommended.�

6. The removal of a priority source for t either leaves t�s active priorityunchanged, or decreases it. If t�s active priority is unchanged, then t�s status in itsrelevant queue (e.g. blocked waiting for some object) is not affected. If t�s active priorityis decreased and t is either ready or running, then t should must be placed at the head of the readyqueue at its new active priority level, if the implementation is supporting PriorityCeilingEmulation. If theimplementation is not supporting PriorityCeilingEmulation then t should be placed atthe 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 implementationmust 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 activepriority level. Its position in the queue is implementation defined, butplacement 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 �

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

420. change

Replaced: �It is a consequence of other rules that if athread or schedulable object t holds a PriorityCeilingEmulation lock, then itwill not inherit a priority, nor have a new priority assigned, that exceeds thelock�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 athread or schedulable object t attempts to synchronize on an object objgoverned by a PriorityCeilingEmulation policy with ceiling ceil, then t�sactive 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 alsoexceed obj�s monitor control policy�s ceiling. Note that t�s base priorityand/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 thatapply to threads or schedulable objects managed by a scheduler other than the default base priority schedulerwhen they synchronize on objects with monitor control policies defined in thissection.

Rationale

422. change

Replaced:�priority inversions � With: �dependencies �

Replaced: �result (to prevent heap corruption when thegarbage collector has been preempted) when the object is governed byPriorityInheritance� With: �result�

Since the same object may be accessed from synchronized code byboth a NoHeapRealtimeThreadandan arbitrary thread or schedulable object, unwanted priority inversions dependencies may result (to preventheap corruption when the garbage collector has been preempted) when the objectis governed by PriorityInheritanceresult. To avoid this problem, this specification providesthree wait-free queue classes as an alternative means for safe, concurrent dataaccesses without priority inversion.

MonitorControl class

getMonitorControl(obj) method

423. change

Deleted: �base�

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

424. change

Replaced:�monitor � With: �obj �

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

setMonitorControl(policy) method

425. change

Replaced:�Unlike � With: �Like �

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

426. change

Replaced:�SecurityException � With: �IllegalArgumentException �

Replaced: �thecaller � With: �policy �

Replaced: �permitted to alter the default monitor controlpolicy� With: �in immortal memory�

java.lang.SecurityException IllegalArgumentException - Thrown if the caller policyis not permitted to alter the default monitorcontrol policyin immortalmemory.

427. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif policy is not a supported monitor control policy.�

setMonitorControl(obj, policy) method

428. change

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

With: �Immediately sets policy as the monitor control policyfor obj.

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

429. change

Deleted:�active �

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

430. change

Deleted: �java.lang.IllegalArgumentException - Thrown whenmonitor is null.�

431. change

Inserted: �java.lang.IllegalArgumentException - Thrown whenobj is null or policy is not in immortal memory.�

432. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif policy is not a supported monitor control policy.�

433. change

Inserted: �java.lang.IllegalMonitorStateException - Thrownif the caller does not hold a lock on obj.�

PriorityCeilingEmulation class

Description section

434. change

Inserted: �In order for this protocol to have the desiredeffect in terms of avoiding unbounded priority inversions and preventingdeadlock, the implementation must perform the following checks when a thread orschedulable object t attempts to synchronize on a target object governed by aPriorityCeilingEmulation policy with ceiling ceil:

� t�s base priority does not exceed ceil

� t�s ceiling priority (if t is holding any otherPriorityCeilingEmulation locks) does not exceed ceil.�

Deleted: �In order for this protocol to have the desiredeffect in terms of controlling priority inversions, the active priority of athread or schedulable object attempting to synchronize on, or alreadysynchronized 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 couldsynchronize on targetObj.�

With: �the following values:

� the highest base priority of any thread or schedulableobject that could synchronize on targetObj

� the maximum ceiling priority value that any thread orschedulable object could have when it attempts to synchronize on targetObj.�

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

� the highest base priority of any thread or schedulable objectthat could synchronize on targetObj

� the maximum ceiling priority value that any thread or schedulableobject could have when it attempts to synchronize on targetObj.

436. change

Deleted: �If a thread or schedulable object t whose activepriority is p1 attempts to synchronize on an object governed by aPriorityCeilingEmulation policy with ceiling p2, where p1>p2, then aCeilingViolationException is thrown in t. Further, if a thread or schedulableobject t2 is synchronized on an object governed by a PriorityCeilingEmulationpolicy with ceiling p2, and is also synchronized on an object obj governed by aPriorityInheritance policy, then if some other thread or schedulable object t1whose active priority p1 exceeds p2 attempts to synchronize on obj, then aCeilingViolationException is thrown in t1 (and thus t2�s active priorityremains at the ceiling value p2).�

437. change

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

Replaced: �set the priority of a thread or schedulableobject t2 to a value p1, while t2 holds a lock� With: �synchronize �

Replaced: �t1� With: �t�

Replaced: �(See the rules � With: �ACeilingViolationException is likewise thrown �

Replaced: �the Semantics � With: �t if t is holding aPriorityCeilingEmulation lock�

Replaced: �Requirements section in this chapter for the listof the three priority-setting methods.)� With: �has a ceiling priorityexceeding p1�

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

synchronize on an object governed by a PriorityCeilingEmulation policy withceiling p2,wherep1>p2,thena CeilingViolationExceptionisthrown in t1t. (See the rules A CeilingViolationException is likewise thrown in the Semantics t if t is holding a PriorityCeilingEmulationlock and Requirements sectionin this chapter for the list of the three priority-setting methods.) has a ceilingpriority exceeding p2.

438. change

Inserted: �A consequence of the above rule is that a threador schedulable object may nest synchronizations onPriorityCeilingEmulation-governed objects as long as the ceiling for the innerlock is not less than the ceiling for the outer lock. The possibility of nestedsynchronizations on objects governed by a mix of PriorityInheritance andPriorityCeilingEmulation policies requires one other piece of behavior in orderto avoid unbounded priority inversions. If a thread or schedulable object holdsa PriorityInheritance lock, then any PriorityCeilingEmulation lock that iteither holds or attempts to acquire will exhibit priority inheritancecharacteristics. This rule is captured above in the definition of prioritysources (4.d).�

Deleted: �This invocation sets obj� obj�s base policy, whichbecomes the active policy when obj is unlocked and has an empty wait set. (Seeclass MonitorControl).�

Deleted: �Note that when defining the ceiling for a givenobject obj, the programmer cannot simply use the maximum of the base prioritiesof all threads and schedulable objects that could lock obj; the activepriorities of such threads and schedulable objects � in particular theinheritance of priority from other threads and schedulable objects �needs to be taken into account.�

getMaxCeiling() method

439. change

Deleted: �with�

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 allocatedin memory (e.g., immortal memory) that is unexceptionally referenceable fromevery execution context; most significantly heap and non-heap.�

With: �The PriorityInheritance instance shall be allocatedin ImmortalMemory.�

WaitFreeWriteQueue class

Description section

441. change

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

442. change

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

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

443. change

Inserted (actually moved from above): �WaitFreeWriteQueue isone of the classes allowing NoHeapRealtimeThreads and regular Java threads tosynchronize on an object without the risk of a NoHeapRealtimeThread incurringGarbage Collector latency due to priority inversion avoidance management.�

Third Constructor

444. change

Inserted: �andboth 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 immortalmemory�

Replaced:�queues � With: �queue �

The writer and reader parameters, if non-null, are checked to insure that they arecompatible 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 nearestcommon scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all threeparameters are null, the queues queue will be allocated in immortal memory.

446. change

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

force(object) method

447. change

Replaced: �MemoryScopeException - Thrown if a memory accesserror occurs.�

With:

�MemoryScopeException - Thrown if a memory access error orillegal 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: � duringthe time between calling this method and returning from it�

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

write() method

450. change

Replaced: �MemoryScopeException - Thrown if a memory accesserror occurs.�

With: �MemoryScopeException - Thrown if a memory accesserror or illegal assignment error would occur while storing object in thequeue.�

WaitFreeReadQueue class

Description section

451. change

Deleted (actually moved): �WaitFreeReadQueue is one of theclasses allowing NoHeapRealtimeThreads and regular Java threads to synchronizeon an object without the risk of a NoHeapRealtimeThread incurring GarbageCollector 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. TheWaitFreeReadQueue class is intended for single-reader multiple-writercommunication, although it may also be used (with care) for multiple readers

453. change

Inserted (actually moved): �WaitFreeReadQueue is one of theclasses allowing NoHeapRealtimeThreads and regular Java threads to synchronizeon an object without the risk of a NoHeapRealtimeThread incurring GarbageCollector latency due to priority inversion avoidance management.�

Third Constructor

454. change

Changed the type of the reader and writer arguments fromThread 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 immortalmemory�

457. change

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

Fourth Constructor

458. change

Changed the type of the reader and writer arguments fromThread to Runnable

459. change

Inserted: �andboth 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 immortalmemory�

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

461. change

Replaced: �If� With: �Thrown if �

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

462. change

Inserted: �InnaccessibleAreaException - Thrown if memory isa 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 methodand returning from it.�

java.lang.InterruptedException- Thrown if the method thread isinterrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the timebetween 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�

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

469. change

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

WaitFreeDequeue class

Description section

470. change

Deleted (actually moved): �WaitFreeDequeue is one of theclasses allowing NoHeapRealtimeThreads and regular Java threads to synchronizeon an object without the risk of a NoHeapRealtimeThread incurring GarbageCollector latency due to priority inversion avoidance management.�

Inserted (actually moved): �WaitFreeDequeue is one of theclasses allowing NoHeapRealtimeThreads and regular Java threads to synchronizeon an object without the risk of a NoHeapRealtimeThread incurring GarbageCollector latency due to priority inversion avoidance management.�

Constructor

471. change

Changed the type of the writer and reader arguments fromThread to Runnable

472. change

Inserted: �andboth 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 immortalmemory�

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

473. change

Inserted: �InnaccessibleAreaException - Thrown if memory isa 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 thethread is interrupted by interrupt() orAsynchronouslyInterruptedException.fire() during the time between calling thismethod and returning from it.�

476. change

Deleted: �MemoryScopeException - Thrown if the memory areacontaining the queues is incompatible with the current context.�

blockingWrite(object) method

477. change

Added �throws InterruptedException�

478. change

Replaced: �MemoryScopeException - If the write causes anaccess or assignment violation.�

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

479. change

Inserted: �java.lang.InterruptedException - Thrown if thethread 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 orillegal assignment error would occur while storing object in the queue.�

nonBlockingRead() method

481. change

Replaced: �MemoryScopeException - If the write causes anaccess or assignment violation.�

With:

�MemoryScopeException - Thrown if a memory access error orillegal assignment error would occur while storing object in the queue.�

Time Chapter

Definitions section

482. change

Replace: �The following terms and abbreviations will beused:

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

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

The Epoch is the standard base time, conventionally January1 00:00:00 GMT 1970. It is the point from which the real-time clock measuresabsolute time.

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

The normalized (canonical) form for time objects uniquelyspecifies the values for the millisecond and nanosecond components of a pointin time, including the case of 0 milliseconds or 0 nanoseconds, and a negativetime 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 defaultit is associated with the real-time clock.

The Epoch is the standard base time, conventionally January1 00:00:00 GMT 1970. It is the point from which the real-time clock measuresabsolute time.

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 bymethods that perform time object addition and subtraction. Operations areexecuted using the appropriate arithmetic precision. If the finalresult of the an operation can be represented in normalized form, then the operationmust not throw arithmetic exceptions while producing intermediate results.

HighResolutionTime Class

equals(time) method

485. change

Replaced: �Equality includes clock association� With: �Equality includes clockassociation. �

equals(object) method

486. change

Replaced: �Equality includes clock association� With: �Equality includes clockassociation. �

set(time) method

487. change

Inserted: �time parameter is null this method will throwIllegalArgumentException. If the�

488. change

Replaced: �This method ignores the possible discrepancybetween the� With: �The �

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

Deleted: �, retaining the original clock clock associationwith this�

In:

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

489. change

Inserted: �java.lang. IllegalArgumentException - Thrown theparameter time is null.

waitForObject(target, time) method

490. change

Inserted: �As for target.wait(), there is the possibility ofspurious wakeup behavior.

The wait time may be relative or absolute, and it iscontrolled by the clock associated with it. If the wait time is relative, thenthe calling thread is blocked waiting on target for the amount of time given bytime, and measured by the associated clock. If the wait time is absolute, thenthe calling thread is blocked waiting on target until the indicated time valueis reached by the associated clock.�

491. change

Replaced: �

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

With:

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

492. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif 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 thereal-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�

The result will have the same clock association as this. An ArithmeticExceptionisthrown if there is an overflow the result does not fit in the result afternormalizationnormalized format.

495. change

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

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

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�

The result will have the same clock association as this, and the clockassociation with dest is ignored. An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An IllegalArgumentException is thrown if the time parameter is null. An ArithmeticExceptionisthrown if there is an overflow the result does not fit in the result afternormalizationnormalized format.

499. change

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

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

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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: �relativetime gives an overflow after normalization� With: �normalized format�

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�

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: �thisdoes not have �

Replaced:�concept of date� With: �real-time clock�

An UnsupportedOperationException Illegal- ArgumentException is thrown if the parameter date is null. The clock associated association is implicitlymade withthis does not have the concept of datereal-time clock.

505. change

Deleted:�UnsupportedOperationException Thrown if the clock associated with this doesnot 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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

java.lang.ArithmeticException - Thrown if there is anoverflow the result does not fit in the result after normalizationnormalizedformat.

subtract(reltime, dest) method

513. change

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

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

An ArithmeticException is thrown if there is an overflowtheresult 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�

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 �

The string shall be a decimal reprepresentation representation of the millisecondsand nanosecond values; formatted as follows �(2251 ms, 750000 ns)�

RelativeTime class

Description section

516. change

Deleted: �Although logically, and correctly, this mayrepresent time before the epoch, an instance of RelativeTime representing timebefore 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 timebefore the epoch may cause some methods to throw an IllegalArgumentException. For add and subtract negative valuesbehave as they do in arithmetic.

absolute(clock) method

517. change

Inserted: �Throws:

java.lang.ArithmeticException - Thrown if the result doesnot fit in the normalized format.�

absolute(clock, dest) method

518. change

Inserted: �Throws:

java.lang.ArithmeticException - Thrown if the result doesnot fit in the normalized format.

add(millis, nanos) method

519. change

Replaced: �thereis an overflow � With: �the result does not fit �

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

An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An ArithmeticException is thrown if there is an overflowtheresult does not fit in the result after normalizationnormalized format.

526. change

Replaced: �thereis an overflow � With: �the result does not fit �

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

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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�

An ArithmeticException is thrown if there is an overflowtheresult 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�

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 �

The string shall be a decimal reprepresentation representation of themilliseconds 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 ornanosecond fields is negative the variable is set to negative value. Althoughlogically this may represent time before the epoch, invalid results may occurif an instance of AbsoluteTime representing time before the epoch is given as aparameter to the a method.�

Clocks and Timers Chapter

Definitions section

533. change

Replace: �The counting time is the time accumulated whileactive by a Timer whose initial firing time has been specified as aRelativeTime. The counting time is zeroed at the occurrence of any firing orskipping.

NOTE: A PeriodicTimer whose initial firing has beenspecified as an AbsoluteTime self-reschedules in an absolute manner, even ifthe interval or period is always specified as a RelativeTime, by adding theinterval or period to the time of the last firing or skipping.�

With: �The counting time is the time accumulated whileactive by a Timer created or rescheduled using a RelativeTime to specify theinitial firing/skipping time. The counting time is zeroed at the beginning ofan activation, or when rescheduled, while active, before the initialfiring/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 stopmay be understood as start counting again from where stopped, or start fromscratch after resetting the count. In both cases a delay is introduced. An RTSJTimer, when using the counter model, resets the count when it is re-startedafter being stopped.

� Timer modeled as counter: The timer is viewed as if everyclock interrupt increments a count up to the firing count, initially given byeither an instance of RelativeTime or computed as the difference between aninstance of AbsoluteTime and a semantically specified �now� (using the sameclock).�

535. change

Made a list bullet of: �An RTSJ Timer, when using the counter model, resets thecount when it is re-started after being stopped.�

536. change

Deleted: In this model, start is understood as startcomparing, and possibly the first start is understood as defining �now�. stopis understood as stop comparing. start after stop may be understood as startcomparing again. In this case no delay is introduced.

� Timer modeled as comparator: The timer is viewed as if everyclock 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 ofan instance of RelativeTime and a semantically specified �now� (using the sameclock).�

537. change

Replaced: �The first firing or skipping of a PeriodicTimershall be at the beginning of the first interval, however specified.Subsequently, the PeriodicTimer timer will fire or skip at period times set ormeasured from the last firing or skipping.�

With: �The initial firing, or skipping, of a PeriodicTimeroccurs in response to the invocation of its start method, in accordance withthe start time passed to its constructor. This initial firing, or skipping, maybe rescheduled by a call to the reschedule method, in accordance with the timepassed to that method.�

538. change

Replaced �If a timer is made active after the initial firingor skipping is due, the first firing or skipping shall occur immediately.

NOTE: The transition to not-active by a timer with aninitial firing time specified as a RelativeTime causes the counting time toreset, effectively preventing a timer with an initial firing time specified asa 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 orskipping of a PeriodicTimer is scheduled to occur:

i. If the start, or reschedule, time was given as anabsolute 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 ismade active, then S equals the time at which the timer was made active.

ii. If the start, or reschedule, time was given as arelative time, R, then S equals the time at which the counting time, startedwhen the timer was made active, equals R.

NOTE: The transition to not-active by this timer causes thecounting time to reset, effectively preventing this kind of timer from firingimmediately, unless given a time value of 0.

b. The firings, or skippings, of a PeriodicTimer arescheduled to occur according to S+nT, for n = 0, 1, 2 ..., where S is as justspecified, and T is the interval of the periodic timer.�

539. change

Insert semantic: �A Timer object will not fire before itsdue 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�

There is always at least one clock object available: a the system real-time clock that advancesin sync with the external worldclock. This is the default Clock.

setResolution(resolution) method

542. change

Replaced: �resolution - The new resolution of this. Theclock association of the resolution parameter is ignored�

With: �resolution - The new resolution of this, if therequested value is supported by this clock. If resolution is smaller than theminimum resolution supported by this clock then it throwsIllegalArgumentException. If the requested resolution is not available and it islarger than the minimum resolution, then the clock will be set to the closestresolution that the clock supports, via truncation. The value of the resolutionparameter is not altered. The clock association of the resolution parameter isignored.�

543. change

Inserted: �java.lang.IllegalArgumentException - Thrown ifresolution is null, or if the requested resolution is smaller than the minimumresolution supported by this clock.�

Timer class

Description section

544. change

Replaced:�relative � With: �according �

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 beinterpreted 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�

start ->

[if last_rescheduled_with_AbsoluteTime

then

[set startTimetargetTime = currentTimenextTargetTime

and[if set targetTime =< nextTargetTimecurrentTime

then goset totargetTime state= {active,enabled, absolute}currentTime]

then go to state {active, enabled, absolute}]

else

[set startTimecountingTime = currentTime0

and set countingTimedurationTime =0nextDurationTime

and setdurationTime = nextDurationTime

then goto 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: �[�

startDisabled->

[if last_rescheduled_with_AbsoluteTime

then

[set startTimetargetTime = currentTimenextTargetTime

[setif startTimetargetTime =< currentTime

and then set targetTime = nextTargetTimecurrentTime]

then goto state {active, disabled, absolute}]

else

[set startTime =currentTimeelse

and [set countingTime = 0

and setdurationTime = nextDurationTime

then goto 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: �[�

start ->

[if last_rescheduled_with_AbsoluteTime

then

[set targetTime= nextTargetTime

[setif startTimetargetTime =< currentTime

andthen set targetTime = nextTargetTimecurrentTime]

then go to state {active, enabled,absolute}]

[set startTime= currentTimeelse

and [set countingTime = 0

and setdurationTime = nextDurationTime

then goto 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�

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�

{active,enabled, absolute}

[if currentTime >= targetTime

then

[ifPeriodicTimer

then

[ifperiod > 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 goto state {not-active, disabled, absolute}]]

else

[itis a OneShotTimer so

fire

and go tostate {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 -> throwsIllegalStateException

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�

reschedule ->

[if NOT fired_or_skipped_in_current_activation

then

[if using an instance ofAbsoluteTime

then

[reset thetargetTime to absoluteTime arg

and re-entercurrent state]

else

[reset thedurationTime to relativeTime arg

[reset theand durationTimeset tocountingTime relativeTime= arg0

and go tostate {active, enabled, relative}]]

else

[if using aninstance of AbsoluteTime

then

[reset the nextTargetTime to absoluteTime arg

and setlast_rescheduled_with_AbsoluteTime = TRUE

and no statechange]

else

[reset the nextDurationTime to relativeTime arg

and setlast_rescheduled_with_AbsoluteTime = FALSE

and no statechange]]]

552. change

Replaced: �and� With: � via durationTime =�

Replaced:�re-enter� With: �(durationTime�

Replaced:�current� With: �+�

Replaced:�state]� With: �period)�

Replaced:�enabled� With: �enable�

[if countingTime >= durationTime

then

[if PeriodicTimer

then

[ifperiod > 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 tostate {not-active, disabled, relative}]]

else

[it is aOneShotTimer 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]]�

[if using aninstance of AbsoluteTime

then

[reset the targetTime toabsoluteTime arg

and go to state {active,enabled, absolute}]

else

[reset the durationTime torelativeTime arg

and re-enterset countingTime current= state]]0

and re-entercurrent state]]

554. change

Deleted: �return (startTime +durationTime)�

Deleted:�getFireTime�

Deleted:�->�

Replaced:�startTime� With: �currentTime�

Inserted: � -countingTime�

[if using an instance ofAbsoluteTime

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 -> throwsIllegalStateException

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]�

[if period >0

then

[skip

and setfired_or_skipped_in_current_activation = TRUE

and selfreschedule

and via targetTime = reenter(

targetTime current+ state]period)

and re-entercurrent state]

556. change

Replaced:�disabled� With: �disable�

enable -> goto state {active, enabled, absolute}

disableddisable -> no state change, do nothing

stop -> [goto 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 NOTfired_or_skipped_in_current_activation

then

[if using aninstance of AbsoluteTime

then

[reset thetargetTime to absoluteTime arg

and re-enter current state]

else

[reset thedurationTime 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)�

{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 aOneShotTimer so

skip

and go to state {not-active, disabled, relative}]]]

559. change

Replaced:�disabled� With: �disable�

enable -> goto state {active, enabled, relative}

disableddisable -> no state change, do nothing

stop -> [goto 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�

reschedule ->

[if NOTfired_or_skipped_in_current_activation

then

[if using aninstance of AbsoluteTime

then

[reset thetargetTime to absoluteTime arg

and go tostate {active, disabled, absolute}]

else

[reset thedurationTime to relativeTime arg

[reset theand durationTimeset tocountingTime relativeTime= arg0

and re-entercurrent state]]

561. change

Inserted: �getFireTime ->�

Deleted:�getFireTime�

Deleted:�->�

Replaced:�startTime� With: �currentTime�

Inserted: � -countingTime�

getFireTime ->

getFireTime -> return (startTimecurrentTime + durationTime -

countingTime)

destroy -> go to state {destroyed}

startDisabled -> throws IllegalStateException

562. change

Replaced:�disabled� With: �disable�

{destroyed}

enable | disableddisable| stop | start | isRunning

| reschedule | getFireTime | destroy

| startDisabled -> throwsIllegalStateException

Timer Constructor

563. change

Inserted: �.The clock associated with the parameter time is always ignored�

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 thetimer 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 hasbeen destroyed.�

bindTo() method

566. change

Added override: �Should not be called.

Throws:

java.lang.UnsupportedOperationException - Thrown if bindTois 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�

Stop this from counting or comparing if active, remove from it allthe associated handlers if any, and release as many of its resources aspossible back to the system. Every method invoked on a Timer that has been destroyedwillthrow IllegalStateException.

569. change

Inserted: �Throws: java.lang.IllegalStateException - Thrownif this Timer has been destroyed.�

disable() method

570. change

Replaced: �notenabled� With: �already disabled, whether it it is active or not-active�

These semantics imply also that firings are not queued. Using theabove example, if enable was called at time 43 no firing will occur, since attime 42 thiswas disabled. If the Timer is not enabledalready disabled, whether it is activeornot-active, this method does nothing.

enable() method

571. change

Replaced: �notdisabled� With: �already enabled, this method does nothing. If the Timeris not-active�

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 doesnothing

getFireTime() method

572. change

Replaced �Returns: An instance of AbsoluteTime objectrepresenting the absolute time at which this is expected to fire or to skip. Ifthe timer has been created or re-scheduled (see reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will returnthe sum of such time and the start time. The clock association of the returnedtime is the clock on which this timer is based.�

With: �Returns: The absolute time at which this is expectedto fire or to skip, in a newly allocated AbsoluteTime object. If the timer hasbeen created or re-scheduled (see reschedule(HighResolutionTime)) using aninstance of RelativeTime for its time parameter then it will return the sum ofthe current time and the RelativeTime remaining time before the timer isexpected to fire/skip. The clock association of the returned time is the clockon which this timer is based.�

573. change

Inserted: �java.lang.ArithmeticException - Thrown if theresult does not fit in the normalized format.�

getFireTime(fireTime) method

574. change

Added method:

Getthe time at which this Timeris expected tofire. If the Timeris disabled, the returned time is that ofthe skipping of the firing. If the Timer is

not-activeit 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 theresult.

Returns: The instance of AbsoluteTime passed as parameter, with time valuesrepresenting the absolute time at which this is expected to fire or to skip. If the fireTime parameter is null the result isreturned in a newly allocated object. If the timer has been created orre-scheduled (see reschedule(HighResolutionTime)) using an instance of RelativeTime for its timeparameter then it will return the sum of the current time and the RelativeTime remaining timebefore the timer is expected to fire/skip. The clock association of thereturned time is the clock on which this timer is based.

Throws:

java.lang.ArithmeticException - Thrown if the result does not fit inthe 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 hasbeen destroyed.�

isRunning() method

576. change

Inserted: �Throws:

java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.�

removeHandler() method

577. change

Added override

Inserted �Throws:

java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.�

reschedule() method

578. change

Replaced:�re-scheduling � With: �rescheduling �

The re-scheduling rescheduling will take place between the invocation and the return of themethod.

579. change

Deleted: � NOTE: While the scheduled time is changed asdescribed 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 asdescribed above, the rescheduling itself is applied only on the first firing(or on the first skipping if disabled) of a timer�s activation. If rescheduleis invoked after the current activation timer�s firing, then the rescheduledtime will be effective only upon the next start or startDisabled command (whichmay need to be preceded by a stop command).

If reschedule is invoked with a RelativeTime time on anactive timer before its first firing/skipping, then the rescheduledfiring/skipping time is relative to the time of invocation.�

580. change

Inserted: �.The clock associated with the parameter time is always ignored�

time - The time to reschedule for this eventfiring. If time is null, theprevious 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 timeis anegative RelativeTimevalue.�

setHandler() method

582. change

Added override.

Inserted: �java.lang.IllegalStateException - Thrown if thisTimer has been destroyed.�

OneShotTimer class

Description section

583. change

Replaced:�retains the enabled or disabled state it had at expiration time� With:�disabled�

After expiration, the OneShotTimer becomes not-activeandretainsthe enabled or disabled state it had at expiration timedisabled. If the clocktime has already passed the timeout time, it will fire immediately after it isstarted or after it is rescheduled while active

First Constructor

584. change

Replaced: �atwhich � 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 tostart()�

time - The time at which usedto determine when to fire thehandler is releasedevent. A null time value of time null is equivalent to a relative time RelativeTimeof 0, and in this case the Timer fires immediately upon a call to start().

585. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif the timer functionality cannot be supported using the clock associated withtime.�

Second Constructor

586. change

Replaced: �atwhich � 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()�

587. change

Replaced: �clock - The timer will be based on this clock. Ifthe 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 systemRealtime clock is used. The clock associated with the parameter time is alwaysignored.�

588. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif 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, thePeriodicTimer will only fire once, unless restarted after expiration, behavinglike for a OneShotTimer. In all cases, if thetimer is disabled when the firing time is reached, that particular firing islost (skipped). If enabled at a later time, it will fire at its next scheduledtime.�

590. change

Insert a paragraph break after �immediately after it isstarted�

In:

If the clock time has already passed the beginning of thefirst period, the PeriodicTimer will fire immediately after it is started.

If one of the HighResolutionTime argument types isRationalTime (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 �

start - The time that specifies when the firstinterval begins, based on the clock associated with it. If A start value of null is null then equivalent toa 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 PeriodicTimerthe method Timer.getClock() returns the clock to which the interval isassociated with, even when the time value of interval is zero and thePeriodicTimer firing behavior is that of a OneShotTimer�

interval - The period of the timer. Its usage isbased on the clock associated with it. If interval is zerozero or null, the period is ignored and the firingbehavior of the PeriodicTimer is the one of a OneShotTimer . For a PeriodicTimer the method Timer.getClock() returns the clock to which the interval isassociated with, even when the time value of interval iszero and the PeriodicTimer firing behavior is that of a OneShotTimer.

593. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif the timer functionality cannot be supported using the clock associated withstart 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 �

595. change

Replaced:�zero� With: �zero or null�

Replaced: �theone � With: �that �

interval - The period of the timer. Its usage isbased 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 theinterval. For a PeriodicTimer the method Timer.getClock() returns the clockused to time the interval, even when the time value of interval is zero and thePeriodicTimer firing behavior is that of a OneShotTimer.�

With: �clock - The clock to be used to time the interval. Ifnull, the system Realtime clock is used. The Clock association of the parameterinterval is always ignored.�

597. change

Inserted: �java.lang.UnsupportedOperationException - Thrownif the timer functionality cannot be supported using the clock associated withstart or the given clock.�

createReleaseParameters() method

598. change

Replaced: �Create a ReleaseParameters object with the nextfire time as the start time and the interval of this as the period.�

With: �Create a release parameters object with new objectscontaining copies of the values corresponding to this timer. When the PeriodicTimerinterval is greater than 0, create a PeriodicParameters object with a starttime and period that correspond to the next firing (or skipping) time, andinterval, of this timer. When the interval is 0, create an AperiodicParametersobject, since in this case the timer behaves like a OneShotTimer.

If this timer is active, then the start time is the nextfiring (or skipping) time returned as an AbsoluteTime. Otherwise, the starttime is the initial firing (or skipping) time, as set by the last call toreschedule, or if there was no such call, by the constructor of this timer.�

599. change

Replaced: �Returns: A new instance of ReleaseParameters witha value corresponding to the release characteristics of this timer.�

With �Returns: A new release parameters object with newobjects containing copies of the values corresponding to this timer. If theinterval is greater than zero, return a new instance of PeriodicParameters. Ifthe interval is zero return a new instance of AperiodicParameters.�

getClock() method

600. change

Inserted override of getClock

Inserted: �Returns the instance of Clock that thePeriodicTimer interval is associated with at the time of the call, even whenthe time value of interval is zero and the PeriodicTimer firing behavior is thatof a OneShotTimer.

Returns: The instance of Clock that the interval isassociated with at the time of the call.

Throws:

java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.�

getFireTime() method

601. change

Replaced: �Gets the absolute time this will next fire.�

With: �Get the time at which this PeriodicTimer is nextexpected to fire or to skip. If the PeriodicTimer is disabled, the returnedtime is that of the skipping of the firing. If the PeriodicTimer is not-activeit throws IllegalStateException.�

602. change

Replaced: �Returns: A new AbsoluteTime instance with thevalue at which this is expected to fire.�

With: �Returns: The absolute time at which this is nextexpected to fire or to skip, in a newly allocated AbsoluteTime object. If thetimer has been created or re-scheduled (seeTimer.reschedule(HighResolutionTime)) using an instance of RelativeTime for itstime parameter then it will return the sum of the current time and theRelativeTime remaining time before the timer is expected to fire/skip. Within aperiodic timer activation, the returned time is associated with the start clockbefore the first fire (or skip) time, and associated with the interval clockotherwise.�

603. change

Inserted: �java.lang.ArithmeticException - Thrown if theresult does not fit in the normalized format.�

604. change

Replaced: �in a not-active state� With: �not-active�

java.lang.IllegalStateException- Thrown ifthis PeriodicTimerhas been destroyed, or if it is in a not-active statenot-active.

getInterval() method

605. change

Replaced: �A new� With: �The�

A newTheRelativeTimeinstancewith the value of this timer�s interval.

setInterval(interval) method

606. change

Replaced: �Thesemantics of the update are the same� With: �A null interval is interpreted �

Replaced: �forupdating the period of a real-time thread� With: �RelativeTime�

Replaced: �Seethe semantics of the priority scheduler� With: �0,0.�

interval - A RelativeTime object which is the interval used to resetthis Timer. The semantics ofthe update are the same A null interval is interpreted as for updatingthe 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 (orskipping) 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 intervalcurrently in use. Resetting the interval of an active periodic timer onlyeffects future fire (or skip) times after the next.�

Asynchrony Chapter

Semantics and Requirements for Asynchronous Events and their Handlerssection

608. change

Inserted:�active �

2. The release of attached handlers occurs in executioneligibility order (priority order with the default PriorityScheduler) and at the active priority of theschedulable object that invoked the fire method.

609. change

Deleted: �If an AI-method is attempting to acquire an objectlock when an associated AIE is generated, the attempt to acquire the lock isabandoned immediately�

And Inserted as a new semantic: �If an AI-method isattempting to acquire an object lock when an associated AIE is generated, theattempt to acquire the lock is abandoned.�

AsyncEvent class

addHandler(handler) method

610. change

Replaced:�schedule� With: �system�

Since this affects the constraints expressed in the releaseparameters of an existing schedulable object, this may change the feasibilityof the current schedulesystem.

removeHandler(handler) method

611. change

Replaced:�schedule� With: �system�

Since this affects the constraints expressed in the releaseparameters of an existing schedulable object, this may change the feasibilityof the current schedulesystem.

setHandler(handler) method

612. change

Replaced:�schedule� With: �system�

Since this affects the constraints expressed in the releaseparameters of the existing schedulable objects, this may change the feasibilityof the current schedulesystem.

AsyncEventHandler class

Description section

613. change

Deleted:�default �

The default scheduler for an asynchronous event handler is inherited from thethread/schedulable object that created it. If it was created from a Javathread, the default scheduler is the current default scheduler.

BoundAsyncEventHandler class

Second constructor

614. change

Replaced:�BAEH�s � With: �BAEH�s �

release - A ReleaseParameters object which will be associated with theconstructed instance. If null, thiswill have default ReleaseParameters for the BAEH�s BAEH�sscheduler.

Replaced:�BAEH�s � With: �BAEH�s �

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: �ifso, �

Replaced: �theexception � With: �it �

Replaced:�pending if it is current� With: �pending�

Atomically see if this is pending on the current exception is this currently executingschedulable object, and if so, make the exception it nonpending if it is currentpending.

616. change

Replaced: �thecurrent exception� With: �pending�

Returns: True if this was the current exceptionpending. False if this was not the currentexceptionpending.

doInterruptible() method

617. change

Inserted: �The run method of given Interruptible is alwaysentered with the exception in the enabled state, but that state can be modifiedwith 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 acall to doInterruptible() in progress. If invoked when no call todoInterruptible() is in progress, enable returns false and does nothing.�

619. change

Replaced:�with � With: �in the context of �

Replaced: �)in progress� With: �)�

Returns: True if this is enabled and the method call wasinvoked with in the context of the associated doInterruptible() in progress). Falseotherwise.

System and Options Chapter

POSIXSignalHandler class

Description section

620. change

Replaced:�AsyncEvent� With: �AsyncEventHandler�

Use instances of AsyncEvent398AsyncEventHandler402 to handle POSIXsignals.

addHandler(signal, handler) method

621. change

Deleted:�AsyncEvent of the �

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�

java.lang.IllegalArgumentException - Thrown if signal is not known bythis classclass or if handler is null.

Replaced:�IllegalArgumentException � With: �UnsupportedOperationException �

Deleted: �not�

Replaced: �by� With: �to �

Inserted: �,but not supported on this implementation�

java.lang.IllegalArgumentException UnsupportedOperationException - Thrown if signal is not known by to this class, but notsupported on this implementation.

removeHandler(signal, handler) method

623. change

Deleted: �of the AsyncEvent�

Remove the given AsyncEventHandler402 from the list of handlers of the AsyncEventof the given signal.

624. change

Replaced:�class� With: �class or if handler is null�

java.lang.IllegalArgumentException - Thrown if signal is not known bythis classclass or if handler is null.

setHandler(signal, handler) method

625. change

Deleted:�AsyncEvent of the �

Set the given AsyncEventHandler as the handler of the AsyncEvent of the given signal.

626. change

Inserted: �java.lang.UnsupportedOperationException-Thrown if signalisknown to this class, but not supported on this implementation.�

RealtimeSystem class

setMaximumConcurrentLocks(numLocks) method

627. change

Replaced: �effect� With: �effect other than on the valuereturned by getMaximumConcurrentLocks()�

numLocks - An integer whose value becomes thenumber of locks that can be in simultaneous use without incurring an executiontime increase. If number is less than or equal to zero nothinghappens. 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 valuereturned by getMaximumConcurrentLocks()�

If the system does not use this hint this method has no effecteffect other thanon the value returned by getMaximumConcurrentLocks().

Exceptions chapter

ArrivalTimeQueueOverflowException class

Description section

629. change

Replaced: �a this�With: �an instance of this class�

If an arrival time occurs and should be queued but the queuealready holds a number of times equal to the initial queue length defined bythis then the fire() method shall throw a thisan instance of this class.

CeilingViolationException class

Description section

630. change

Replaced:�active � With: �base �

This exception is thrown when a schedulable object or java.lang.Thread attempts to lockan object governed by an instance of PriorityCeilingEmulation and the thread orSO�s activebase priority exceedsthe policy�s ceiling.

getCallerPriority() method

631. change

Replaced:�active� With: �base�

Gets the active base priority of the SO or thread whose attempt to synchronize resultedin the throwing of this.

Replaced:�active� With: �base�

Returns: The synchronizing thread�s active base priority.

getCeiling() method

632. change

Inserted:�base �

Gets the ceiling of the PriorityCeilingEmulation policy which wasexceeded by the base priority of an SO or thread that attempted to synchronize on anobject governed by the policy, which resulted in throwing of this.