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.
2. change
Replaced:
By timely execution of threads we mean that…
With:
Timely execution of schedulable objects means that …
In
Timely execution of schedulable objects means that the programmer can determine 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
In
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
In
Priority is typically an integer associated with a schedulable object;
5. change
Replaced
“to”
With
“that may help”
In
However, the base scheduler also inherits methods from itssuperclass that may help determinefeasibility.
6. change
Inserted
“real-time”
in
specifically including no-heap real-timethreads and no-heap asynchronous event handlers.
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 “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”
In
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”
In
A reference to a scoped object cannot be assigned to avariable from an outer scope,
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.”
10. change
Replaced “soft” With “execution time”
in
The Clock class may be extended to represent other clocksthe underlying system might make available (such as a executiontime clock of some granularity).
11. change
Replaced “methods” with “methods, static initializers”
in
These ATC-deferred sections are synchronized methods, static initializers, and synchronizedstatements.
12. change
Replaced “thread” With “schedulable object”
In
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”
in
14. change
Inserted: “real-time”
in
Through ATC it must be possible to abort a real-time thread but in a manner that does not carrythe dangers of the Threadclass’s stop() and destroy() methods.
15. change
Inserted: “real-time”
in
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.”
17. change
Inserted: “Real-Time” in the title.
18. change
Replaced “is” With “would be”
In
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”
in
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”
in
To create such a set of real-timethreads consider the following steps
22. change
Inserted “real-time”
in
Make all of the application methods of the real-time thread interruptible
23. change
Inserted “real-time”
in
Have the handlers call interrupt() on each of the real-time threadsaffected by the change
24. change
Inserted “real-time”
in
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”
in
Ultimately the run() methodof the real-time thread will completenormally.
26. change
Insert “real-time”
in
This idiom provides a quick (if coded to be so) but orderlyclean up and termination of the real-timethread.
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.
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
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.”
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”
In
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.”
In
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”
in
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”
in
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.
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.”
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.)”
in
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.)
55. change
Replaced “default” With “associated”
In
java.lang.IllegalArgumentException - Thrown if thescheduling parameters are not compatible with the associatedscheduler.
56. change
Replaced “default” With “associated”
In
java.lang.IllegalArgumentException - Thrown if thescheduling parameters or release parameters are not compatible with the associated scheduler.
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”
in
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”
In
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 “
In
java.lang.IllegalArgumentException - Thrown if theparameters are not compatible with the associatedscheduler.
Text copied from the Schedulable interface is coveredwith that interface
61. change
Replaced “notan instance of RealtimeThread or an asynch event handler”
with “that of a Java thread”
in
java.lang.ClassCastException - Thrown if thecurrent execution context is that of a Java thread.
62. change
Inserted
“If this method is invoked from a Java thread it will returnthat thread’s current memory area (heap or immortal.)”
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.”
In
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.
66. change
Inserted “Note: The current memory area(getCurrentMemoryArea()) is found at memory area stack indexgetMemoryAreaStackDepth() - 1., so getCurrentMemoryArea() ==getOutMemoryArea(getMemoryAreaStack- Depth() - 1).”
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.”
In
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.”
In
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.”
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.”
In
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.”
In
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.
75. change
Inserted “it “
in
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.
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”
in
java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null,if area is heap memory, if area or schedulingis allocated in heap memory, or if this is inheap memory.
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.”
In
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”
In
IllegalAssignmentError - Thrown if the new NoHeapRealtimeThread instance cannot hold a reference to non-null values of scheduling release and area and
grouprelease, or if those parameters cannot hold a reference to the new NoHeapRealtimeThread.
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. “
In
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”
In
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.
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
84. change
Replaced “inherited“with “acquired”
Inserted “theaction of”
85. change
Replaced “inheritance “ with “inversion avoidance algorithms”
86. change
Replaced “Synchronization “ with “the Synchronization”
In
The active priority of a schedulable object, or a Java thread, is 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.”
88. change
Replaced “costenforcement “ with “processinggroup enforcement”
in
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”
90. change
Inserted “active “
in
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.
91. change
Replaced “The “with “This”
In
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”
In
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 “
In
If the object is already included in the feasibility set, do nothing.
95. change
Replaced
“Returns: True, if this was admitted to the feasible set,False, if this was not admitted because it would not be feasible or 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.”
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 “
In
If the object is already included in the feasibility set, do nothing.
98. change
Replaced “current “ with “associated“
in
Returns: A reference to the associated Scheduler object.
99. change
Deleted “theparameters of “
in
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 “
in
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.
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”
in
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 “feasible “ with “feasibility”
Replaced “schedule “ with “system”
In
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.”
In
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 “
in
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.
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”
in
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 “feasible” with “feasibility”
Replaced “schedule” with “system”
In
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”
In
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”
In
IllegalAssignmentError456 - Thrown if this object cannot holdreferences to all three the proposed parameter objectsobjects, or the parameters parameterobjects cannot hold references a reference tothis.
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”
In
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 “feasible” with “feasibility”
Replaced “schedule” with “system”
In
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.”
In
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”
In
IllegalAssignmentError456 - Thrown if this object cannot holdreferences to both the proposed parameter objectsobjects, or the parameters parameterobjects cannot hold references a reference tothis.
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”
In
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 “feasible” with “feasibility”
Replaced “schedule” with “system”
In
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”
In
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”
In
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.
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”
In
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: “feasible ” With:“feasibility ”
Replaced: “schedule ” With:“system ”
In
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.”
In
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 ”
In
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.”
In
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.
125. change
Replaced: “schedule” With:“system”
In
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.”
In
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.
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”
In
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: “feasible ” With: “feasibility ”
Replaced: “schedule ” With: “system ”
In
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”
In
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 ”
In
IllegalAssignmentError456 - Thrown if this object cannot holda reference to memory the proposed parameter object, or memory theparameter object cannot holda reference to this.
131. change
Replaced: “schedule” With:“system”
In
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”
In
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”
In
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.
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”
In
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: “feasible ” With:“feasibility ”
Replaced: “schedule ” With:“system ”
In
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”
In
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”
In
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 ”
In
IllegalAssignmentError - Thrown if this object cannot holda reference to group the proposed parameter object, or group the parameterobject cannot hold areference to this.
140. change
Replaced: “schedule” With:“system”
In
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”
In
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”
In
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.
143. change
Replaced: “The ” With: “This ”
Replaced: “new ReleaseParameters” With: “proposed parameter object ”
Deleted: “a ”
Replaced: “parameters ” With:“parameter ”
Replaced: “feasible the ” With:“feasible, this ”
Replaced: “ReleaseParameters ”With: “parameter of this ”
Replaced: “new parameters” With:“proposed one”
In
The This method first performs a feasibility 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: “feasible ” With:“feasibility ”
Replaced: “schedule ” With:“system ”
In
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) ”
In
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”
In
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 ”
In
IllegalAssignmentError - Thrown if this object cannot hold a referenceto release the proposed parameterobject, or release the parameter object cannot hold a referenceto this.
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”
In
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.
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.”
In
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”
In
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.
157. change
Replaced: “schedule” With: “system”
In
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”
In
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.
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”
In
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: “feasible ” With:“feasibility ”
Replaced: “schedule ” With:“system ”
In
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 )”
In
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”
In
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 ”
In
IllegalAssignmentError456 - Thrown if this object cannot holda reference to scheduling the proposed parameter object, or scheduling theparameter object cannot holda reference to this.
166. change
Replaced: “schedule” With:“system”
In
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.
167. change
Deleted: “(as expressed in the the associated instances”
Deleted: “SchedulingParameters , ReleaseParametersMemoryParameters , and ProcessingGroupParameters ) of”
Replaced: “feasible ” With: “feasibility ”
In
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”
In
java.lang.IllegalArgumentException - Thrown if schedulableis null, or if schedulable is notassociated with this; that is schedulable.getScheduler() != this.
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”
In
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.
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 ”
In
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 ”
Replaced: “feasible ” With:“feasibility ”
In
Returns: True, if the removal was successful.False, if the schedulable object cannot be removed from the scheduler’s feasible feasibility set; e.g., theschedulable object is not part of the scheduler’s feasible feasibility set.
172. change
Replaced: “constructed” With:“constructed by a Java thread”
In
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 ”
In
scheduler - The Scheduler that becomes the default scheduler assigned to new schedulable objects created by Java threads. If null nothing happens.
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”
In
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: “feasible ” With:“feasibility ”
Replaced: “schedule ” With:“system ”
In
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 ”
In
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 ”
In
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”
In
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().
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”
In
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: “feasible ” With:“feasibility ”
Replaced: “schedule ” With:“system ”
In
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 ”
In
schedulable -The instance of Schedulable85 schedulableobject for which the changesare proposed.
184. change
Inserted: “of this scheduler ”
Replaced: “governed by theassociated scheduler ” With: “used ”
In
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 ”
In
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.)
186. change
Inserted: “of this scheduler ”
187. change
Replaced: “governed by theassociated scheduler ” With: “used ”
In
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”
In
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 ”
In
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()
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()
192. change
Replaced: “required priority ”With: “base ”
In
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).
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 ”
In
Returns: A reference to the singleton distinguished instance PriorityScheduler.
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.”
In
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.
198. change
Inserted: “clones of ”
199. change
Replaced: “visible ” With:“high-resolution time ”
In
Return a clone of this. This method should behave effectively as if 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.)”
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.”
202. change
Insert: “IllegalAssignmentError - Thrown if cost, deadline,overrunHandler, or missHandler cannot be stored in this.”
203. change
Inserted: “clones of ”
204. change
Replaced: “visible ” With:“high-resolution time ”
In
Return a clone of this. This method should behave effectively as if 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.)“
206. change
Insert: “IllegalAssignmentError - Thrown if cost cannot bestored in this.”
207. change
Insert “Throws: IllegalAssignmentError - Thrown if handlercannot be stored in this.”
208. change
Deleted: “if ”
In
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.”
210. change
Insert: “Throws: IllegalAssignmentError - Thrown if handlercannot be stored in this.
211. change
Insert: “IllegalAssignmentError - Thrown if cost or deadlinecannot be stored in this.”
212. 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: “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.”
213. change
Inserted: “IllegalAssignmentError - Thrown if start orperiod cannot be stored in this.”
214. change
Inserted: “IllegalAssignmentError - Thrown if start periodcost, deadline, overrunHandler or missHandler cannot be stored in this.”
215. change
Inserted: “IllegalAssignmentError - Thrown if period cannotbe stored in this.”
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.”
218. change
Inserted “IllegalAssignmentError - Thrown if period, cost ordeadline cannot be stored in this.”
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.”
222. 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:
“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.”
223. change
Inserted: “IllegalAssignmentError - Thrown if cost,deadline, overrunHandler or missHandler cannot be stored in this.”
224. 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 ofRelativeTime(Long.MAX_VALUE, 999999).”
225. change
Added override Replacing: “java.lang.IllegalArgumentException- Thrown if deadline is null, if the time value of deadline is less than orequal to zero, or if the new value of this deadline is incompatible with thescheduler for any associated schedulable object.”
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.”
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.”
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”
230. change
Inserted: “IllegalAssignmentError - Thrown ifminInterarrival cannot be stored in this.”
231. change
Replaced: “Long.MAX_VALUE,999999” With: “mit”
In
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.”
232. change
added override
Replaced: “Long.MAX_VALUE,999999” With: “mit”
In
deadline- The proposed deadline. If null, thedefault value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit)
233. change
Replaced: “Long.MAX_VALUE,999999” With: “mit”
In
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.”
235. change
Inserted: “IllegalAssignmentError - Thrown if minimum cannotbe stored in this.”
236. change
Replaced: “cannot measureexecution time” With: “do not support processing group parameters”
In
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
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 ProcessingGroupParameters object caused by methods on that object areimmediately visible to the scheduler.
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”
In
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.”
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.)”
In
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.)
247. change
Inserted: “IllegalAssignmentError - Thrown if cost cannot bestored in this.”
248. change
Inserted: “Throws: IllegalAssignmentError - Thrown ifhandler cannot be stored in this.”
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.”
250. change
Inserted: “Throws:
IllegalAssignmentError - Thrown if handler cannot be storedin this.”
251. change
Inserted: “IllegalAssignmentError - Thrown if period costdeadline cannot be stored in this.”
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.”
In
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.”
254. change
Inserted: “alters the value of this object’s start timeproperty, but”
255. change
Inserted: “other ”
In
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”
In
java.lang.IllegalStateException IllegalAssignmentError456 - Thrown if the processing group is already startedstart cannot be stored in this.
258. change
Inserted: “java.lang.IllegalArgumentException Thrown ifstart is a relative time value and less than zero.”
259. change
Replaced: “spend ” With: “spent”
In
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…
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”
In
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.
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.”
262. change
Inserted: “, but note that allocation can be performed in aspecific memory area using the
newInstance and newArray methods.”
In
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.”
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.”
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.
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.
269. change
Inserted subsection. Parent Scope
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.”
In
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.
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.) ”
In
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.)
273. change
New semantic: “Pushing a scoped memory onto a scope stack isalways subject to the single parent rule.”
274. change
Inserted: “execution of ”
In
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.
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.
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 ”
In
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.
277. change
Replaced: “An instance ofjava....” With: “A Java thread ”
278. change
Replaced: “13” With: “15”
In
An instance of java.lang.Thread A Java thread may use executeInArea, and the newInstance and newArray methods from the ImmortalMemory and Heap- Memory classes. These methodsallow it to execute with an immortal current allocation context, but semantic (1315) applies even duringexecution of these methods. .
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.”
In
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
282. change
Inserted: “still ready to bedecremented to”
283. change
Inserted: “then it isdecremented to zero and”
In
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)
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.”
In
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.
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”
288. change
Replaced: “area” With: “are”
In
For this table, ImmortalMemory and ImmortalPhysicalMemory are equivalent, and allsub-classes of ScopedMemory area are equivalent.
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.”
In
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.
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.”
In
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.
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
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.”
300. change
Replaced: “below ” With:“outside ”
In
For all other scoped memory areas, the parent isthe first scoped memory area below outside it on the scope stack. .
301. change
Deleted: “ma.refCount++”
In
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++
302. change
Replace “refCount == 0” With: “!ma in use”
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”
In
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.
305. change
Inserted:“IllegalAssignmentError - Thrown if storing logic in this would violate theassignment rules”
In
IllegalAssignmentError456 - Thrown ifstoring logic in this would violatethe assignment rules.
306. change
Inserted:“IllegalAssignmentError - Thrown if storing logic in this would violate theassignment rules”
In
IllegalAssignmentError456 - Thrown ifstoring logic in this would violatethe assignment rules.
307. change
Replaced: “IllegalStateException” With: “IllegalThreadStateException ”
In
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.”
In
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.
309. change
Replaced: “IllegalStateException” With: “IllegalThreadStateException ”
In
java.lang.IllegalStateExceptionIllegalThreadStateException - Thrown if the caller is a Java thread.
310. 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.”
In
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.
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”
In
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”
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.)”
In
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.”
318. change
Deleted: “InaccessibleAreaException - Thrown if the memoryarea is not in the schedulable object’s scope stack.”
319. change
Deleted: “InaccessibleAreaException - Thrown if the memoryarea is not in the schedulable object’s scope stack.”
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.
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.
322. change
Inserted: “Throws: java.lang.IllegalArgumentException -Thrown if length is negative.”
323. change
Inserted: “length is negative or”
In
Throws:
java.lang.IllegalArgumentException - Thrown if length is negative or type does not represent aprimitive type.
324. change
Deleted: “When logic.run() is complete, the scoped memoryarea is no longer active, and its reference count will be decremented.”
325. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
326. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
327. change
Replaced: “when enter ” With:“if the caller ”
328. change
Deleted: “invoked from ”
In
java.lang.IllegalThreadStateException - Thrown when enter if the caller is invoked from aJava thread.
329. change
Replaced: “when enter ” With:“if the caller ”
330. change
Deleted: “invoked from ”
In
java.lang.IllegalThreadStateException - Thrown when enter if the caller is invoked from aJava thread.
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”
In
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 ”
In
java.lang.IllegalStateExceptionIllegalThreadStateException-Thrown if the caller is a Java thread.
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.”
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.”
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.”
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.
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.”
342. change
Inserted: “java.lang.UnsupportedOperationException - Thrownif the wait operation is not supported using the clock associated with time.”
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.
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.”
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.”
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.”
346. change
Inserted: “java.lang.UnsupportedOperationException - Thrownif the wait operation is not supported using the clock associated with time.”
347. change
Replaced: “IllegalStateException” With: “IllegalThreadStateException ”
In
java.lang.IllegalStateExceptionIllegalThreadStateException - Thrown if the caller is a Java thread.
348. change
Replaced: “IllegalStateException” With: “IllegalThreadStateException ”
In
java.lang.IllegalStateExceptionIllegalThreadStateException - Thrown if the caller is a Java thread.
349. change
Replaced: “IllegalStateException” With: “IllegalThreadStateException ”
In
java.lang.IllegalStateExceptionIllegalThreadStateException - Thrown if the caller is a Java thread.
350. change
Inserted: “IllegalThreadStateException is thrown when calledby a Java thread even when the invocation could also throwIllegalArgumentException.”
351. change
Replaced: “the ” With: “this ”
In
InaccessibleAreaException - Thrown if the this memory areais not in the caller’s scope stack.
352. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
353. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
354. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
355. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
356. change
Replaced:“VTMemory”
With: “LTMemory”
In
VTMemory is similar to VTMemoryLTMemory except that the execution time of
anallocation from a VTMemory area need not complete in linear time.
357. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
358. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
359. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
360. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
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.”
362. change
Replaced:“aysnc
” With: “async ”
In
ae - The aysnc async event to register.
363. change
Replaced:“aysnc
” With: “async ”
In
ae - The aysnc async event to register.
364. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
365. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
366. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
367. change
Inserted: “IllegalAssignmentError - Thrown if storing
logicin this would violate the assignment rules.”
368. change
Inserted: “IllegalAssignmentError - Thrown if storinglogic
in this would violate the assignment rules.”
369. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
370. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
371. change
Inserted: “IllegalAssignmentError - Thrown if storing
logicin this would violate the assignment rules.”
372. change
Inserted: “IllegalAssignmentError - Thrown if storinglogic
in this would violate the assignment rules.”
373. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
374. change
Inserted: “IllegalAssignmentError - Thrown if storing logicin this would violate the assignment rules.”
375. change
Inserted: “IllegalAssignmentError - Thrown if storing
logicin this would violate the assignment rules.”
376. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
377. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
378. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
379. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
380. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
381. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
382. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
383. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
384. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
385. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
386. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
387. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
388. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
389. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
390. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
391. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
392. change
Replaced:“block
until one load or store completes” With: “throw anIllegalStateException”
Replaced:
“It” With: “The unmap method ”
In
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.
393. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
394. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
395. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
396. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
397. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
398. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
399. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
400. change
Inserted: “java.lang.SecurityException - Thrown if thisaccess is not permitted by the security manager.”
401. change
Replaced:“allocationrate
” With: “allocationRate ”
In
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.
402. change
Replaced:“default
” With: “base ”
In
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.
403. change
In
thesubsection title
Replaced:“Default
” With: “Base ”
404. change
Replaced:“default
” With: “base ”
In
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.”
In
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 ”
In
• t.setPriority(prio)
if t is an instance of java.lang.Thread the new base priority is the
lesser of prio, Thread.MAX_PRIORITY, and the 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”
In
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, ”
In
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 ”
In
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:
“”)”
In
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.”
In
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 ”
In
• 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.
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”
In
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.
423. change
Deleted:
“base”
In
Returns: The base monitor
control policy of the obj parameter.
424. change
Replaced:“monitor
” With: “obj ”
In
java.lang.IllegalArgumentException- Thrown if monitor obj is null.
425. change
Replaced:“Unlike
” With: “Like ”
In
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”
In
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.”
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
”
In
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.”
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.”
In
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”
In
• 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.”
439. change
Deleted:
“with”
In
All invocations with of this method return a reference to the same object.
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.”
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.”
In
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.”
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 ”
In
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.”
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.”
448. change
Replaced:“read
” With: “thread ”
449. change
Replaced:“AIE”
With: “AsynchronouslyInterruptedException”
Inserted:
“ duringthe time between calling this method and returning from it”
In
java.lang.InterruptedException- Thrown if the read thread isinterrupted
by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the
timebetween calling this method and returning from it.
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.”
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.”
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”
In
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 queue will be allocated in immortal memory.
457. change
Inserted: “InnaccessibleAreaException - Thrown if memory isa scoped memory that is not on the caller’s scope stack.”
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”
In
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 queue will be allocated in immortal memory.
461. change
Replaced:
“If” With: “Thrown if ”
In
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.”
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.”
In
java.lang.InterruptedException- Thrown if the method thread isinterrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the timebetween calling this method and returning from it.
466. change
Replaced:“write
” With: “thread ”
467. change
Replaced:“AIE”
With: “AsynchronouslyInterruptedException”
468. change
Inserted:
“during the time between calling this method and returning from it”
In
java.lang.InterruptedException- Thrown if the write thread 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.”
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.”
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”
In
The writer and reader parameters, if non-null, are
checked to insure that they arecompatible with the MemoryArea
specified by memory (if nonnull.)
If memory is null and both Runnables are non-null, the
constructor will find a select the 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 queue will be allocated in immortal memory.
473. change
Inserted: “InnaccessibleAreaException - Thrown if memory isa scoped memory that is not on the caller’s scope stack.”
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.”
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.”
480. change
Inserted: “Throws:
MemoryScopeException - Thrown if a memory access error orillegal assignment error would occur while storing object in the queue.”
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.”
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.
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 32 bits of a Java int.
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:”
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.
485. change
Replaced:
“Equality includes clock association” With: “Equality includes
clockassociation. ”
486. change
Replaced:
“Equality includes clock association” With: “Equality includes
clockassociation. ”
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.
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.”
493. change
Deleted: “The clock association is implicitly made with thereal-time clock.
Equivalent to new AbsoluteTime(0,0).”
494. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
The result will have the same clock association as this. An 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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
496. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
The result will have the same clock association as this, and the
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
498. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An IllegalArgumentException is thrown if the time parameter
is null. An 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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result
after normalizationnormalized
format.
500. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
502. change
Replaced:“computation
of ” With: “the result does not fit in”
Replaced:
“relativetime gives an overflow after normalization” With: “normalized format”
In
java.lang.ArithmeticException- Thrown if computation of the result does not fit in the relative time gives an overflow after normalizationnormalized format.
503. change
Replaced:“computation
of ” With: “the result does not fit in”
Replaced:“relative
time gives an overflow after normalization” With: “normalized format”
In
java.lang.ArithmeticException- Thrown if computation of the result does not fit in the relative time gives an overflow after normalizationnormalized format.
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”
In
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”
507. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
509. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
511. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException - Thrown if there is anoverflow the result does not fit in the result after normalizationnormalizedformat.
513. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
515. change
Replaced:“reprepresentation
” With: “representation ”
In
The string shall be a decimal reprepresentation representation of the millisecondsand nanosecond values; formatted as follows “(2251 ms, 750000 ns)”
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.
517. change
Inserted: “Throws:
java.lang.ArithmeticException - Thrown if the result doesnot fit in the normalized format.”
518. change
Inserted: “Throws:
java.lang.ArithmeticException - Thrown if the result doesnot fit in the normalized format.
519. change
Replaced:
“thereis an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
521. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
523. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
525. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
527. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
529. change
Replaced:“there
is an overflow ” With: “the result does not fit ”
Replaced:“result
after normalization” With: “normalized format”
In
An ArithmeticException is thrown if there is an
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”
In
java.lang.ArithmeticException- Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
531. change
Replaced:“reprepresentation
” With: “representation ”
In
The string shall be a decimal reprepresentation representation of themilliseconds and nanosecond values; formatted as follows “(2251 ms, 750000 ns)”
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.”
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.”
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.”
540. change
Replaced:
“a ”With: “the system ”
541. change
Replaced:“clock
that advances in sync with the external world” With: “clock”
In
There is always at least one clock object available: a the system real-time clock that advancesin sync with the external worldclock. This is the default Clock.
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.”
544. change
Replaced:“relative
” With: “according ”
In
A timer is a timed event that measures time relative according to a
given Clock
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”
In
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: “[”
In
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: “[”
In
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”
In
startDisabled->
[if last_rescheduled_with_AbsoluteTime
then
[set startTimetargetTime = currentTimenextTargetTime
and[if set targetTime =< nextTargetTimecurrentTime
then goset totargetTime state= {active, disabled, absolute} crrentTime]
then go to state {active,disabled,
absolute}]
else
[set startTimecountingTime = currentTime0
and set countingTimedurationTime =0nextDurationTime
and set durationTime=
nextDurationTime
then go to state {active,disabled,
relative}]]
550. change
Inserted: “via targetTime = (targetTime + period)”
Replaced: “enabled” With: “enable”
In
{active,enabled,
absolute}
[if currentTime >= targetTime
then
[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”
In
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”
In
[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]]”
In
[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”
In
[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]”
In
[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”
In
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)”
In
{active,
disabled,relative}
[if countingTime >= durationTime
then
[if
PeriodicTimer
then
[if period> 0
then
[skip
and set fired_or_skipped_in_current_activation = TRUE
and
self reschedule
and via durationTime = reenter(
durationTime current+ state]period)
and re-enter current state]
else
[skip
and go to state {not-active, disabled, relative}]]
else
[it is aOneShotTimer so
skip
and go to state {not-active, disabled, relative}]]]
559. change
Replaced:“disabled”
With: “disable”
In
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”
In
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”
In
getFireTime ->
getFireTime -> return (startTimecurrentTime
+ durationTime -
countingTime)
destroy -> go to state {destroyed}
startDisabled -> throws IllegalStateException
562. change
Replaced:“disabled”
With: “disable”
In
{destroyed}
enable | disableddisable| stop | start | isRunning
| reschedule | getFireTime | destroy
| startDisabled -> throwsIllegalStateException
563. change
Inserted:
“.The clock associated with the parameter time is always ignored”
In
clock - The clock on which to base this
timer,overriding the clock associated with the parameter time. If null, the system Realtime clock is used. The clock associated with the parameter time is always ignored.
564. change
Inserted: “java.lang.UnsupportedOperationException
-
Thrown if thetimer functionality cannot be supported using the given clock.”
565. change
added override and Inserted: “Throws:
java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.”
566. change
Added override: “Should not be called.
Throws:
java.lang.UnsupportedOperationException - Thrown if bindTois called on a Timer.”
567. change
Replaced:“block
” With: “object ”
In:
Create a ReleaseParameters block object appropriate
to the timing characteristics of this event.
568. change
Inserted:“remove
from it all the associated handlers if any”
In
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.”
570. change
Replaced: “notenabled” With: “already disabled, whether it it is active or not-active”
In
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.
571. change
Replaced:
“notdisabled” With: “already enabled, this method does nothing. If the
Timeris not-active”
In
Re-enable this timer after it has been disabled. (See disable()374 .) If the
Timer is not disabledalready enabled, this method does nothing. If the Timer is not-active, this method doesnothing
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.”
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.
575. change
Added override
Inserted “Throws:
java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.”
576. change
Inserted: “Throws:
java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.”
577. change
Added override
Inserted “Throws:
java.lang.IllegalStateException - Thrown if this Timer hasbeen destroyed.”
578. change
Replaced:“re-scheduling
” With: “rescheduling ”
In
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”
In
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.”
582. change
Added override.
Inserted: “java.lang.IllegalStateException - Thrown if thisTimer has been destroyed.”
583. change
Replaced:“retains
the enabled or disabled state it had at expiration time” With:“disabled”
In
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
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()”
In
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.”
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()”
In
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().
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.”
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)…
591. change
Replaced:
“If” With: “A ”
Inserted:“value
of null ”
Replaced:“null
then ” With: “equivalent to a RelativeTime of 0, and in this case”
Replaced:“first
interval will start ” With: “Timer fires ”
In
start - The time that specifies when the 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”
In
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.”
594. change
Replaced:
“If” With: “A ”
Inserted:“value
of null ”
Replaced:“null
then ” With: “equivalent to a RelativeTime of 0, and in this case”
Replaced:“first
interval will start ” With: “Timer fires ”
In
start - The time that specifies when the 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().
595. change
Replaced:“zero”
With: “zero or null”
Replaced:
“theone ” With: “that ”
In
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.”
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.”
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.”
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”
In
java.lang.IllegalStateException- Thrown ifthis
PeriodicTimerhas been destroyed,
or if it is in a not-active statenot-active.
605. change
Replaced: “A new” With: “The”
In
A newTheRelativeTimeinstancewith
the value of this timer’s interval.
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.”
In
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.”
608. change
Inserted:“active
”
In
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.”
610. change
Replaced:“schedule”
With: “system”
In
Since this affects the constraints expressed in the releaseparameters of an existing schedulable object, this may change the feasibilityof the current schedulesystem.
611. change
Replaced:“schedule”
With: “system”
In
Since this affects the constraints expressed in the releaseparameters of an existing schedulable object, this may change the feasibilityof the current schedulesystem.
612. change
Replaced:“schedule”
With: “system”
In
Since this affects the constraints expressed in the releaseparameters of the existing schedulable objects, this may change the feasibilityof the current schedulesystem.
613. change
Deleted:“default
”
Deleted:“default
”
In
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.
614. change
Replaced:“BAEHís
” With: “BAEH’s ”
In
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 ”
In
logic - The java.lang.Runnable object whose run()method is executed by AsyncEventHandler.handleAsyncEvent(). If null, the logic will default to the BAEHís BAEH’s run method.
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”
In
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”
Replaced:
“thecurrent exception” With: “pending”
In
Returns: True if this was the
current exceptionpending. False if this was not the
currentexceptionpending.
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().”
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: “)”
In
Returns: True if this is enabled and the
method call wasinvoked with in the context of the associated doInterruptible() in
progress). Falseotherwise.
620. change
Replaced:“AsyncEvent”
With: “AsyncEventHandler”
In
Use instances of AsyncEvent398AsyncEventHandler402 to handle
POSIXsignals.
621. change
Deleted:“AsyncEvent
of the ”
In
Add the given AsyncEventHandler to the list of handlers of the AsyncEvent of the given signal.
622. change
Replaced:“class”
With: “class or if handler is null”
In
java.lang.IllegalArgumentException - Thrown if signal is not
known bythis classclass or if handler is null.
Replaced:“IllegalArgumentException
” With: “UnsupportedOperationException ”
Deleted:
“not”
Replaced:
“by” With: “to ”
Inserted:
“,but not supported on this implementation”
In
java.lang.IllegalArgumentException UnsupportedOperationException - Thrown if signal is not known by to this class, but notsupported on this implementation.
623. change
Deleted: “of the AsyncEvent”
In
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”
In
java.lang.IllegalArgumentException - Thrown if signal is not
known bythis classclass or if handler is null.
625. change
Deleted:“AsyncEvent
of the ”
In
Set the given AsyncEventHandler as the handler of the AsyncEvent of the given signal.
626. change
Inserted: “java.lang.UnsupportedOperationException-Thrown if signalisknown to this class, but not supported on this implementation.”
627. change
Replaced: “effect” With: “effect other than on the valuereturned by getMaximumConcurrentLocks()”
In
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().
628. change
Replaced: “effect” With: “effect other than on the valuereturned by getMaximumConcurrentLocks()”
In
If the system does not use this hint this method has no effecteffect other thanon the value returned by getMaximumConcurrentLocks().
629. change
Replaced:
“a this”With: “an instance of this class”
In
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.
630. change
Replaced:“active
” With: “base ”
In
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.
631. change
Replaced:“active”
With: “base”
In
Gets the active base priority of the SO or thread whose attempt to
synchronize resultedin the throwing of this.
Replaced:“active”
With: “base”
In
Returns: The synchronizing thread’s active base priority.
632. change
Inserted:“base
”
In
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.