Changes Accepted in Early May 2005
Change list RSTJ 1.0.1(a) to 1.0.1(b)
Note that changes to inherited methods are only itemized in the class where the method is defined.
Note that numbered items such as semantics are identified by unique numbers in this change list. Since deleted semantics and new semantics have numbers, the numbers in this change list may not match either the 1.0.1(a) or 1.0.1(b) documents. Because if this, cross references that appear in this change list may not make sense.
1. change
The non-normative thread safety chapter has been removed.
2. change
Replaced:
By timely execution of threads we mean that
With:
Timely execution of schedulable objects means that
In
Timely execution of schedulable objects means that the programmer can determine by analysis of the program, testing the program on particular implementations, or both whether particular threads will always complete execution before a given timeliness constraint.
3. change
Replaced: threads
With :
schedulable objects
In
We use the term scheduling (or scheduling algorithm) to refer to the production of a sequence (or ordering) for the execution of a set of schedulable objects (a schedule).
4. change
Replaced thread
With
schedulable object
In
Priority is typically an integer associated with a schedulable object;
5. change
Replaced
?to?
With
?that may help?
In
However, the base scheduler also inherits methods from its superclass that may help determine feasibility.
6. change
Inserted
?real-time?
in
specifically including no-heap real-time threads and no-heap asynchronous event handlers.
7. change
Replaced: ?Every ? With: ?The contents of a?
Replaced ?area effectively maintains?
With ?are discarded when no object in the scope can be referenced. This is done by a technique similar to reference counting the scope. A conformant implementation might maintain?
Replaced: ?that? With ?each?
Replaced: ?is? With ?would be?
Replaced: ?is? With ?would be?
Replaced ?is? With ?would be?
Replaced ?The? With: ?Reuse of the?
Replaced ?Cannot be reused? With ?is blocked?
Replaced ?complete and the RTSJ requires that the finalizers execute to completion before the next use (calling enter() or in a constructor) of the scoped memory area? With ?complete?
In
The contents of a scoped memory are discarded when no object in the scope can be referenced. This is done by a technique similar to reference counting the scope. A conformant implementation might maintain a count of the number of external references to each memory area. The reference count for a ScopedMemory area would be increased by entering a new scope through the enter() method of MemoryArea, by the creation of a schedulable object using the particular ScopedMemory area, or by the opening of an inner scope. The reference count for a ScopedMemory area would be decreased when returning from the enter() method, when the schedulable object using the ScopedMemory terminates, or when an inner scope returns from its enter() method. When the count drops to zero, the finalize method for each object in the memory would be executed to completion. Reuse of the scope is blocked until finalization is complete.
8. change
Replaced ?Enclosing? With ?Outer?
In
A reference to a scoped object cannot be assigned to a variable from an outer scope,
9. change
Replaced
?A second policy, priority ceiling emulation protocol (or highest locker protocol), is also specified for systems that support it. The highest locker protocol is also a well known algorithm in the literature, and it has the following effect:
? With this policy, a monitor is given a priority ceiling when it is created, which is the highest priority of any thread that could attempt to enter the monitor.
? As soon as a thread enters synchronized code, its priority is raised to the monitor?s ceiling priority.
? If, through programming error, a thread has a higher priority than the ceiling of the monitor it is attempting to enter, then an exception is thrown.
Note that while the RTSJ requires that the execution of non-heap schedulable objects must not be delayed by the execution of the garbage collector, an application can cause a no-heap schedulable to wait for garbage collection by synchronizing using an object between an heap-using thread or schedulable object and a non-heap schedulable object. The RTSJ provides three wait-free queue classes to provide protected, non-blocking, shared access to objects accessed by both regular Java threads and no-heap real-time threads. These classes are provided explicitly to enable communication between the real-time execution of non-heap schedulable objects and regular Java threads.?
With
?A second policy, priority ceiling emulation protocol (or highest locker protocol), is also specified for systems that support it. This protocol is also a well-known algorithm in the literature; somewhat simplified, its effect is as follows:
? A monitor is given a ?priority ceiling? when it is created; the programmer should choose the highest priority of any thread that could attempt to enter the monitor.
? As soon as a thread enters synchronized code, its (active) priority is raised to the monitor?s ceiling priority. If, through programming error, a thread has a higher base priority than the ceiling of the monitor it is attempting to enter, then an exception is thrown.
? On leaving the monitor, the thread has its active priority reset. In simple cases it will set be to the thread?s previous active priority, but under some circumstances (e.g. a dynamic change to the thread?s base priority while it was in the monitor) a
different value is possible
Note that while the RTSJ requires that the execution of non-heap schedulable objects must not be delayed by garbage collection on behalf of lower-priority schedulable objects, an application can cause a no-heap schedulable object to wait for garbage collection by synchronizing using an object between an heap-using thread or schedulable object and a non-heap schedulable object. The RTSJ provides wait-free queue classes to provide protected, non-blocking, shared access to objects accessed by both regular Java threads and no-heap real-time threads. These classes are provided explicitly to enable communication between the real-time execution of non-heap schedulable objects and regular Java threads or heap-using schedulable objects.?
10. change
Replaced ?soft? With ?execution time?
in
The Clock class may be extended to represent other clocks the underlying system might make available (such as a execution time clock of some granularity).
11. change
Replaced ?methods? with ?methods, static initializers?
in
These ATC-deferred sections are synchronized methods, static initializers, and synchronized statements.
12. change
Replaced ?thread? With ?schedulable object?
In
Code that responds to an ATC does not return to the point in the schedulable object where the ATC was triggered;
13. change
Replaced ?thread? With ?schedulable object?
Replaced ?thread? With ?thread or schedulable object?
Replaced ?thread ? with ?thread or schedulable object?
in
14. change
Inserted: ?real-time?
in
Through ATC it must be possible to abort a real-time thread but in a manner that does not carry the dangers of the Thread class?s stop() and destroy() methods.
15. change
Inserted: ?real-time?
in
There should be straightforward idioms for common cases such as timer handlers and real-time thread termination.
16. change
Deleted
?ATC must be implemented without inducing an overhead for programs that do not use it.?
17. change
Inserted: ?Real-Time? in the title.
18. change
Replaced ?is? With ?would be?
In
It would be convenient to program threads that abnormally terminate when the external real-time system changes in a way such that the thread is no longer useful.
19. change
deleted ?would?
from
Without this facility, a thread or set of threads would have to be coded in such a manner so that their
computational behavior anticipated all of the possible transitions among possible states of the external system.
20. change
Inserted ?real-time?
in
The RTSJ accommodates safe asynchronous real-time thread termination through a combination of the asynchronous event handling and the asynchronous transfer of control mechanisms.
21. change
Inserted ?real-time?
in
To create such a set of real-time threads consider the following steps
22. change
Inserted ?real-time?
in
Make all of the application methods of the real-time thread interruptible
23. change
Inserted ?real-time?
in
Have the handlers call interrupt() on each of the real-time threads affected by the change
24. change
Inserted ?real-time?
in
After the handlers call interrupt() have them create a new set of real-time threads appropriate to the current state of the external world
25. change
Inserted ?real-time?
in
Ultimately the run() method of the real-time thread will complete normally.
26. change
Insert ?real-time?
in
This idiom provides a quick (if coded to be so) but orderly clean up and termination of the real-time thread.
27. change
Deleted
?The base implementation will provide a PhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes that correctly identify memory classes that are standard for the (OS, JVM, and processor) platform.?
from
The PhysicalMemoryManager is available for use by the various physical memory accessor objects (VTPhysicalMemory, LTPhysicalMemory, ImmortalPhysicalMemory, RawMemoryAccess, and RawMemoryFloatAccess) to create objects of the correct type that are bound to areas of physical memory with the appropriate characteristics - or with appropriate accessor behavior. Examples of characteristics that might be specified are: DMA memory, accessors with byte swapping, etc. The base implementation will provide a PhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes that correctly identify memory classes that are standard for the (OS, JVM, and processor) platform. OEMs may provide PhysicalMemoryTypeFilter classes that allow additional characteristics of memory devices to be specified.
28. change
Inserted
?Subject to the usual assumptions, the methods in javax.realtime can safely be used concurrently by multiple threads unless it is otherwise documented.?
In the list of base requirements
29. change
Replaced
?Allows the application to control the processor utilization of a thread or group of threads.?
With
?Allows the application to control the processor utilization of a schedulable object.?
In the description of the cost enforcement option
30. change
Insert the following option in the option table:
?Processing Group Enforcement
Allows the application to control the processor utilization of a group of schedulable objects?
31. change
Insert the following option in the option table:
?Processing Group deadline less than period
Allows the application to specify a processing group deadline ?
32. change
Insert the following option in the option table:
?Allocation-rate enforcement on heap allocation
Allows the application to limit the rate at which a schedulable object creates objects in the heap.?
33. change
Inserted
?The ProcessingGroupParameters class is only functional on systems that support the processing group enforcement option. Cost enforcement, and cost overrun handlers are only functional on systems that support the cost enforcement option. If processing group enforcement is supported, ProcessingGroupParameters must function as specified. If cost enforcement is supported, cost enforcement, and cost overrun handlers must function as specified.?
34. change
Inserted
?If the processing group deadline less than period is not supported, values passed to the constructor for ProcessingGroupParameters and its setDeadline method are constrained to be equal to the period. If the option is supported, processing group deadlines less than the period must be supported and function as specified.?
35. change
Replaced
?If cost enforcement is not supported, the ProcessingGroupParameters class must not be present. If cost enforcement is supported, ProcessingGroupParameters must be implemented as specified.?
With
?If priority ceiling emulation is supported, PriorityCeilingEmulation must be implemented as specified. If priority ceiling emulation is not supported, PriorityCeilingEmulation must be present, but the implementation may not permit its use as a monitor control policy.?
36. change
Replaced
?If priority ceiling emulation protocol is not supported, the PriorityCeilingEmulation class must not be present. If priority ceiling emulation is supported, PriorityCeilingEmulation must be implemented as specified.?
With
?If heap allocation rate enforcement is supported, it must be implemented as specified. If heap allocation rate enforcement is not supported, the allocation rate attribute of MemoryParameters must be checked for validity but otherwise ignored by the implementation.?
37. change
Inserted
?The following semantics are optional for an RTSJ implementation designed and licensed exclusively as a development tool:
? The priority scheduler need not support fixed-priority preemptive scheduling or priority inheritance. This does not excuse an implementation from fully supporting the relevant APIs. It only reduces the required behavior of the underlying scheduler to the level of the scheduler in the Java specification extended to at least 28 priorities.
? No semantics constraining timing beyond the requirements of the Java specifications need be supported. Specifically, garbage collection may delay any thread without bound and any delay in delivering asynchronously interrupted exceptions is permissible including never delivering the exception. Note, however, that if any AIE other than the generic AIE is delivered, it must meet the AIE semantics, and all heap-memory-related semantics other than preemption remain fully in effect. Further, relaxed timing does not imply relaxed sequencing. For instance, semantics for scoped memory must be fully implemented.
? The RTSJ semantics that alter standard Java method behavior—such as the modified semantics for Thread.setPriority and Thread.interrupt—are not required for a development tool, but such deviations from the RTSJ must be documented, and the implementation must be able to generate a run-time warning each time one of these methods deviates from standard RTSJ behavior.
? These relaxed requirements set a floor for RTSJ development system tool implementations. A development tool may choose to implement semantics that are not required.?
38. change
Replaced ?admission control? with ?feasibility testing?
twice in
If the feasibility testing algorithm is not the default, document the feasibility testing algorithm.
39. change
Replaced ?the base? With ?each other?
In
document the behavior of the scheduler and its interaction with each other scheduler
40. change
Deleted
?3 An implementation of the RTSJ is permitted to spuriously release waiting threads, but it must document the circumstances under which that may happen.?
41. change
Deleted
?4. Threads that are preempted in favor of a thread with higher execution eligibility may be given access to the processor at any time as determined by a particular implementation. If the behavior does not match the POSIX specification, the implementation is required to provide documentation stating exactly the algorithm used for granting such access.?
42. change
Inserted
?Placement at the front of the queue may be required in a future version of this specification.?
In
If the preempted schedulable object is not placed at the front of the appropriate queue the implementation must document the algorithm used for such placement. Placement at the front of the queue may be required in a future version of this specification.
43. change
Replaced ?default? With ?base?
in
It must supply documentation for the behavior of the new scheduler with priority inheritance (and, if it is supported, priority ceiling emulation protocol) equivalent to the semantics for the base priority scheduler found in the Synchronization chapter.
44. change
Replaced ?This? With ?The?
in
The worst-case response interval between firing an AsyncEvent because of a bound happening to releasing an associated AsyncEventHandler
45. change
Inserted the following documentation requirement
?An implementation may run finalizers for objects in scoped memory before the scope is reentered and before it returns from any call to getReferenceCount() for that scope. It must, however, document when it runs those finalizers.?
46. change
Inserted the following documentation requirement
?For each supported clock, the documentation must specify whether the resolution is settable, and if it is settable the documentation must indicate the supported values.?
47. change
Inserted the following documentation requirement
?If an implementation includes any clocks other than the required real-time clock, their documentation must indicate in what contexts those clocks can be used.?
48. change
Deleted
?If we refer to other heaps, such as the heap used by the C language runtime or the operating system?s heap, we will explicitly state which heap.?
from
Throughout the RTSJ, when we use the word code, we mean code written in the Java programming language. When we mention the Java language in the RTSJ, that also refers to the Java programming language. The use of the term heap in the RTSJ will refer to the heap used by the runtime of the Java language. If we refer to other heaps, such as the heap used by the C language runtime or the operating system?s heap, we will explicitly state which heap.
49. change
Replaced
?Thread groups are rooted at a base ThreadGroup object which is created in heap memory, and thread group objects hold references to all their member threads. Since no-heap threads cannot hold a reference to a heap object they are not permitted to contain a reference to a thread group, and since thread groups cannot hold references to threads created in scoped memory they are also not permitted to have normal thread group membership. In consequence all no-heap threads and some plain real-time threads have null thread group references.?
With
?Thread groups are rooted at a base ThreadGroup object which may be created in heap or immortal memory. All thread group object hold references to all their member threads, and subgroups, and a reference to their parent group. Since heap and immortal memory can not hold references to scoped memory, it follows that a thread group can never be allocated in scoped memory. It then follows that no thread allocated in scoped memory may be referenced from any thread group, and consequently such threads are not part of any thread group and will hold a null thread group reference. Similarly, a NoHeapRealtimeThread can not be a member of a heap allocated thread group.?
50. change
Deleted
?Note that a thread group cannot be created in a scoped memory area because the parent/child references between thread groups would violate scoped memory assignment rules and throw an IllegalAssignmentError.?
51. change
Insert new section ?InterruptedException?
52. change
Inserted
?The interruptible methods in the standard libraries (such as Object.wait, Thread.sleep, and Thread.join) have their contract expanded slightly such that they will respond to interruption not only when the interrupt method is invoked on the current thread, but also, for schedulable objects, when executing within a call to AIE.doInterruptible and that AIE is fired. See Asynchrony.?
53. change
Replaced
?A no-heap real- time thread will not be blocked by the garbage collector executing in the context of a Java thread with a lower execution eligibility.?
With
?Garbage collection executing in the context of a Java thread must not in itself block execution of a no-heap thread with a higher execution eligibility, however application locks work as specified even when the lock causes synchronization between a heap-using thread and a no-heap thread.?
54. change
Inserted
?, and when an asynchronously interrupted exception?s fire method is invoked between the time the real-time thread has entered that exception?s doInterruptible method, and return from doInterruptible. (See the Asynchrony chapter.)?
in
Each real-time thread has an attribute which indicates whether an AsynchronouslyInterruptedException is pending. This attribute is set when a call to RealtimeThread.interrupt() is made on the associated real-time thread, and when an asynchronously interrupted exception?s fire method is invoked between the time the real-time thread has entered that exception?s doInterruptible method, and return from doInterruptible. (See the Asynchrony chapter.)
55. change
Replaced ?default? With ?associated?
In
java.lang.IllegalArgumentException - Thrown if the scheduling parameters are not compatible with the associated scheduler.
56. change
Replaced ?default? With ?associated?
In
java.lang.IllegalArgumentException - Thrown if the scheduling parameters or release parameters are not compatible with the associated scheduler.
57. change
Inserted ?The newly-created real-time thread is associated with the scheduler in effect during execution of the constructor.?
In the description of the scheduling parameter
58. change
Replaced ?copy? With ?clone?
Replaced ?the new RealtimeThread? With ?this?
Replaced ?default ? with ?associated?
in
scheduling - The SchedulingParameters associated with this (And possibly other instances of Schedulable). If scheduling is null and the creator is a schedulable object, SchedulingParameters102 is a clone of the creator?s value created in the same memory area as this. If scheduling is null and the creator is a Java thread, the contents and type of the new SchedulingParameters object is governed by the associated scheduler.
59. change
In the description of the release parameter
Replaced ?default ? with ?associated ?
Replaced ?copy? with ?clone?
In
release - The ReleaseParameters associated with this (and possibly other instances of Schedulable). If release is null the new RealtimeThread will use a clone of the default ReleaseParameters for the associated scheduler created in the memory area that contains the RealtimeThread object.
60. change
Replaced ?The ? with ?This ?
In
java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler.
Text copied from the Schedulable interface is covered with that interface
61. change
Replaced ?not an instance of RealtimeThread or an asynch event handler?
with ?that of a Java thread?
in
java.lang.ClassCastException - Thrown if the current execution context is that of a Java thread.
62. change
Inserted
?If this method is invoked from a Java thread it will return that thread?s current memory area (heap or immortal.)?
63. chang
Inserted ?This method returns the position in the memory area stack of the initial memory area.?
64. change
Insert ?may?
65. change
Delete ?This method returns the position in the memory area stack of initial memory area.?
In
This method returns the position in the memory area stack of the initial memory area. Memory area stacks may include inherited stacks from parent threads. The initial memory area for the current RealtimeThread or AsyncEventHandler is the memory area given as a parameter to the constructor. The index on the memory area stack of the initial memory area is a fixed property of the real-time thread. This method returns the position in the memory area stack of initial memory area.
66. change
Inserted ?Note: The current memory area (getCurrentMemoryArea()) is found at memory area stack index getMemoryAreaStackDepth() - 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 is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?
In
java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.
69. change
Replaced ?not an instance of RealtimeThread or an async event handler.? With ?that of a Java thread.?
In
java.lang.ClassCastException - Thrown if the current execution context is that of a Java thread.
70. change
Replaced ?java.lang.IllegalArgumentException - Thrown if clock cannot represent calendar time, or if time is a relative time less than zero.?
With
?java.lang.UnsupportedOperationException - Thrown if the sleep operation is not supported by clock.
java.lang.IllegalArgumentException - Thrown if time is null, or if time is a relative time less than zero.?
71. change
Inserted
?This method must not throw IllegalAssignmentError. It must tolerate time instances that may not be stored in this.?
72. change
Replaced ?if interrupted ?
With ?if the thread is interrupted by interrupt()36 or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?
In
java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt()36 or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.
73. change
Replaced ?not an instance of RealtimeThread or an async event handler.?
With ?that of a Java thread.?
In
java.lang.ClassCastException - Thrown if the current execution context is that of a Java thread.
74. change
Replaced ?java.lang.IllegalArgumentException - Thrown if clock cannot represent calendar time, or if time is a relative time less than zero.?
With
?java.lang.UnsupportedOperationException - Thrown if the sleep operation is not supported using the clock associated with time.?
java.lang.IllegalArgumentException - Thrown if time is null, or if time is a relative time less than zero.
75. change
Inserted ?it ?
in
Set up the real-time thread?s environment and start it. The set up might include delaying it until the assigned start time and initializing the thread?s scope stack.
76. change
Replaced ?scheduling or area is? with ?the parameters are?
Replaced ?default ? with ?associated?
Deleted ?or?
Inserted
?if area is heap memory, if area or scheduling is allocated in heap memory, or if this is in heap memory?
in
java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null, if area is heap memory, if area or scheduling is allocated in heap memory, or if this is in heap memory.
77. change
Replaced ?default? with ?associated?
Deleted ?or?
Inserted
?if area is null, if area is heap memory, if area, release or scheduling is allocated in heap memory, or if this is in heap memory.?
In
java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null, if area is heap memory, if area, release or scheduling is allocated in heap memory, or if this is in heap memory.
78. change
Deleted ?release?
Replaced ?area and group? with ?release?
In
IllegalAssignmentError - Thrown if the new NoHeapRealtimeThread instance cannot hold a reference to non-null values of scheduling release and area and
grouprelease, or if those parameters cannot hold a reference to the new NoHeapRealtimeThread.
79. change
Inserted
?The newly-created no-heap real-time thread is associated with the scheduler in effect during execution of the constructor.?
80. change
Replaced ?default? with ?associated?
Deleted ?or?
Inserted
?if area is heap memory, if area, scheduling release, memory or group is allocated in heap memory, if this is in heap memory, or if logic is in heap memory. ?
In
java.lang.IllegalArgumentException - Thrown if the parameters are not compatible with the associated scheduler, if area is null, if area is heap memory, if area, scheduling release, memory or group is allocated in heap memory, if this is in heap memory, or if logic is in heap memory.
81. change
Replaces ?parameters ? with ?scheduling, release, memory and group?
In
IllegalAssignmentError422 - Thrown if the new NoHeapRealtimeThread instance cannot hold references to non-null values of the scheduling release, memory and group,
or if those parameters cannot hold a reference to the new NoHeapRealtimeThread.
82. change
Replaced
?Checks if the NoHeapRealtimeThread is startable and starts it if it is. Checks that the parameters associated with this NHRT object are not allocated in heap. Also checks if this object is allocated in heap. If any of them are allocated, start() throws a MemoryAccessError?
with
?Checks if the NoHeapRealtimeThread is startable and starts it if it is.?
83. change
Delete the Throws: MemoryAccessError clause
84. change
Replaced ?inherited? with ?acquired?
Inserted ?the action of?
85. change
Replaced ?inheritance ? with ?inversion avoidance algorithms?
86. change
Replaced ?Synchronization ? with ?the Synchronization?
In
The active priority of a schedulable object, or a Java thread, is the maximum of its base priority and any priority it has acquired due to the action of priority inversion avoidance algorithms (see the Synchronization Chapter).
87. change
Replaced
?This specification does not require any particular feasibility algorithm be implemented in the Scheduler object. The default algorithm always returns success, as it assumes an adequately fast computer.?
With
?This specification does not require any particular feasibility algorithm be implemented in the Scheduler object. The default algorithm always returns success for sporadic and periodic schedulable objects, as it assumes adequate resources, but it always returns false for aperiodic schedulable objects since no pool of resources would render such a load feasible.?
88. change
Replaced ?cost enforcement ? with ?processing group enforcement?
in
Processing groups are only functional in a system that implements processing group enforcement. Although the processing group itself does not consume CPU time, it acts as a proxy for its members.
89. change
Insert semantic
?Changes to the membership of the processing group take effect immediately?
90. change
Inserted ?active ?
in
Although a system may not implement the first release (start) of a schedulable object as unblocking that schedulable object, under the base scheduler those semantics apply; i.e., the schedulable object is added to the tail of the queue for its active priority.
91. change
Replaced ?The ? with ?This?
In
The This method first performs a feasibility analysis with this added to the system.
92. change
Deleted
?the scheduling release, and memory parameters of?
from
If the resulting system is feasible, inform the scheduler and cooperating facilities that the scheduling, release, and memory parameters of this instance of Schedulable should be considered
93. change
Replace ?feasible? with ?feasibility?
In
This method first performs a feasibility analysis with this added to the system. If the resulting system is feasible, inform the scheduler and cooperating
facilities that this instance of Schedulable73 should be considered in feasibility analysis until further notified. If the analysis showed that the system including this would not be feasible, this method does not admit this to the feasibility set.
94. change
Replace ?feasible? with ?feasibility ?
In
If the object is already included in the feasibility set, do nothing.
95. change
Replaced
?Returns: True, if this was admitted to the feasible set, False, if this was not admitted because it would not be feasible or because there is no assigned instance of Scheduler.?
With
?Returns: True if inclusion of this in the feasibility set yields a feasible system, and false otherwise. If true is returned then this is known to be in the feasibility set. If false is returned this was not added to the feasibility set, but may already have been present.?
96. change
Deleted: ?the SchedulingParameters ReleaseParameters ReleaseParameters and MemoryParameters of?
from
Inform the scheduler and cooperating facilities that the SchedulingParameters ReleaseParameters and MemoryParameters of this instance of Schedulable should be considered in feasibility analysis until further notified.
97. change
Replaced ?feasible ? with ?feasibility ?
In
If the object is already included in the feasibility set, do nothing.
98. change
Replaced ?current ? with ?associated ?
in
Returns: A reference to the associated Scheduler object.
99. change
Deleted ?the parameters of ?
in
Inform the scheduler and cooperating facilities that the parameters of this instance of Schedulable82 should not be considered in feasibility analysis until it is further notified.
100. change
Deleted ?there is no assigned instance of Scheduler or if?
Replaced ?feasible ? with ?feasibility ?
in
Returns: True, if the removal was successful. False, if there is no assigned instance of Scheduler , or if the schedulable object cannot be removed from the scheduler?s feasible set; e.g., the schedulable object is not part of the scheduler?s feasible feasibility set.
101. change
Deleted ?release and memory ?
From
The method first performs a feasibility analysis using release and memory as replacements for the matching parameter values of this. If the resulting system is feasible the method replaces the current release and memory parameters of this with the new parameters.
102. change
Replaced ?The ? with ?This?
Replaced ?release and memory ? with ?the proposed parameter objects?
Replaced ?matching parameter values ? with ?current parameters?
Replaced ?feasible the ? with ?feasible, this ?
Replaced ?new parameters ? with ?proposed ones?
in
This method first performs a feasibility analysis using the proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible, this method replaces the current parameters of this with the proposed ones.
103. change
Replaced ?feasible ? with ?feasibility?
Replaced ?feasible ? with ?feasibility?
Replaced ?schedule ? with ?system?
In
This method does not require that the schedulable object be in the feasibility set before it is called. If it is not initially a member of the feasibility set it will be added if the resulting system is feasible.
104. change
Inserted
?Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.?
In
java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.
105. change
Deleted ?object ?
Replaced ?release and memory ? with ?the proposed parameter objects?
Replaced ?release or memory ? with ?parameter objects?
Replaced ?references ? with ?a reference ?
in
IllegalAssignmentError - Thrown if this object cannot hold references to release and memory the proposed parameter objects, or the release or memory parameter objects cannot hold references a reference to this.
106. change
Replaced ?The? with ?This?
Replaced ?new ReleaseParameters, MemoryParameters, and ProcessingGroupParameters? with ?proposed parameter objects?
Replaced ?feasible the? with ?feasibility, this?
Replaced ?release, memory and processing group? with ?of this?
Replaced ?corresponding replacement parameters? with ?proposed ones?
in
The This method first performs a feasibility analysis using the new ReleaseParameters , MemoryParameters and
ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible the feasible, this method replaces the current release, memory and processing group parameters of this with the corresponding replacement parameters.proposed ones.
107. change
Replaced ?feasible? with ?feasibility?
Replaced ?feasible? with ?feasibility?
Replaced ?schedule? with ?system?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
108. change
Inserted ?schedulable object?s?
Inserted ?Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.
109. change
Deleted ?object?
Replaced ?all three? with ?the proposed?
Replaced ?objects? with ?objects,?
Replaced ?parameters? with ?parameter objects?
Replaced ?references? with ?a reference?
In
IllegalAssignmentError456 - Thrown if this object cannot hold references to all three the proposed parameter objects objects, or the parameters parameter objects cannot hold references a reference to this.
110. change
Replaced ?The? with ?This?
Replaced ?new ReleaseParameters and ProcessingGroupParameters? with ?proposed parameter objects?
Replaced ?the? with ?this?
Replaced ?ReleaseParameters and ProcessingGroupParameters? with ?parameters of this?
Replaced ?new parameters? with ?proposed ones?
In
The This method first performs a feasibility analysis using the new ReleaseParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible, the this method replaces the current ReleaseParameters and ProcessingGroupParameters parameters of this with the new parametersproposed ones.
111. change
Replaced ?feasible? with ?feasibility?
Replaced ?feasible? with ?feasibility?
Replaced ?schedule? with ?system?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
112. change
Inserted ?schedulable object?s?
Inserted ?Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.?
In
java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.
113. change
Deleted ?object?
Replaced ?both? with ?the proposed?
Replaced ?objects? with ?objects,?
Replaced ?parameters? with ?parameter objects?
Replaced ?references? with ?a reference?
In
IllegalAssignmentError456 - Thrown if this object cannot hold references to both the proposed parameter objects objects, or the parameters parameter objects cannot hold references a reference to this.
114. change
Replaced ?sched? with ?scheduling? in the method declaration
115. change
Replaced ?The? with ?This?
Replaced ?release and memory? with ?the proposed parameter objects?
Replaced ?matching parameter values? with ?current parameters?
Replaced ?feasible the? with ?feasibility, this?
Deleted "scheduling, release and memory?
Replaced ?corresponding replacement parameters? with ?proposed ones?
In
The This method first performs a feasibility analysis using release and memory the proposed parameter objects as replacements for the matching parameter values current parameters of this. If the resulting system is feasible the feasible, this method replaces the current scheduling, release and memory parameters of this with the corresponding replacement parametersproposed ones.
116. change
Replaced ?feasible? with ?feasibility?
Replaced ?feasible? with ?feasibility?
Replaced ?schedule? with ?system?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
117. change
Inserted ?. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable
object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.
118. change
Inserted ?object?
Replaced ?release and memory? with ?the proposed parameter objects?
Replace ?release or memory? with ?parameter objects?
Replace ?references? with ?a reference?
In
IllegalAssignmentError456 - Thrown if this object cannot hold references to release and memory the proposed parameter objects, or the release or memory parameter objects cannot hold references a reference to this.
119. change
Rename ?sched? to ?scheduling? in the declaration
120. change
Replaced: ?new ReleaseParameters , MemoryParameters. And ProcessingGroupParameters? With: ?proposed parameter objects ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?ReleaseParameters, MemoryParameters andProcessingGroupParameters ? With: ?parameters of this ?
Replaced: ?new parameters? With: ?proposed ones?
In
The This method first performs a feasibility analysis using the new ReleaseParameters , MemoryParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of this. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters, MemoryParameters and ProcessingGroupParameters parameters of this with the new parametersproposed ones.
121. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
122. change
Inserted: ?schedulable object?s ?
Inserted: ?. Also thrown if this this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.?
In
java.lang.IllegalArgumentException - Thrown when the parameter values are not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and any of the proposed parameter objects are located in heap memory.
123. change
Deleted: ?object ?
Replaced: ?all three ? With: ?the proposed ?
Replaced: ?objects ? With: ?objects, ?
Replaced: ?parameters ? With: ?parameter objects ?
Replaced: ?references ? With: ?a reference ?
In
IllegalAssignmentError - Thrown if this object cannot hold references to all three the proposed parameter objects objects, or the parameters parameter objects cannot hold references a reference to this.
124. change
Deleted: ?, or if sched is not compatible with the scheduler associated with this.?
In
java.lang.IllegalThreadStateException - Thrown if the new release parameters change the schedulable object from periodic scheduling to some other protocol and the schedulable object is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible() , or if sched is not compatible with the scheduler associated with this.
125. change
Replaced: ?schedule? With: ?system?
In
Since this affects the constraints expressed in the memory parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.
126. change
Inserted: ?. Also thrown if this this schedulable object is no-heap and memory is located in heap memory.?
In
java.lang.IllegalArgumentException - Thrown if memory is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is no-heap and memory is located in heap memory.
127. change
?The ? With: ?This ?
Replaced: ?given memory parameters ? With: ?proposed parameter object ?
Replaced: ?replacements ? With: ?replacement ?
Replaced: ?memory parameters ? With: ?current parameter ?
Replaced: ?this ? With: ?this. ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?memory parameters ? With: ?parameter ?
Replaced: ?new memory parameters? With: ?proposed one?
In
The This method first performs a feasibility analysis using the given memory parameters proposed parameter object as replacements replacement for the memory parameters current parameter of this this. If the resulting system is feasible the feasible, this method replaces the current memory parameters parameter of this with the new memory parametersproposed one.
128. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
129. change
Replaced: ?memory ? With: ?the parameter value ?
Inserted: ?schedulable object?s ?
Inserted: ?. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when memory the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory.
130. change
Deleted ?object ?
Replaced: ?memory ? With: ?the proposed parameter object,?
Replaced: ?memory ? With: ?the parameter object ?
In
IllegalAssignmentError456 - Thrown if this object cannot hold a reference to memory the proposed parameter object, or memory the parameter object cannot hold a reference to this.
131. change
Replaced: ?schedule? With: ?system?
In
Since this affects the constraints expressed in the processing group parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.
132. change
Replaced: ?at ? With: ?as determined by ?
Replaced: ?next release of this? With: ?associated scheduler?
In
group - A ProcessingGroupParameters object which will take effect at as determined by the next release of thisassociated scheduler. If null, the default value is governed by the associated scheduler (a new object is created if the default value is not null). (See PriorityScheduler .)
133. change
Inserted: ?. Also thrown if this schedulable object is no-heap and group is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when group is not compatible with the scheduler for this schedulable object. Also thrown if this schedulable object is no-heap and group is located in heap memory.
134. change
Replaced: ?The ? With: ?This ?
Replaced: ?new ProcessingGroupParameters ? With: ?proposed parameter object ?
Deleted: ?a ?
Replaced: ?parameters ? With: ?parameter ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?ProcessingGroupParameters ? With: ?parameter of this ?
Replaced: ?new parameters. The changes ...? With: ?proposed one?
In
The This method first performs a feasibility analysis using the new ProcessingGroupParameters proposed parameter object as a replacement for the current parameters parameter of this. If the resulting system is feasible the feasible, this method replaces the current ProcessingGroupParameters parameter of this with the new parameters. The changes take place at the schedulable object?s next releaseproposed one.
135. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
136. change
Replaced: ?ProcessingGroupParameters object? With: ?proposed processing group parameters?
In
group - The ProcessingGroupParameters objectproposed processing group parameters. If null, the default value is governed by the associated scheduler (a new object is created if the default value is not null). (See PriorityScheduler .)
137. change
Replaced: ?group ? With: ?the parameter value ?
Inserted: ?schedulable object?s ?
138. change
Inserted: ?. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when group the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory.
139. change
Deleted: ?object ?
Replaced: ?group ? With: ?the proposed parameter object, ?
Replaced: ?group ? With: ?the parameter object ?
In
IllegalAssignmentError - Thrown if this object cannot hold a reference to group the proposed parameter object, or group the parameter object cannot hold a reference to this.
140. change
Replaced: ?schedule? With: ?system?
In
Since this affects the constraints expressed in the release parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.
141. change
Inserted: ?, and take effect as determined by the associated scheduler?
In
release - A ReleaseParameters object which will become the release parameters associated with this after the method call,
and take effect as determined by the associated scheduler. If null, the default value is governed by the associated scheduler (a new object is created if the default value is not null). (See PriorityScheduler .)
142. change
Inserted: ?associated ?
Inserted: ?. Also thrown if this schedulable object is no-heap and release is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when release is not compatible with the associated scheduler. Also thrown if this schedulable object is no-heap and release is located in heap memory.
143. change
Replaced: ?The ? With: ?This ?
Replaced: ?new ReleaseParameters ? With: ?proposed parameter object ?
Deleted: ?a ?
Replaced: ?parameters ? With: ?parameter ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?ReleaseParameters ? With: ?parameter of this ?
Replaced: ?new parameters? With: ?proposed one?
In
The This method first performs a feasibility analysis using the new ReleaseParameters proposed parameter object as a replacement for the current parameters parameter of this. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters parameter of this with the new parametersproposed one.
144. change
Moved from one paragraph down: ?This change becomes effective under conditions determined by the scheduler controlling the schedulable object. For instance, the change may be immediate or it may be delayed until the next release of the schedulable object. See the documentation for the scheduler for details.?
145. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
146. change
Replaced: ?ReleaseParameters object? With: ?proposed release parameters?
Inserted: ?the ?
Replaced: ?release parameters for ? With: ?value is governed by ?
Deleted: ?are used ?
Inserted: ?. (See PriorityScheduler) ?
In
release - The ReleaseParameters objectproposed release parameters. If null, the default release parameters for value is governed by the associated scheduler are used (a new object is created if the default value is not null). (See PriorityScheduler.)
147. change
Replaced: ?release ? With: ?the parameter value ?
Inserted: ?schedulable object?s ?
148. change
Inserted: ?. Also thrown if this schedulable object is no-heap and release is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when release the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is noheap and the proposed parameter object is located in heap memory.
149. change
Deleted: ?object ?
Replaced: ?release ? With: ?the proposed parameter object, ?
Replaced: ?release ? With: ?the parameter object ?
In
IllegalAssignmentError - Thrown if this object cannot hold a reference to release the proposed parameter object, or release the parameter object cannot hold a reference to this.
150. change
Replace: ?Sets the reference to the Scheduler object. The timing of the change is under the control of the new scheduler. In the case of the default scheduler, the change is made immediately. If this schedulable object has been admitted to the feasible set (e.g., by addToFeasibility()) it remains in the feasible set after the change in scheduler. This change in the scheduler may affect the feasibility of the current schedule.?
With
?Sets the reference to the Scheduler object. The timing of the change must be agreed between the scheduler currently associated with this schedulable object, and scheduler.?
151. change
Deleted: ?the new ?
Inserted: ?. Also thrown if this schedulable object is no-heap and release is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when scheduler is null, or the schedulable object?s existing parameter values are not compatible with the new scheduler. Also thrown if this schedulable object is no-heap and scheduler is located in heap memory.
152. change
Replaced: ?is under the control of the new scheduler. In the case of? With: ?must be agreed between ?
Deleted: ?default scheduler, the ?
153. change
Replaced: ?and scheduling parameters take control immediately? With: ?currently associated with this schedulable object?
Replaced: ?the release and processing group parameters take effect the next time the schedulable is released? With: ?scheduler.?
In
Sets the scheduler and associated parameter objects. The timing of the change is under the control of the new scheduler. In the case of must be agreed between the default scheduler, the scheduler and scheduling parameters take control immediatelycurrently associated with this schedulable
object, and the release and processing group parameters take effect the next time the schedulable is released. scheduler.
154. change
Deleted: ?If this schedulable object has been admitted to the feasible set (e.g., by addToFeasibility() ) it remains in the feasible set after the change in scheduler. This change in the scheduler may affect the feasibility of the current schedule.?
155. change
Replaced: ?the ? With: ?scheduler. Also thrown when this schedulable object is no-heap and?
156. change
Inserted: ?, scheduling release, memoryParameters, or group is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when scheduler is null or the parameter values are not compatible with the scheduler. Also thrown when this schedulable object is no-heap and scheduler, scheduling release, memoryParameters, or group is located in heap memory.
157. change
Replaced: ?schedule? With: ?system?
In
Since this affects the scheduling parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.
158. change
Inserted: ?associated ?
159. change
Inserted: ?. Also thrown if this schedulable object is no-heap and scheduling is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when scheduling is not compatible with the associated scheduler. Also thrown if this schedulable object is no-heap and scheduling is located in heap memory.
160. change
Replaced: ?The ? With: ?This ?
Replaced: ?given scheduling parameters ? With: ?proposed parameter object ?
Replaced: ?replacements ? With: ?replacement ?
Replaced: ?scheduling parameters ? With: ?current parameter ?
Replaced: ?this ? With: ?this. ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?scheduling parameters ? With: ?parameter ?
Replaced: ?new scheduling parameters? With: ?proposed one?
In
The This method first performs a feasibility analysis using the given scheduling parameters proposed parameter object as replacements replacement\ for the scheduling parameters current parameter of this this. If the resulting system is feasible the feasible, this method replaces the current scheduling parameters parameter of this with the new scheduling parametersproposed one.
161. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
162. change
Deleted: ?SchedulingParameters are set to the?
Replaced: ?SchedulingParameters for ? With: ?value is governed by ?
Inserted: ?a new object is created ?
Replaced: ?null a new object is created? With: ?null?
Inserted: ?. (See PriorityScheduler )?
In
scheduling - The proposed scheduling parameters. If null, the SchedulingParameters are set to the default SchedulingParameters for value is governed by the associated
scheduler (a new object is created if the default value is not null a new object is creatednull). (See PriorityScheduler108 .)
163. change
Replaced: ?scheduling ? With: ?the parameter value ?
Inserted: ?schedulable object?s ?
164. change
Inserted: ?. Also thrown if this schedulable object is no-heap and the proposed parameter object is located in heap memory?
In
java.lang.IllegalArgumentException - Thrown when scheduling the parameter value is not compatible with the schedulable object?s scheduler. Also thrown if this schedulable object is no-heap and the proposed parameter object is located in heap memory.
165. change
Deleted: ?object ?
Replaced: ?scheduling ? With: ?the proposed parameter object, ?
Replaced: ?scheduling ? With: ?the parameter object ?
In
IllegalAssignmentError456 - Thrown if this object cannot hold a reference to scheduling the proposed parameter object, or scheduling the parameter object cannot hold a reference to this.
166. change
Replaced: ?schedule? With: ?system?
In
An instance of Scheduler manages the execution of schedulable objects and implements a feasibility algorithm. The feasibility algorithm determines if the known set of schedulable objects, given their particular execution ordering (or priority assignment), is a feasible schedulesystem.
167. change
Deleted: ?(as expressed in the the associated instances?
Deleted: ?SchedulingParameters , ReleaseParameters MemoryParameters , and ProcessingGroupParameters ) of?
Replaced: ?feasible ? With: ?feasibility ?
In
Inform this scheduler and cooperating facilities that the resource demands (as expressed in the associated instances of SchedulingParameters, ReleaseParameters , MemoryParameters , and ProcessingGroupParameters ) of the given instance of Schedulable83 will be considered in the feasibility analysis of the associated
Scheduler101 until further notice. Whether the resulting system is feasible or not, the addition is completed. If the object is already included in the feasible feasibility set, do nothing.
168. change
Inserted: ?, or if schedulable is not associated with this; that is schedulable.getScheduler() != this?
In
java.lang.IllegalArgumentException - Thrown if schedulable is null, or if schedulable is not associated with this; that is schedulable.getScheduler() != this.
169. change
Replaced: ?set of scheduling and release characteristics? With: ?system ?
Inserted: ?. The definitions of ?feasible? and ?system? are the responsibility of the feasibility algorithm of the actual Scheduler subclass?
In
Queries the system about the feasibility of the set of scheduling and release characteristics system currently being considered. The definitions of ?feasible? and ?system? are the responsibility of the feasibility algorithm of the actual Scheduler subclass.
170. change
Replaced: ?the ? With: ?this ?
Replaced: ?demands, as expressed in ? With: ?demands of ?
Replaced: ?associated instances of SchedulingParameters , ReleaseParameters, MemoryParameters , and ProcessingGroupParameters , of this? With: ?given ?
In
Inform the this scheduler and cooperating facilities that the resource demands, as expressed in demands of the associated instances of SchedulingParameters , ReleaseParameters, MemoryParameters , and ProcessingGroupParameters , of this given instance of Schedulable should no longer be considered in the
feasibility analysis of the associated Scheduler . Whether the resulting system is feasible or not, the removal is completed.
171. change
Inserted: ?Parameters: schedulable - A reference to the given instance of Schedulable?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
In
Returns: True, if the removal was successful. False, if the schedulable object cannot be removed from the scheduler?s feasible feasibility set; e.g., the schedulable object is not part of the scheduler?s feasible feasibility set.
172. change
Replaced: ?constructed? With: ?constructed by a Java thread?
In
Sets the default scheduler. This is the scheduler given to instances of schedulable objects when they are constructedconstructed by a Java thread. The default scheduler is set to the required PriorityScheduler at startup.
173. change
Inserted: ?schedulable objects created by Java ?
In
scheduler - The Scheduler that becomes the default scheduler assigned to new schedulable objects created by Java threads. If null nothing happens.
174. change
Replaced: ?new ReleaseParameters and MemoryParameters? With: ?proposed parameter objects ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?ReleaseParameters and MemoryParameters ? With: ?parameters of schedulable ?
Replaced: ?new parameters? With: ?proposed ones?
In
This method first performs a feasibility analysis using the new ReleaseParameters and MemoryParameters proposed parameter objects as replacements for the current parameters of schedulable. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters and MemoryParameters parameters of chedulable with the new parametersproposed ones.
175. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
176. change
Inserted: ?of this scheduler?
Replaced: ?governed by the associated scheduler ? With: ?used ?
In
release - The proposed release parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)
177. change
Inserted: ?of this scheduler ?
Replaced: ?governed by the associated scheduler ? With: ?used ?
In
memory - The proposed memory parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)
178. change
Inserted: ?schedulable is null, or schedulable is not associated with this scheduler, or?
Inserted: ?proposed ?
Replaced: ?the schedulable object?s ? With: ?this ?
Deleted: ?, or if schedulable is null?
In
java.lang.IllegalArgumentException - Thrown if schedulable is null, or schedulable is not associated with this scheduler, or the proposed parameters are not compatible
with the schedulable object?s this scheduler, or if schedulable is null.
179. change
Deleted: ?the ?
Inserted: ?proposed ?
Replaced: ?if either ? With: ?the ?
Replaced: ?object is unable to ? With: ?objects cannot ?
IllegalAssignmentError422 - Thrown if the schedulable cannot hold references to the proposed parameter objects, or if either the parameter object is unable to objects cannot hold a reference to schedulable.
180. change
Inserted: java.lang.IllegalThreadStateException - Thrown if the new release parameters change schedulable from periodic scheduling to some other protocol and schedulable is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible().
181. change
Replaced: ?new ReleaseParameters MemoryParameters and ProcessingGroupParameters? With: ?proposed parameter objects ?
Replaced: ?feasible the ? With: ?feasible, this ?
Replaced: ?ReleaseParameters MemoryParameters and ProcessingGroupParameters ? With: ?parameters of schedulable ?
Replaced: ?new parameters? With: ?proposed ones?
In
This method first performs a feasibility analysis using the new ReleaseParameters MemoryParameters and ProcessingGroupParameters proposed parameter objects as replacements for the current parameters of schedulable. If the resulting system is feasible the feasible, this method replaces the current ReleaseParameters MemoryParameters and ProcessingGroupParameters parameters of schedulable with the new parametersproposed ones.
182. change
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?feasible ? With: ?feasibility ?
Replaced: ?schedule ? With: ?system ?
In
This method does not require that the schedulable object be in the feasible feasibility set before it is called. If it is not initially a member of the feasible feasibility set it will be added if the resulting schedule system is feasible.
183. change
Replaced: ?instance of Schedulable ? With: ?schedulable object ?
In
schedulable - The instance of Schedulable85 schedulable object for which the changes are proposed.
184. change
Inserted: ?of this scheduler ?
Replaced: ?governed by the associated scheduler ? With: ?used ?
In
release - The proposed release parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)
185. change
Inserted: ?of this scheduler ?
Replaced: ?governed by the associated scheduler ? With: ?used ?
In
memory - The proposed memory parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)
186. change
Inserted: ?of this scheduler ?
187. change
Replaced: ?governed by the associated scheduler ? With: ?used ?
In
group - The proposed processing group parameters. If null, the default value of this scheduler is governed by the associated scheduler used (a new object is created if the default value is not null). (See PriorityScheduler.)
188. change
Inserted: ?schedulable is null, or schedulable is not associated with this scheduler, or?
Inserted: ?proposed ?
Replaced: ?the schedulable object?s ? With: ?this ?
Deleted: ?, or if schedulable is null?
In
java.lang.IllegalArgumentException - Thrown if schedulable is null, or schedulable is not associated with this scheduler, or the proposed parameters are not compatible with the schedulable object?s this scheduler, or if schedulable is null.
189. change
Deleted: ?the ?
Inserted: ?proposed ?
Deleted: ?if any of ?
Replaced: ?is unable to ? With: ?cannot ?
In
IllegalAssignmentError - Thrown if the schedulablecannot hold references to the proposed parameter objects, or ifany of the parameter objects is unable to cannot hold a referenceto schedulable.
190. change
Inserted:
java.lang.IllegalThreadStateException - Thrown if the new release parameters change schedulable from periodic scheduling to some other protocol and schedulable is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible()
191. change
New method
public abstract boolean setIfFeasible(javax.realtime.Schedulable schedulable,
javax.realtime.SchedulingParameters scheduling,
javax.realtime.ReleaseParameters release,
javax.realtime.MemoryParameters memory,
javax.realtime.ProcessingGroupParameters group)
This method first performs a feasibility analysis using the proposed parameter objects as replacements for the current parameters of schedulable. the resulting system is feasible, this method replaces the current parameters schedulable with the proposed ones.
This method does not require that the schedulable object be in the feasibility set before it is called. If it is not initially a member of the feasibility set will be added if the resulting system is feasible.
Parameters:
schedulable - The schedulable object for which the changes are proposed.
scheduling - The proposed scheduling parameters. If null, the default value of this scheduler is used (a new object is created the default value is not null). (See PriorityScheduler.)
release - The proposed release parameters. If null, the default value of this scheduler is used (a new object is created if the default value is not null). (See PriorityScheduler.)
memory - The proposed memory parameters. If null, the default value of this scheduler is used (a new object is created if the default value is not null). (See PriorityScheduler.)
group - The proposed processing group parameters. If null, the default value of this scheduler is used (a new object is created the default value is not null). (See PriorityScheduler.)
Returns: True, if the resulting system is feasible and the changes are made. False, if the resulting system is not feasible and no changes are made.
Throws:
java.lang.IllegalArgumentException - Thrown if schedulable is null, or schedulable is not associated with this scheduler, or the proposed parameters are not compatible with this scheduler.
IllegalAssignmentError - Thrown if schedulable cannot hold references to the proposed parameter objects, or the parameter objects cannot hold a reference to schedulable.
java.lang.IllegalThreadStateException - Thrown if the new release parameters change schedulable from periodic scheduling to some other protocol and schedulable is currently waiting for the next release in RealtimeThread.waitForNextPeriod() or RealtimeThread.waitForNextPeriodInterruptible()
192. change
Replaced: ?required priority ? With: ?base ?
In
Class which represents the required (by the RTSJ) priority-based scheduler. The default instance is the required priority base scheduler which does fixed priority, preemptive scheduling.
193. change
Inserted:
Note that the system contains one instance of the PriorityScheduler which is the system?s base scheduler and is returned by PriorityScheduler.instance(). It may, however, contain instances of subclasses of PriorityScheduler and even additional instances of PriorityScheduler itself created through this class? protected constructor. The instance returned by the instance() method is the base scheduler and is returned by Scheduler.getDefaultScheduler() unless the default scheduler is reset with Scheduler.setDefaultScheduler(Scheduler).
194. change
Replaced: ?Return a reference to the singleton instance of PriorityScheduler.? With: ?Return a reference to the distinguished instance of PriorityScheduler which is the system?s base scheduler.?
195. change
Replaced: ?singleton ? With: ?distinguished ?
In
Returns: A reference to the singleton distinguished instance PriorityScheduler.
196. change
Deleted: ?Override the isFeasible method from Scheduler providing feasibility analysis appropriate to the priority scheduler?
Replaced: ?the system ? With: ?this scheduler ?
Replaced: ?scheduling and release characteristics ? With: ?schedulable objects ?
Replaced: ?being considered.? With: ?in the feasibility set. ?
In
Override the isFeasible method from Scheduler providing feasibility analysis appropriate to the priority scheduler. Queries the system this scheduler about the feasibility of the set of scheduling and release characteristics schedulable objects currently being considered. in the feasibility set.
197. change
Inserted:
Implementation Notes:
The default feasibility test for the PriorityScheduler considers a set of schedulable objects with bounded resource requirements, to always be feasible. This covers all schedulable objects with release parameters of types PeriodicParameters and SporadicParameters.
If any schedulable object within the feasibility set has release parameters of the exact type AperiodicParameters135 (not a subclass thereof), then the feasibility set is not feasible, as aperiodic release characteristics require unbounded resources. In that case, this method will return false and all methods in the setIfFeasible family of methods will also return false. Consequently, any call to a setIfFeasible method that passes a schedulable object which has release parameters of type AperiodicParameters, or passes proposed release parameters of type AperiodicParameters, will return false. The only time a set IfFeasible method can return true, when there exists in the feasibility set a schedulable object with release parameters of type AperiodicParameters, is when the method will change those parameters to not be AperiodicParameters.
Implementations may provide a feasibility test other than the default just described. In which case the details of that test should be documented here in place of this description of the default implementation.
198. change
Inserted: ?clones of ?
199. change
Replaced: ?visible ? With: ?high-resolution time ?
In
Return a clone of this. This method should behave effectively as if it constructed a new object with clones of the visible high-resolution time values of this.
200. change
Inserted: ? The new object has clones of all high-resolution time values (deep copy).
? References to event handlers are copied (shallow copy.)?
201. change
Replaced: ?The implementation may use copy semantics for each HighResolutionTime parameter value. For instance the value returned by getCost() must be equal to the value passed in by setCost, but it need not be the same object.
? With:
?Release parameters use HighResolutionTime values for cost, and deadline. Since the times are expressed as a HighResolutionTime318 values, these values use accurate timers with nanosecond granularity. The actual resolution available and even the quantity the timers measure depend on the clock associated with each time value.
The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained. For instance, the value returned by getCost() must be the same object passed in by setCost(), but any changes made to the time value of the cost must not take effect in the associated ReleaseParameters instance unless they are passed to the parameter object again, e.g. with a new invocation of setCost.?
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 it constructed a new object with clones of the visible high-resolution time values of this.
205. change
Insert: ? The new object has clones of all high-resolution time values (deep copy).
? References to event handlers are copied (shallow copy.)?
206. change
Insert: ?IllegalAssignmentError - Thrown if cost cannot be stored in this.?
207. change
Insert ?Throws: IllegalAssignmentError - Thrown if handler cannot be stored in this.?
208. change
Deleted: ?if ?
In
java.lang.IllegalArgumentException - Thrown if deadline is null, if the time value of deadline is less than or equal to zero,
or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.
209. change
Insert: ?IllegalAssignmentError - Thrown if deadline cannot be stored in this.?
210. change
Insert: ?Throws: IllegalAssignmentError - Thrown if handler cannot be stored in this.
211. change
Insert: ?IllegalAssignmentError - Thrown if cost or deadline cannot be stored in this.?
212. change
Replaced: ?The implementation may use copy semantics for each HighResolutionTime parameter value. For instance the value returned by getCost() must be equal to the value passed in by setCost, but it need not be the same object.?
With: ?Periodic parameters use HighResolutionTime values for period and startime. Since these times are expressed as a HighResolutionTime values, thesevalues use accurate timers with nanosecond granularity. The actual resolution available and even the quantity the timers measure depend on the clock associated with each time value.
The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained. For instance, the value returned by getCost() must be the same object passed in by setCost(), but any changes made to the time value of the cost must not take effect in the associated PeriodicParameters instance unless they are passed to the parameter object again, e.g. with a new invocation of setCost.?
213. change
Inserted: ?IllegalAssignmentError - Thrown if start or period cannot be stored in this.?
214. change
Inserted: ?IllegalAssignmentError - Thrown if start period cost, deadline, overrunHandler or missHandler cannot be stored in this.?
215. change
Inserted: ?IllegalAssignmentError - Thrown if period cannot be stored in this.?
216. change
Added override, replacing: ?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. The default value of the deadline must be controlled by the classes that extend ReleaseParameters.? With:
?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. If deadline is null, the deadline is set to a new instance of RelativeTime equal to period.?
217. change
Added override Replacing: ?java.lang.IllegalArgumentException - Thrown if deadline is null, if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?
With:
?java.lang.IllegalArgumentException - Thrown if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?
218. change
Inserted ?IllegalAssignmentError - Thrown if period, cost or deadline cannot be stored in this.?
219. change
Replaced: ?Changes to the start time of a real-time thread are only effective until invocation of the start method. Changes to the start time after invocation of start are silently ignored.?
With:
?The effect of changing the start time for any schedulable objects associated with this parameter object is determined by the scheduler associated with each schedulable object.?
220. change
Replaced: ?start - Time at which the first release begins (i.e. the schedulable object becomes eligible for execution. If a RelativeTime, this time is relative to the first time the schedulable object becomes activated (that is, when start() is called on a real-time thread or when an associated event handler is first fired). If an AbsoluteTime, then the first release is the maximum of the start parameter and the time of the call to the associated RealtimeThread.start() method (or the first firing of an associated event). If null, the default value is a new instance of RelativeTime(0,0).?
With:
?start - The new start time. If null, the default value is a new instance of RelativeTime(0,0).?
221. change
Inserted: ?IllegalAssignmentError - Thrown if start cannot be stored in this.?
222. change
Replaced: ?The implementation may use copy semantics for each HighResolutionTime parameter value. For instance the value returned by getCost() must be equal to the value passed in by setCost, but it need not be the same object.?
With:
?The implementation must use modified copy semantics for each HighResolutionTime318 parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained. For instance, the value returned by getCost() must be the same object passed in by setCost(), but any changes made to the time value of the cost must not take effect in the associated AperiodicParameters instance unless they are passed to the parameter object again, e.g. with a new invocation of setCost.?
223. change
Inserted: ?IllegalAssignmentError - Thrown if cost, deadline, overrunHandler or missHandler cannot be stored in this.?
224. change
Added override, replacing: ?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. The default value of the deadline must be controlled by the classes that extend ReleaseParameters.? With:
?deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. If deadline is null, the deadline is set to a new instance of RelativeTime(Long.MAX_VALUE, 999999).?
225. change
Added override Replacing: ?java.lang.IllegalArgumentException - Thrown if deadline is null, if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?
With:
?java.lang.IllegalArgumentException - Thrown if the time value of deadline is less than or equal to zero, or if the new value of this deadline is incompatible with the scheduler for any associated schedulable object.?
226. change
Replace: ?Returns: True, if the resulting system is feasible and the changes are made. False, if the resulting system is not feasible and no changes are made.?
With:
?Returns: false. Aperiodic parameters never yield a feasible system. (Subclasses of AperiodicParameters, such as SporadicParameters, need not return false.)?
227. change
Inserted: ?IllegalAssignmentError - Thrown if cost or deadline cannot be stored in this.?
228. change
Inserted: ?The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained.?
Before
Only changes to a SporadicParameters object caused by methods on that object cause the change to propagate to all schedulable objects using the parameter object.
229. change
In the default value table,
Replaced the default for deadline ?Long.MAX_VALUE, 999999)? With: ?mit?
230. change
Inserted: ?IllegalAssignmentError - Thrown if minInterarrival cannot be stored in this.?
231. change
Replaced: ?Long.MAX_VALUE, 999999? With: ?mit?
In
deadline - The latest permissible completion time measured from the release time of the associated invocation of the schedulable object. For a minimum implementation for purposes of feasibility analysis, the deadline is equal to the minimum interarrival interval. Other implementations may use this parameter to compute execution eligibility. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit).
Inserted: ?IllegalAssignmentError - Thrown if minInterarrival, cost, deadline, overrunHandler or missHandler cannot be stored in this.?
232. change
added override
Replaced: ?Long.MAX_VALUE, 999999? With: ?mit?
In
deadline - The proposed deadline. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit)
233. change
Replaced: ?Long.MAX_VALUE, 999999? With: ?mit?
In
deadline - The proposed deadline. If null, the default value is a new instance of RelativeTime(Long.MAX_VALUE, 999999mit).
234. change
Inserted: ?IllegalAssignmentError - Thrown if interarrival, cost or deadline cannot be stored in this.?
235. change
Inserted: ?IllegalAssignmentError - Thrown if minimum cannot be stored in this.?
236. change
Replaced: ?cannot measure execution time? With: ?do not support processing group parameters?
In
This is associated with one or more schedulable objects for which the system guarantees that the associated objects will not be given more time per period than indicated by cost. On implementations which cannot measure execution timedo not support processing group parameters, this class may be used as a hint to the feasibility algorithm.
237. change
Inserted: ?Processing group parameters use HighResolutionTime values for cost, deadline, period and start time. Since those times are expressed as a HighResolutionTime, the values use accurate timers with nanosecond granularity. The actual resolution available and even the quantity it measures depends on the clock associated with each time value.?
238. change
Inserted: ?The implementation must use modified copy semantics for each HighResolutionTime parameter value. The value of each time object should be treated as if it were copied at the time it is passed to the parameter object, but the object reference must also be retained.?
Before
Only changes to a ProcessingGroupParameters object caused by methods on that object are immediately visible to the scheduler.
239. change
Inserted: ?if cost is null, ?
240. change
Inserted: ?if ?
241. change
Inserted: ?than zero and less than or equal to the period. If the implementation does not support processing
group deadline less than period, deadline less?
242. change
Replaced: ?zero? With: ?period will cause IllegalArgumentException to be thrown?
In
java.lang.IllegalArgumentException - Thrown if the period is null or its time value is not greater than zero, if cost is null, or if the time value of cost is less than zero, if start is an instance of RelativeTime and its value is negative, or if the time value of deadline is not greater than zero and less than or equal to the period. If the implementation does not support processing group deadline less than period, deadline less than zeroperiod will cause IllegalArgumentException to be thrown.
243. change
Inserted: ?IllegalAssignmentError - Thrown if start, period, cost, deadline, overrunHandler or missHandler cannot be stored in this.?
244. change
Inserted: ?clones of ?
245. change
Replaced: ?visible ? With: ?high-resolution time ?
246. change
Inserted: ?The new object has clones of all high-resolution time values (deep copy).
? References to event handlers are copied (shallow copy.)?
In
Return a clone of this. This method should behave effectively as if it constructed a new object with clones of the visible high-resolution time values of this.
? The new object is in the current allocation context.
? clone does not copy any associations from this and it does not
implicitly bind the new object to a SO.
? The new object has clones of all high-resolution time values (deep copy).
? References to event handlers are copied (shallow copy.)
247. change
Inserted: ?IllegalAssignmentError - Thrown if cost cannot be stored in this.?
248. change
Inserted: ?Throws: IllegalAssignmentError - Thrown if handler cannot be stored in this.?
249. change
Inserted: ?Throws:
java.lang.IllegalArgumentException - Thrown if deadline has a value less than zero or greater than the period. Unless the implementation supports deadline less than period in processing groups, IllegalArgumentException is also thrown if deadline is less than the period.
IllegalAssignmentError - Thrown if deadline cannot be stored in this.?
250. change
Inserted: ?Throws:
IllegalAssignmentError - Thrown if handler cannot be stored in this.?
251. change
Inserted: ?IllegalAssignmentError - Thrown if period cost deadline cannot be stored in this.?
252. change
Inserted: ?. If the implementation does not support processing group deadline less than period, and period is not equal to the current value of the processing group?s deadline, the deadline is set to a clone of period created in the same memory area as period.?
In
java.lang.IllegalArgumentException - Thrown if period is null, or its time value is not greater than zero. If the implementation does not support processing group deadline less than period, and period is not equal to the current value of the processing group?s deadline, the deadline is set to a clone of period created in the same memory area as period.
253. change
Inserted: ?IllegalAssignmentError - Thrown if period cannot be stored in this.?
254. change
Inserted: ?alters the value of this object?s start time property, but?
255. change
Inserted: ?other ?
In
Sets the value of start. If the processing group is already started this method alters the value of this object?s start time property, but has no other effect.
256. change
Replaced: ?java.lang.IllegalStateException ? With: ?IllegalAssignmentError ?
257. change
Replaced: ?the processing group is already started? With: ?start cannot be stored in this?
In
java.lang.IllegalStateException IllegalAssignmentError456 - Thrown if the processing group is already startedstart cannot be stored in this.
258. change
Inserted: ?java.lang.IllegalArgumentException Thrown if start is a relative time value and less than zero.?
259. change
Replaced: ?spend ? With: ?spent ?
In
Execution time of object constructors, and time spend spent in class loading and static initialization are not governed by bounds on object allocation in this specification, but?
260. change
Replaced: ?area ? With: ?area, m, ?
Replaced: ?the ? With: ?m.?
Inserted: ?(or another ?
Inserted: ?from the family ?
Replaced: ?the instance, the memory area? With: ?enter-like methods in MemoryArea or ScopedMemory) m?
In
A memory area is represented by an instance of a subclass of the MemoryArea class. When a memory area area, m, is entered by calling the m.enter (or another method from the family of the instance, the memory area enter-like methods in MemoryArea or ScopedMemory) m becomes the allocation context of the current schedulable object. When control returns from the enter method, the allocation context is restored to the value it had immediately before enter was called.
This semantic is a modified version of what was semantic 11
261. change
Inserted: ?The initial allocation context for a schedulable object when it is first released, is the memory area that was designated the initial memory area when the schedulable object was constructed. This initial allocation context becomes the current allocation context for that schedulable object when the schedulable object first becomes eligible for execution. For async event handlers, the initial allocation context is the same on each release; for real-time threads, in releases subsequent to the first, the allocation context is the same as it was when the real-time thread became blocked-for-release-event.?
262. change
Inserted: ?, but note that allocation can be performed in a specific memory area using the
newInstance and newArray methods.?
In
All object allocation through the new keyword will use the current allocation context, but note that allocation can be performed in a specific memory area using the newInstance and newArray methods.?
The concept of ?enclosing allocation context has been replaced with a more formal model of Scope Stack. The contained semantics are relocated to the semantics in Maintaining the Scope Stack
263. change
Deleted:
7 The enclosing allocation context of a memory area, mem for a schedulable object, t, is the allocation context in effect for t immediately before it calls mem.enter.
8. The structure of enclosing allocation contexts, the scope stack, is accessible through a set of static methods on RealtimeThread. These methods allow outer allocation contexts to be accessed by their index number. The algorithms for maintaining the scope stack are given in ?Maintaining the Scope Stack.?
264. change
Consolidated with ?Maintaining the Scope Stack semantic 4
9. The executeInArea method may only be used on memory areas that are outer scopes on the current schedulable object?s scope stack.
The following semantics pertain to the scope stack
265. change
Inserted:
10 Schedulable objects behave as if they stored their memory area context in a structure called the scope stack. This structure is manipulated by creation of schedulable objects, and the following methods from the MemoryArea and ScopedMemory classes: all the enter and joinAndEnter methods, executeInArea, and both newInstance methods. See the semantics in Maintaining the Scope Stack for details.
266. change
Inserted
11. The scope stack is accessible through a set of static methods on RealtimeThread. These methods allow outer allocation contexts to be accessed by their index number. Memory areas on a scope stack may be referred to as inner or outer relative to other entries in that scope stack. An ?outer scope? is further from the current allocation context on the current scope stack and has a lower index.
267. change
Inserted
12. The executeInArea, newInstance and newArray methods, when invoked on an instance of ScopedMemory require that instance to be an outer allocation context on the current schedulable object?s current scope stack.
Inserted
268. change
13. An instance of ScopedMemory is said to be in use if it has a non-zero reference count as defined by semantic (17) below.
269. change
Inserted subsection. Parent Scope
270. change
Replaced: ?If ? With: ?When ?
Inserted: ?becomes in use, its parent?
Replaced: ?in use and ? With: ?the nearest ScopedMemory object outside it on the current scope stack. If?
Replaced: ?enclosing scoped memory? With: ?outside ScopedMemory object in the current scope stack?
Deleted: ?ScopedMemory objects in this class. For all other?
Deleted: ?, the parent is the nearest ScopedMemory object outside it on the current schedulable object?s scope stack.?
In
Instances of ScopedMemory have special semantics including definition of parent. If a ScopedMemory object is not in use, it has no parent scope. If When a Scoped- Memory object becomes in use, its parent is in use and the nearest ScopedMemory object outside it on the current scope stack. If there is no enclosing scoped memoryoutside ScopedMemory object in the current scope stack, the parent is the primordial scope which is not actually a memory area, but only a marker that constrains the parentage of ScopedMemory objects in this class. For all other ScopedMemory objects, the parent is the nearest ScopedMemory object outside it on the current schedulable object?s scope stack.
271. change
Replaced: ?are made current by entering them or passing them as the initial memory area for a new schedulable object? With: ?become in use ?
272. change
Replaced: ?9. ? With: ?(11.) ?
In
Instances of ScopedMemory that are made current by entering them or passing them as the initial memory area for a new schedulable object become in use must satisfy the single parent rule which requires that each scoped memory has a unique parent as defined in semantic 9. (11.)
273. change
New semantic: ?Pushing a scoped memory onto a scope stack is always subject to the single parent rule.?
274. change
Inserted: ?execution of ?
In
Each schedulable object has an initial memory area which is that object?s initial allocation context. The default initial memory area is the current allocation context in effect during execution of the schedulable object?s constructor, but schedulable objects may supply constructors that override the default.
275. change
Now redundant with to Maintaining the Scope Stack semantic 2 -- deleted:
If a schedulable object, t, creates a schedulable object, nt, in a ScopedMemory object?s allocation area, nt inherits the stack of nested memory areas associated with t at the time nt is constructed including all entries from up to and including the memory area containing nt. If nt is created in heap, immortal, or immortal physical memory, nt is created with a scope stack containing only heap, immortal, or immortal physical memory respectively.
276. change
Replaced: ?An instance of java.lang.Thread? With: ?A Java thread ?
Replaced: ?an instance of java.lang.Thread? With: ?a Java thread ?
Inserted: ?a ?
Inserted: ?area ?
In
An instance of java.lang.Thread A Java thread cannot have a scope stack; consequently it can only be created and execute within heap or immortal memory. An attempt to create an instance of java.lang.Thread a Java thread in a scoped memory area throws IllegalAssignmentError.
277. change
Replaced: ?An instance of java....? With: ?A Java thread ?
278. change
Replaced: ?13? With: ?15?
In
An instance of java.lang.Thread A Java thread may use executeInArea, and the newInstance and newArray methods from the ImmortalMemory and Heap- Memory classes. These methods allow it to execute with an immortal current allocation context, but semantic (1315) applies even during execution of these methods. .
279. change
Inserted: ?Each instance of the class ScopedMemory or its subclasses must maintain a referencecount which is greater than zero if and only if either:?
Deleted: ?Each instance of the class ScopedMemory or its subclasses must maintain a reference count which is greater than zero if and only if the?
Replaced: ?. For purposes of this semantic? With: ?; or else ?
280. change
Inserted:
? the scoped memory area is the initial memory area for a schedulable object. In this context, a schedulable objects ceases to be a source of a non-zero reference count on its initial memory area when either:
? the schedulable object is a RealtimeThread and it terminates; or else
? the schedulable object is de-allocated from its memory area.
For purposes of this semantic the following are treated as execution contexts:?
281. change
Inserted: ?been started and have ?
Deleted: ?and ?
Deleted: ?are treated as execution contexts.?
In
21. Each instance of the class ScopedMemory or its subclasses must maintain a reference
count which is greater than zero if and only if either:
? Each instance of the class ScopedMemory or its subclasses must maintain a reference count which is greater than zero if and only if the scoped memory area is the current allocation context or an outer allocation context for one or more execution contexts. For purposes of this semantic, ; or else
? the scoped memory area is the initial memory area for a schedulable object. In this context, a schedulable objects ceases to be a source of a non-zero reference count on its initial memory area when either:
? the schedulable object is a RealtimeThread and it terminates; or else
? the schedulable object is de-allocated from its memory area.
For purposes of this semantic the following are treated as execution contexts:
? RealtimeThread objects that have been started and have not terminated,
? AsyncEventHandler objects that are currently in a released state,
? AsyncEvent objects that are bound to happenings,
? Timer objects that have been started and have not been destroyed, and
? other schedulable objects that control an execution engine
282. change
Inserted: ?still ready to be decremented to?
283. change
Inserted: ?then it is decremented to zero and?
In
When the reference count for an instance of the class ScopedMemory is ready to be decremented from one to zero, all unfinalized objects within that area are considered ready for finalization. If after the finalizers for all unfinalized objects in the scoped memory area run to completion, the reference count for the memory area is still ready to be decremented to zero, then it is decremented to zero and the memory scope is emptied of all objects. The RTSJ implementation must complete finalization of objects in the scope and, if the reference count is zero after finalizers run, deletion of the objects in the scope before that memory scope can again become the current allocation context for any schedulable object. (This is a special case of the finalization implementation specified in The Java Language Specification, second edition, section 12.6.1)
284. change
Inserted: ?. Static initializers are executed executed effectively as if the current thread performed ImmortalMemory.instance().executeInArea(r) where r is a Runnable that executes the <clinit> method of the class being initialized.?
In
Class objects, the associated static memory, and interned Strings behave effectively as if they were allocated in immortal memory with respect to reference rules, assignment rules, and preemption delays by no-heap schedulable objects. Static initializers are executed effectively as if the current thread performed ImmortalMemory.instance().executeInArea(r) where r is a Runnable that executes the <clinit> method of the class being initialized.
285. change
Replaced each: ?Yes? With: ?Permit?
286. change
For Local Variable: Replaced ?Yes, if the reference is from the same scope, or an outer scope? with ?Permit?
287. change
Replaced each: ?No? With: ?Forbid?
288. change
Replaced: ?area? With: ?are?
In
For this table, ImmortalMemory and ImmortalPhysicalMemory are equivalent, and all sub-classes of ScopedMemory area are equivalent.
289. change
Inserted: ?Checks for operations on local variables are not required because a potentially invalid reference would be captured by the other checks before it reached a local variable.?
In
An implementation must ensure that the above checks are performed on every assignment statement before the statement is executed. (This includes the possibility of static analysis of the application logic). Checks for operations on local variables are not required because a potentially invalid reference would be captured by the other checks before it reached a local variable.
290. change
Replaced: ?Five ? With: ?Four ?
291. change
Replaced: ?method ? With: ?methods ?
292. change
Replaced: ?MemoryArea? With: ?MemoryArea and ScopedMemory?
293. change
Deleted: ?starting a schedulable object, ?
294. change
Deleted: ?all ?
295. change
Inserted:
?1. The memory area at the top of a schedulable object?s scope stack is the schedulable object?s current allocation context.
2. When a schedulable object, t, creates a schedulable object, nt, in a ScopedMemory object?s allocation area, nt acquires a copy of the scope stack associated with t at the time nt is constructed including all entries from up to and including the memory area containing nt. If nt is created in heap, immortal, or immortal physical memory, nt is created with a scope stack containing only heap, immortal, or immortal physical memory respectively.
3. When a memory area, ma, is entered by calling a ma.enter method, ma is pushed on the scope stack and becomes the allocation context of the current schedulable object. When control returns from the enter method, the allocation context is popped from the scope stack
4. When a memory area, m, is entered by calling m?s executeInArea method or one of the m.newInstance methods the scope stack before the method call is preserved and replaced with a scope stack constructed as follows:
? If ma is a scoped memory area the new scope stack is a copy of the schedulable object?s previous scope stack up to and including ma.
? If ma is not a scoped memory area the new scope stack includes only ma.
When control returns from the executeInArea method, the scope stack is restored to the value it had before ma.executeInArea or ma.newInstance was called.?
In
Five Four operations effect the scope stack: the enter method methods in MemoryAreaMemoryArea and ScopedMemory, construction of a new schedulable object, starting a schedulable object, the executeInArea method in MemoryArea, and all the new instance methods in MemoryArea.
1. The memory area at the top of a schedulable object?s scope stack is the schedulable object?s current allocation context.
2. When a schedulable object, t, creates a schedulable object, nt, in a ScopedMemory object?s allocation area, nt acquires a copy of the scope stack associated with t at the time nt is constructed including all entries from up to and including the memory area containing nt. If nt is created in heap, immortal, or immortal physical memory, nt is created with a scope stack containing only heap, immortal, or immortal physical memory respectively.
3. When a memory area, ma, is entered by calling a ma.enter method, ma is pushed on the scope stack and becomes the allocation context of the current schedulable object. When control returns from the enter method, the allocation context is popped from the scope stack
4. When a memory area, m, is entered by calling m?s executeInArea method or one of the m.newInstance methods the scope stack before the method call is preserved and replaced with a scope stack constructed as follows:
? If ma is a scoped memory area the new scope stack is a copy of the schedulable object?s previous scope stack up to and including ma.
? If ma is not a scoped memory area the new scope stack includes only ma.
When control returns from the executeInArea method, the scope stack is restored to the value it had before ma.executeInArea or ma.newInstance was called.
296. change
Replace
For ma.enter(logic):
if entering ma would violate the single parent rule
throw ScopedCycleException
push ma on the scope stack belonging to the current
schedulable object
execute logic.run method
pop ma from the scope stack
With
For ma.enter(logic):
push ma on the scope stack belonging to the current
schedulable object -- which may throw
ScopedCycleException
execute logic.run method
pop ma from the scope stack
297. change
Rename section to Construct a Schedulable Object
298. change
Replace
if cma is heap, immortal or ImmortalPhysicalMemory
create a new scope stack containing cma
else
start a new scope stack containing the
entire current scope stack
if ima != cma
push ima on new scope stack
which may throw ScopedCycleException
To start the schedulable object:
for every scoped memory area in the
schedulable object's scope stack
increment the reference count
run the new schedulable object with the
new scope stack
when the schedulable object terminates
every memory area pushed by the
schedulable object will have been popped
for every scoped memory area in the scope stack
decrement the reference count
discard the schedulable objects scope stack.
With
if cma is heap, immortal or ImmortalPhysicalMemory
create a new scope stack containing cma
else
start a new scope stack containing the
entire current scope stack
if ima != cma
push ima on new scope stack --
which may throw ScopedCycleException
299. change
Delete: ?Note that freeing and terminating a schedulable object are symmetrical to constructing and starting it except that the memory area pushed in the constructor is popped when the schedulable object terminates.?
300. change
Replaced: ?below ? With: ?outside ?
In
For all other scoped memory areas, the parent is the first scoped memory area below outside it on the scope stack. .
301. change
Deleted: ?ma.refCount++?
In
precondition: ma.parent is set to the correct parent
(either a scoped memory area or the primordial scope) or to noParent
t.scopeStack is the scope stack of the current schedulable object
if ma is scoped
parent = findFirstScope(t.scopeStack)
if ma.parent == noParent
ma.parent = parent
else if ma.parent != parent
throw ScopedCycleException
else
t.scopeStack.push(ma)
ma.refCount++
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 scope stack can easily become a tree, and although? With: ?Although ?
304. change
Inserted: ?. Also, although the scope stack?s behavior is specified as a stack, an implementation is free to use any data structure that preserves the stack semantics?
In
The term scope stack might mislead a reader to infer that it is a stack that contains only scoped memory areas. Both of those inferences are This is incorrect. With executeInArea and thread creation the scope stack can easily become a tree, and although Although the scope stack may contain scoped memory references, it may also contain heap and immortal memory areas. Also, although the scope stack?s behavior is specified as a stack, an implementation is free to use any data structure that preserves the stack semantics.
305. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules?
In
IllegalAssignmentError456 - Thrown if storing logic in this would violate the assignment rules.
306. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules?
In
IllegalAssignmentError456 - Thrown if storing logic in this would violate the assignment rules.
307. change
Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?
In
java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.
308. change
Inserted: ?ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.?
In
ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.
309. change
Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?
In
java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.
310. change
Inserted: ?ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.?
In
ThrowBoundaryError - Thrown when the JVM needs to propagate an exception allocated in this scope to (or through) the memory area of the caller. Storing a reference to that exception would cause an IllegalAssignmentError , so the JVM cannot be permitted to deliver the exception. The ThrowBoundaryError is allocated in the current allocation context and contains information about the exception it replaces.
311. change
Replaced: ?If the memory area is a scoped memory type, this method behaves as if it had moved? With: ?The effect of executeInArea on ?
Deleted: ?allocation context down the ?
Replaced: ?to ? With: ?is specified in ?
312. change
Replaced: ?occurrence ? With: ?subclasses ?
313. change
Replaced: ?the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stack? With: ?MemoryArea?
In
Execute the run method from the logic parameter using this memory area as the current allocation context. If the memory area is a scoped memory type, this method behaves as if it had moved The effect of executeInArea on the allocation context down the scope stack to is specified in the occurrence subclasses of the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stackMemoryArea.
314. change
Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack?
315. change
Inserted: ?. To create an array of a primitive type use a type such as Integer?
316. change
Inserted: ?(which would call for an array of the primitive int type.)?
In
type - The class of the elements of the new array. To create an array of a primitive type use a type such as Integer.TYPE (which would call for an array of the primitive int type.)
317. change
Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack.?
318. change
Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack.?
319. change
Deleted: ?InaccessibleAreaException - Thrown if the memory area is not in the schedulable object?s scope stack.?
320. change
Insert method override:
Giving
public void executeInArea(java.lang.Runnable logic)
Execute the run method from the logic parameter using heap as the current allocation context. For a schedulable object, this saves the current scope stack and replaces it with one consisting only of the HeapMemory instance; restoring the original scope stack upon completion.
Overrides: executeInArea in class MemoryArea
Parameters:
logic - The runnable object whose run() method should be executed.
Throws:
java.lang.IllegalArgumentException - Thrown if logic is null.
321. change
Insert method override
Giving
public void executeInArea(java.lang.Runnable logic)
Execute the run method from the logic parameter using this memory area as the current allocation context. For a schedulable object, this saves the
current scope stack and replaces it with one consisting only of the ImmortalMemory instance; restoring the original scope stack upon completion.
Overrides: executeInArea in class MemoryArea
Parameters:
logic - The runnable object whose run() method should be executed.
Throws:
java.lang.IllegalArgumentException - Thrown if logic is null.
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 a primitive type.
324. change
Deleted: ?When logic.run() is complete, the scoped memory area is no longer active, and its reference count will be decremented.?
325. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
326. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in 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 a Java 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 a Java 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 or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stack? With: ?this?
In
Description copied from class: javax.realtime.MemoryArea
Execute the run method from the logic parameter using this memory area as the current allocation context. If the memory area is a scoped memory type, this This method behaves as if it had moved moves the allocation context down the scope stack to the occurrence of the memory area. If the memory area is heap or immortal memory, this method behaves as if the run method were running in that memory type with an empty scope stackthis.
335. change
Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?
In
java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.
336. change
Replaced: ?the value from the portal is to an object in a scope that? With: ?this ?
IllegalAssignmentError - Thrown if a reference to the portal object cannot be stored in the caller?s allocation context; that is, if the value from the portal is to an object in a scope that this is ?inner? relative to the current allocation context.
337. change
Inserted: ?java.lang.IllegalThreadStateException - Thrown if the caller is a Java thread.?
338. change
Inserted: ?Since the time is expressed as a HighResolutionTime , this method is an accurate timer with nanosecond granularity. The actual resolution of the timer and even the quantity it measures depends on the clock associated with time. The delay time may be relative or absolute. If relative, then the delay is the amount of time given by time, and measured by its associated clock. If absolute, then the delay is until the indicated value is reached by the clock. If the given absolute time is less than or equal to the current value of the clock, the call to join returns immediately.?
339. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?
340. change
Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.
Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?
341. change
Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.
Since the time is expressed as a HighResolutionTime, this method has an accurate timer with nanosecond granularity. The actual resolution of the timer and even the quantity it measures depends on the clock associated with time. The delay time may be relative or absolute. If relative, then the calling thread is blocked for at most the amount of time given by time, and measured by its associated clock. If absolute, then the time delay is until the indicated value is reached by the clock. If the given absolute time is less than or equal to the current value of the clock, the call to joinAndEnter returns immediately.
Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?
342. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?
343. change
Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.
Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?
344. change
Inserted: ?Since the time is expressed as a HighResolutionTime , this method is an accurate timer with nanosecond granularity. The actual resolution of the timer and even the quantity it measures depends on the clock associated with time. The delay time may be relative or absolute. If relative, then the delay is the amount of time given by time, and measured by its associated clock. If absolute, then the delay is until the indicated value is reached by the clock. If the given absolute time is less than or equal to the current value of the clock, the call to join returns immediately.?
345. change
Inserted: ?If multiple threads are waiting in joinAndEnter family methods for a memory area, at most one of them will be released each time the reference count goes to zero.?
Note that although joinAndEnter guarantees that the reference count is zero when the schedulable object is released for entry, it does not guarantee that the reference count will remain one for any length of time. A subsequent enter could raise the reference count to two.?
346. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?
347. change
Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?
In
java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.
348. change
Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?
In
java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.
349. change
Replaced: ?IllegalStateException ? With: ?IllegalThreadStateException ?
In
java.lang.IllegalStateException IllegalThreadStateException - Thrown if the caller is a Java thread.
350. change
Inserted: ?IllegalThreadStateException is thrown when called by a Java thread even when the invocation could also throw IllegalArgumentException.?
351. change
Replaced: ?the ? With: ?this ?
In
InaccessibleAreaException - Thrown if the this memory area is not in the caller?s scope stack.
352. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
353. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
354. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
355. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
356. change
Replaced: ?VTMemory? With: ?LTMemory?
In
VTMemory is similar to VTMemoryLTMemory except that the execution time of an allocation from a VTMemory area need not complete in linear time.
357. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
358. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
359. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
360. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
361. change
Replaced: ?The base implementation will provide a PhysicalMemoryManager and a set of PhysicalMemoryTypeFilter classes that correctly identify memory classes that are standard for the (OS, JVM, and processor) platform.?
With: ?The base implementation will provide a PhysicalMemoryManager.?
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 logic in this would violate the assignment rules.?
365. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
366. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
367. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
368. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
369. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
370. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
371. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
372. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
373. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
374. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
375. change
Inserted: ?IllegalAssignmentError - Thrown if storing logic in this would violate the assignment rules.?
376. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
377. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
378. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
379. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
380. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
381. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
382. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
383. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
384. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
385. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
386. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
387. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
388. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
389. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
390. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
391. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
392. change
Replaced: ?block until one load or store completes? With: ?throw an IllegalStateException?
Replaced: ?It ? With: ?The unmap method ?
In
If an unmap is requested while another schedulable object is accessing the raw memory, the unmap will block until one load or store completesthrow an IllegalStateException. It The unmap method can interrupt an array operation between entries.
393. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
394. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
395. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
396. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
397. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
398. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
399. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
400. change
Inserted: ?java.lang.SecurityException - Thrown if this access is not permitted by the security manager.?
401. change
Replaced: ?allocationrate ? With: ?allocationRate ?
In
allocationRate - A limit on the rate of allocation in the heap. Units are in bytes per second of wall clock time. If allocationrate allocationRate is zero, no allocation is allowed in the heap.
402. change
Replaced: ?default ? With: ?base ?
In
The classes in this section establish a framework for priority inversion management that applies to priority-oriented schedulers in general, and a specific set of requirements for the default base priority scheduler.
403. change
In the subsection title
Replaced: ?Default ? With: ?Base ?
404. change
Replaced: ?default ? With: ?base ?
In
The following list defines the main terms and establishes the general semantics and requirements that apply to threads and schedulable objects managed by the default base priority scheduler when they synchronize on objects governed by monitor control policies defined in this section.
405. change
Inserted: ?A thread or schedulable object that holds a lock on a PCE-governed object also has a ceiling priority.?
In
1. Each thread or schedulable object has a base priority and an active priority. A thread or schedulable object that holds a lock on a PCE-governed object also has a ceiling priority.
406. change
Deleted: ?an instance of ?
In
? t.setPriority(prio)
if t is an instance of java.lang.Thread the new base priority is the lesser of prio, Thread.MAX_PRIORITY, and the maximum priority for t?s thread group. If t is an instance of a schedulable object, the new base priority is prio.
407. change
Inserted: ?modification of the priority of the priority of t through?
In
3. When t does not hold any locks, its active priority is the same as its base priority. In such a situation modification of the priority of t through an invocation of any of the above priority-setting methods for t causes t to be placed at the tail of its relevant queue (ready, blocked on a particular object, etc.) at its new priority.
408. change
Replaced: ?for ? With: ?resulting from ?
Replaced: ?section ? With: ?section, ?
Replaced: ?entity t ? With: ?object t, ?
In
4. When t holds one or more locks, then t has a set of priority sources. The active priority for t at any point in time is the maximum of the priorities associated with all of these sources. The priority sources for resulting from the monitor control policies defined in this section section, and their associated priorities for a schedulable entity t object t, are as follows:
409. change
Inserted: ?either synchronously or ?
In
Note: This may have been changed (either synchronously or asynchronously) while t has been holding its lock(s).
410. change
Replaced: ?the active ? With: ?a ?
Replaced: ?t (see ? With: ?t. This value is ...?
Replaced: ?description of the setMonitorControl instance method?
With: ?ceiling priority ?
Replaced: ?a definition of ?active monitor control policy? With: ?t?
Deleted: ??)?
In
Associated priority: The maximum value ceil such that ceil is the ceiling for the active a PriorityCeilingEmulation policy governing an object locked by t (see t. This value is also referred to as the description of the setMonitorControl instance method ceiling priority for a definition of ?active monitor control policyt.?)
411. change
Inserted: ?Source: Each thread or schedulable object that is attempting to synchronize on an object locked by t and governed by a PriorityCeilingEmulation policy.
Associated priority: The maximum active priority over all such threads and schedulable objects
Note: This rule, which in effect allows a PriorityCeilingEmulation lock to behave like a PriorityInheritance lock, helps avoid unbounded priority inversions that could otherwise occur in the presence of nested synchronizations involving a mix of PriorityCeilingEmulation and Priority-Inheritance policies. ?
412. change
Replaced: ?should ? With: ?must ?
413. change
Inserted: ?, if the implementation is supporting PriorityCeilingEmulation. If the implementation is not supporting PriorityCeilingEmulation then t should be placed at the head of the ready queue at its new active priority?
Inserted: ?If the implementation is not supported?
Replaced: ?In any event ? With: ?If PriorityCeilingEmulation is not supported,?
Inserted: ?queue placement ?
414. change
Replaced: ?preferred. ? With: ?recommended.?
In
6. The removal of a priority source for t either leaves t?s active priority unchanged, or decreases it. If t?s active priority is unchanged, then t?s status in its relevant queue (e.g. blocked waiting for some object) is not affected. If t?s active priority is decreased and t is either ready or running, then t should must be placed at the head of the ready queue at its new active priority level, if the implementation is supporting PriorityCeilingEmulation. If the implementation is not supporting PriorityCeilingEmulation then t should be placed at the head of the ready queue at its new active priority (Note the ?should?: this behavior is optional.) In any event If PriorityCeilingEmulation is not supported, the implementation must document the queue placement effect. If t?s active priority is decreased and
t is blocked, then t is placed in the corresponding queue at its new active priority level. Its position in the queue is implementation defined, but placement at the tail is preferred. recommended.
415. change
Replaced: ?5? With: ?4?
416. change
Replaced: ?5? With: ?4.a, 4?
417. change
Replaced: ?a ? With: ?c ?
418. change
Replaced: ?5? With: ?4?
419. change
Replaced: ?c ? With: ?d ?
In
? A thread or schedulable object t?s priority sources from 54.b are added and removed synchronously; i.e., they are established based on t?s entering or leaving synchronized code. However, priority sources from 54.a, 4.a c and 54.c d may be added and removed asynchronously, as an effect of actions by other threads or schedulable objects. .
420. change
Replaced: ?It is a consequence of other rules that if a thread or schedulable object t holds a PriorityCeilingEmulation lock, then it will not inherit a priority, nor have a new priority assigned, that exceeds the lock?s ceiling. Unless otherwise stated, the unqualified term ?priority? hereafter means ?active priority? rather than ?base priority?.?
With: ?It is a consequence of other rules that, when a thread or schedulable object t attempts to synchronize on an object obj governed by a PriorityCeilingEmulation policy with ceiling ceil, then t?s active priority may exceed ceil but t?s base priority must not. In contrast, once t has successfully synchronized on obj then t?s base priority may also exceed obj?s monitor control policy?s ceiling. Note that t?s base priority and/or obj?s monitor control policy may have been dynamically modified.?
421. change
Replaced: ?default ? With: ?base ?
In:
The following list establishes the semantics and requirements that apply to threads or schedulable objects managed by a scheduler other than the default base priority scheduler when they synchronize on objects with monitor control policies defined in this section.
422. change
Replaced: ?priority inversions ? With: ?dependencies ?
Replaced: ?result (to prevent heap corruption when the garbage collector has been preempted) when the object is governed by PriorityInheritance? With: ?result?
In
Since the same object may be accessed from synchronized code by both a NoHeapRealtimeThread and an arbitrary thread or schedulable object, unwanted priority inversions dependencies may result (to prevent heap corruption when the garbage collector has been preempted) when the object is governed by PriorityInheritanceresult. To avoid this problem, this specification provides three wait-free queue classes as an alternative means for safe, concurrent data accesses without priority inversion.
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 of the default monitor control policy occurs immediately.
426. change
Replaced: ?SecurityException ? With: ?IllegalArgumentException ?
Replaced: ?the caller ? With: ?policy ?
Replaced: ?permitted to alter the default monitor control policy? With: ?in immortal memory?
In
java.lang.SecurityException IllegalArgumentException - Thrown if the caller policy is not permitted to alter the default monitor control policyin immortal memory.
427. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if policy is not a supported monitor control policy.?
428. change
Replaced: ?Sets policy as the base monitor control policy for obj. The base policy becomes the active monitor control policy when obj is in the unlocked state and has an empty wait set. Since the behavior of a monitor is defined by its active policy, these rules guarantee that the behavior is not modified dynamically while the monitor is still locked, even if this method is called by the thread or schedulable object that currently is synchronized on obj. Unless otherwise noted, the term ?monitor control policy for object obj? means obj?s active rather than base policy.?
With: ?Immediately sets policy as the monitor control policy for obj.
A thread or schedulable object that is queued for the lock associated with obj, or is in obj?s wait set, is not rechecked (e.g., for a CeilingViolationException) under policy, either as part of the execution of setMonitorControl or when it is awakened to (re)acquire the lock. The thread or schedulable object invoking setMonitorControl must already hold the lock on obj.?
429. change
Deleted: ?active ?
In
Returns: The current active MonitorControl policy for obj, which will be replaced.
430. change
Deleted: ?java.lang.IllegalArgumentException - Thrown when monitor is null.?
431. change
Inserted: ?java.lang.IllegalArgumentException - Thrown when obj is null or policy is not in immortal memory.?
432. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if policy is not a supported monitor control policy.?
433. change
Inserted: ?java.lang.IllegalMonitorStateException - Thrown if the caller does not hold a lock on obj.?
434. change
Inserted: ?In order for this protocol to have the desired effect in terms of avoiding unbounded priority inversions and preventing deadlock, the implementation must perform the following checks when a thread or schedulable object t attempts to synchronize on a target object governed by a PriorityCeilingEmulation policy with ceiling ceil:
? t?s base priority does not exceed ceil
? t?s ceiling priority (if t is holding any other PriorityCeilingEmulation locks) does not exceed ceil.?
Deleted: ?In order for this protocol to have the desired effect in terms of controlling priority inversions, the active priority of a thread or schedulable object attempting to synchronize on, or already synchronized on, a target object governed by a PriorityCeilingEmulation policy, must not exceed that policy?s ceiling.?
435. change
Replaced: ?setMonitorControl(? With: ?MonitorControl.setMonitorControl(Object, MonitorControl?
Replaced: ?highest active priority ? With: ?maximum ?
Replaced: ?any thread or schedulable object that could synchronize on targetObj.?
With: ?the following values:
? the highest base priority of any thread or schedulable object that could synchronize on targetObj
? the maximum ceiling priority value that any thread or schedulable object could have when it attempts to synchronize on targetObj.?
In
Thus for any object targetObj that will be governed by priority ceiling emulation, the programmer needs to provide (via setMonitorControlMonitorControl.setMonitorControl(Object, MonitorControl)) a PriorityCeilingEmulation policy whose ceiling is at least as high as the highest active priority maximum of any thread or schedulable object that could synchronize on targetObj. the following values:
? the highest base priority of any thread or schedulable object that could synchronize on targetObj
? the maximum ceiling priority value that any thread or schedulable object could have when it attempts to synchronize on targetObj.
436. change
Deleted: ?If a thread or schedulable object t whose active priority is p1 attempts to synchronize on an object governed by a PriorityCeilingEmulation policy with ceiling p2, where p1>p2, then a CeilingViolationException is thrown in t. Further, if a thread or schedulable object t2 is synchronized on an object governed by a PriorityCeilingEmulation policy with ceiling p2, and is also synchronized on an object obj governed by a PriorityInheritance policy, then if some other thread or schedulable object t1 whose active priority p1 exceeds p2 attempts to synchronize on obj, then a CeilingViolationException is thrown in t1 (and thus t2?s active priority remains at the ceiling value p2).?
437. change
Replaced: ?t1 ? With: ?t whose base priority is p1?
Replaced: ?set the priority of a thread or schedulable object t2 to a value p1, while t2 holds a lock? With: ?synchronize ?
Replaced: ?t1? With: ?t?
Replaced: ?(See the rules ? With: ?A CeilingViolationException is likewise thrown ?
Replaced: ?the Semantics ? With: ?t if t is holding a PriorityCeilingEmulation lock?
Replaced: ?Requirements section in this chapter for the list of the three priority-setting methods.)? With: ?has a ceiling priority exceeding p1?
In
? If a thread or schedulable object t1 t whose base priority is p1 attempts to set the priority of a thread or schedulable object t2 to a value p1, while t2 holds a lock
synchronize on an object governed by a PriorityCeilingEmulation policy with ceiling p2, where p1>p2, then a CeilingViolationException is thrown in t1t. (See the rules A CeilingViolationException is likewise thrown in the Semantics t if t is holding a PriorityCeilingEmulation lock and Requirements section in this chapter for the list of the three priority-setting methods.) has a ceiling priority exceeding p2.
438. change
Inserted: ?A consequence of the above rule is that a thread or schedulable object may nest synchronizations on PriorityCeilingEmulation-governed objects as long as the ceiling for the inner lock is not less than the ceiling for the outer lock. The possibility of nested synchronizations on objects governed by a mix of PriorityInheritance and PriorityCeilingEmulation policies requires one other piece of behavior in order to avoid unbounded priority inversions. If a thread or schedulable object holds a PriorityInheritance lock, then any PriorityCeilingEmulation lock that it either holds or attempts to acquire will exhibit priority inheritance characteristics. This rule is captured above in the definition of priority sources (4.d).?
Deleted: ?This invocation sets obj? obj?s base policy, which becomes the active policy when obj is unlocked and has an empty wait set. (See class MonitorControl).?
Deleted: ?Note that when defining the ceiling for a given object obj, the programmer cannot simply use the maximum of the base priorities of all threads and schedulable objects that could lock obj; the active priorities of such threads and schedulable objects — in particular the inheritance of priority from other threads and schedulable objects — needs to be taken into account.?
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 allocated in memory (e.g., immortal memory) that is unexceptionally referenceable from every execution context; most significantly heap and non-heap.?
With: ?The PriorityInheritance instance shall be allocated in ImmortalMemory.?
441. change
Deleted (actually moved down): ?WaitFreeWriteQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management. ?
442. change
Inserted: ?A queue that can be non-blocking for producers.?
In
A queue that can be non-blocking for producers. The WaitFreeWriteQueue class is intended for single-writer multiple-reader communication, although it may also be used (with care) for multiple writers.
443. change
Inserted (actually moved from above): ?WaitFreeWriteQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?
444. change
Inserted: ?and both Runnables are non-null?
445. change
Replaced: ?find a ? With: ?select the nearest common scoped parent?
Replaced: ?area that ? With: ?area, or if there ?
Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?
Replaced: ?queues ? With: ?queue ?
In
The writer and reader parameters, if non-null, are checked to insure that they are compatible with the MemoryArea specified by memory (if non-null.)
If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queues queue will be allocated in immortal memory.
446. change
Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?
447. change
Replaced: ?MemoryScopeException - Thrown if a memory access error occurs.?
With:
?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?
448. change
Replaced: ?read ? With: ?thread ?
449. change
Replaced: ?AIE? With: ?AsynchronouslyInterruptedException?
Inserted: ? during the time between calling this method and returning from it?
In
java.lang.InterruptedException - Thrown if the read thread is interrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.
450. change
Replaced: ?MemoryScopeException - Thrown if a memory access error occurs.?
With: ?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?
451. change
Deleted (actually moved): ?WaitFreeReadQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?
452. change
Inserted: ?A queue that can be non-blocking for consumers.?
In:
A queue that can be non-blocking for consumers. The WaitFreeReadQueue class is intended for single-reader multiple-writer communication, although it may also be used (with care) for multiple readers
453. change
Inserted (actually moved): ?WaitFreeReadQueue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?
454. change
Changed the type of the reader and writer arguments from Thread to Runnable.
455. change
Inserted: ?and both Runnables are non-null,?
456. change
Replaced: ?find a ? With: ?select the nearest common scoped parent?
Replaced: ?area that ? With: ?area, or if there ?
Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?
In
If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queue will be allocated in immortal memory.
457. change
Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?
458. change
Changed the type of the reader and writer arguments from Thread to Runnable
459. change
Inserted: ?and both Runnables are non-null?
460. change
Replaced: ?find a ? With: ?select the nearest common scoped parent?
Replaced: ?area that ? With: ?area, or if there ?
Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?
In
The writer and reader parameters, if non-null, are checked to insure that they are compatible with the MemoryArea specified by memory (if non-null.)
If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queue will be allocated in immortal memory.
461. change
Replaced: ?If ? With: ?Thrown if ?
In
java.lang.IllegalArgumentException - If Thrown if an argument holds an invalid value.
462. change
Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?
463. change
Replaced: ?method ? With: ?thread ?
464. change
Replaced: ?AIE? With: ?AsynchronouslyInterruptedException?
465. change
Inserted: ? during the time between calling this method and returning from it.?
In
java.lang.InterruptedException - Thrown if the method thread is interrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.
466. change
Replaced: ?write ? With: ?thread ?
467. change
Replaced: ?AIE? With: ?AsynchronouslyInterruptedException?
468. change
Inserted: ? during the time between calling this method and returning from it?
In
java.lang.InterruptedException - Thrown if the write thread is interrupted by interrupt() or AIEAsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.
469. change
Inserted: ?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?
470. change
Deleted (actually moved): ?WaitFreeDequeue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?
Inserted (actually moved): ?WaitFreeDequeue is one of the classes allowing NoHeapRealtimeThreads and regular Java threads to synchronize on an object without the risk of a NoHeapRealtimeThread incurring Garbage Collector latency due to priority inversion avoidance management.?
471. change
Changed the type of the writer and reader arguments from Thread to Runnable
472. change
Inserted: ?and both Runnables are non...?
Replaced: ?find a ? With: ?select the nearest common scoped parent?
Replaced: ?area that ? With: ?area, or if there ?
Replaced: ?compatible with reader and writer? With: ?no such scope it will use immortal memory?
In
The writer and reader parameters, if non-null, are checked to insure that they are compatible with the MemoryArea specified by memory (if nonnull.)
If memory is null and both Runnables are non-null, the constructor will find a select the nearest common scoped parent memory area that area, or if there is compatible with reader and writerno such scope it will use immortal memory. If all three parameters are null, the queue will be allocated in immortal memory.
473. change
Inserted: ?InnaccessibleAreaException - Thrown if memory is a scoped memory that is not on the caller?s scope stack.?
474. change
Added ?throws InterruptedException?
475. change
Inserted: ?java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?
476. change
Deleted: ?MemoryScopeException - Thrown if the memory area containing the queues is incompatible with the current context.?
477. change
Added ?throws InterruptedException?
478. change
Replaced: ?MemoryScopeException - If the write causes an access or assignment violation.?
With: ?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?
479. change
Inserted: ?java.lang.InterruptedException - Thrown if the thread is interrupted by interrupt() or AsynchronouslyInterruptedException.fire() during the time between calling this method and returning from it.?
480. change
Inserted: ?Throws:
MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?
481. change
Replaced: ?MemoryScopeException - If the write causes an access or assignment violation.?
With:
?MemoryScopeException - Thrown if a memory access error or illegal assignment error would occur while storing object in the queue.?
482. change
Replace: ?The following terms and abbreviations will be used:
A time object is an instance of AbsoluteTime, RelativeTime, or RationalTime.
A time object is always associated with a clock. By default it is associated with the real-time clock.
The Epoch is the standard base time, conventionally January 1 00:00:00 GMT 1970. It is the point from which the real-time clock measures absolute time.
The time value representation is a compound format composed of 64 bits of millisecond timing, and 32 bits of nanoseconds within a millisecond. The millisecond constituent uses the 64 bits of a Java long while the nanosecond constituent uses the
The normalized (canonical) form for time objects uniquely specifies the values for the millisecond and nanosecond components of a point in time, including the case of 0 milliseconds or 0 nanoseconds, and a negative time value, according to the following three rules:?
With:
?The following terms and abbreviations will be used:
A time object is an instance of AbsoluteTime, RelativeTime, or RationalTime.
A time object is always associated with a clock. By default it is associated with the real-time clock.
The Epoch is the standard base time, conventionally January 1 00:00:00 GMT 1970. It is the point from which the real-time clock measures absolute time.
The time value representation is a compound format composed of 64 bits of millisecond timing, and 32 bits of nanoseconds within a millisecond. The millisecond constituent uses the 64 bits of a Java long while the nanosecond constituent uses the 32 bits of a Java int.
The normalized (canonical) form for time objects uniquely specifies the values for the millisecond and nanosecond components of a point in time, including the case of 0 milliseconds or 0 nanoseconds, and a negative time value, according to the following three rules:?
483. change
Inserted: ?Operations are executed using the appropriate arithmetic precision.?
484. change
Replaced: ?the ? With: ?an ?
In:
b. Normalization is also performed on the result of operations by methods that perform time object addition and subtraction. Operations are executed using the appropriate arithmetic precision. If the final result of the an operation can be represented in normalized form, then the operation must not throw arithmetic exceptions while producing intermediate results.
485. change
Replaced: ? Equality includes clock association? With: ?Equality includes clock association. ?
486. change
Replaced: ? Equality includes clock association? With: ?Equality includes clock association. ?
487. change
Inserted: ?time parameter is null this method will throw IllegalArgumentException. If the?
488. change
Replaced: ?This method ignores the possible discrepancy between the? With: ?The ?
Replaced: ?and ? With: ?is set to be ?
Deleted: ?, retaining the original clock clock association with this?
In:
Change the value represented by this to that of the given time. If the time parameter is null this method will throw IllegalArgumentException. If the type of this and the type of the given time are not the same this method will throw ClassCastException. This method ignores the possible discrepancy between the The clock associated with this and is set to be the clock associated with the time parameter, retaining the original clock association with this.
489. change
Inserted: ?java.lang. IllegalArgumentException - Thrown the parameter time is null.
490. change
Inserted: ?As for target.wait(), there is the possibility of spurious wakeup behavior.
The wait time may be relative or absolute, and it is controlled by the clock associated with it. If the wait time is relative, then the calling thread is blocked waiting on target for the amount of time given by time, and measured by the associated clock. If the wait time is absolute, then the calling thread is blocked waiting on target until the indicated time value is reached by the associated clock.?
491. change
Replaced: ?
java.lang.InterruptedException - Thrown if another thread or AIE.fire() interrupts this thread while it is waiting.
With:
java.lang.InterruptedException - Thrown if this schedulable object is interrupted by RealtimeThread.interrupt() or AsynchronouslyInterruptedException.fire() while it is waiting.?
492. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the wait operation is not supported using the clock associated with time.?
493. change
Deleted: ?The clock association is implicitly made with the real-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 ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
495. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
496. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
The result will have the same clock association as this, and the clock association with dest is ignored. An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
497. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
498. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An IllegalArgumentException is thrown if the time parameter is null. An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
499. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
500. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
501. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
502. change
Replaced: ?computation of ? With: ?the result does not fit in?
Replaced: ?relative time gives an overflow after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if computation of the result does not fit in the relative time gives an overflow after normalizationnormalized format.
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: ?this does not have ?
Replaced: ?concept of date? With: ?real-time clock?
In
An UnsupportedOperationException Illegal- ArgumentException is thrown if the parameter date is null. The clock associated association is implicitly made with this does not have the concept of datereal-time clock.
505. change
Deleted: ?UnsupportedOperationException Thrown if the clock associated with this does not have the concept of date?
506. change
Inserted: ?IllegalArgumentException Thrown if the parameter date is null?
507. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
508. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
509. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
510. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
511. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
512. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
513. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
514. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
515. change
Replaced: ?reprepresentation ? With: ?representation ?
In
The string shall be a decimal reprepresentation representation of the milliseconds and nanosecond values; formatted as follows ?(2251 ms, 750000 ns)?
516. change
Deleted: ?Although logically, and correctly, this may represent time before the epoch, an instance of RelativeTime representing time before the epoch may cause some methods to throw an IllegalArgumentException?
From
A negative interval relative to now represents time in the past. Although logically, and correctly, this may represent time before the epoch, an instance of RelativeTime representing time before the epoch may cause some methods to throw an IllegalArgumentException. For add and subtract negative values behave as they do in arithmetic.
517. change
Inserted: ?Throws:
java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.?
518. change
Inserted: ?Throws:
java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.
519. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
520. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
521. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
522. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
523. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
524. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
525. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
526. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
527. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
528. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
529. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
An ArithmeticException is thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
530. change
Replaced: ?there is an overflow ? With: ?the result does not fit ?
Replaced: ?result after normalization? With: ?normalized format?
In
java.lang.ArithmeticException - Thrown if there is an overflow the result does not fit in the result after normalizationnormalized format.
531. change
Replaced: ?reprepresentation ? With: ?representation ?
In
The string shall be a decimal reprepresentation representation of the milliseconds and nanosecond values; formatted as follows ?(2251 ms, 750000 ns)?
532. change
Deleted: ?If the value of any of the millisecond or nanosecond fields is negative the variable is set to negative value. Although logically this may represent time before the epoch, invalid results may occur if an instance of AbsoluteTime representing time before the epoch is given as a parameter to the a method.?
533. change
Replace: ?The counting time is the time accumulated while active by a Timer whose initial firing time has been specified as a RelativeTime. The counting time is zeroed at the occurrence of any firing or skipping.
NOTE: A PeriodicTimer whose initial firing has been specified as an AbsoluteTime self-reschedules in an absolute manner, even if the interval or period is always specified as a RelativeTime, by adding the interval or period to the time of the last firing or skipping.?
With: ?The counting time is the time accumulated while active by a Timer created or rescheduled using a RelativeTime to specify the initial firing/skipping time. The counting time is zeroed at the beginning of an activation, or when rescheduled, while active, before the initial firing/skipping of an activation.?
534. change
Deleted: ?In this model, start is understood as defining ?now? and start counting, stop is understood as stop counting. start after stop may be understood as start counting again from where stopped, or start from scratch after resetting the count. In both cases a delay is introduced. An RTSJ Timer, when using the counter model, resets the count when it is re-started after being stopped.
? Timer modeled as counter: The timer is viewed as if every clock interrupt increments a count up to the firing count, initially given by either an instance of RelativeTime or computed as the difference between an instance of AbsoluteTime and a semantically specified ?now? (using the same clock).?
535. change
Made a list bullet of: ?An RTSJ Timer, when using the counter model, resets the count when it is re-started after being stopped.?
536. change
Deleted: In this model, start is understood as start comparing, and possibly the first start is understood as defining ?now?. stop is understood as stop comparing. start after stop may be understood as start comparing again. In this case no delay is introduced.
? Timer modeled as comparator: The timer is viewed as if every clock interrupt forces a comparison between an absolute time and a firing time, initially given either as an instance of AbsoluteTime or computed as the sum of an instance of RelativeTime and a semantically specified ?now? (using the same clock).?
537. change
Replaced: ?The first firing or skipping of a PeriodicTimer shall be at the beginning of the first interval, however specified. Subsequently, the PeriodicTimer timer will fire or skip at period times set or measured from the last firing or skipping.?
With: ?The initial firing, or skipping, of a PeriodicTimer occurs in response to the invocation of its start method, in accordance with the start time passed to its constructor. This initial firing, or skipping, may be rescheduled by a call to the reschedule method, in accordance with the time passed to that method.?
538. change
Replaced ?If a timer is made active after the initial firing or skipping is due, the first firing or skipping shall occur immediately.
NOTE: The transition to not-active by a timer with an initial firing time specified as a RelativeTime causes the counting time to reset, effectively preventing a timer with an initial firing time specified as a RelativeTime from firing immediately, unless given a time value of 0.?
With: ?For a PeriodicTimer:
a. Let S be the absolute time at which the initial firing or skipping of a PeriodicTimer is scheduled to occur:
i. If the start, or reschedule, time was given as an absolute time, A, and that time is in the future when the timer is made active, then S equals A. Otherwise, if the absolute time has passed when the timer is made active, then S equals the time at which the timer was made active.
ii. If the start, or reschedule, time was given as a relative time, R, then S equals the time at which the counting time, started when the timer was made active, equals R.
NOTE: The transition to not-active by this timer causes the counting time to reset, effectively preventing this kind of timer from firing immediately, unless given a time value of 0.
b. The firings, or skippings, of a PeriodicTimer are scheduled to occur according to S+nT, for n = 0, 1, 2 ..., where S is as just specified, and T is the interval of the periodic timer.?
539. change
Insert semantic: ?A Timer object will not fire before its due time.?
540. change
Replaced: ?a ? With: ?the system ?
541. change
Replaced: ?clock that advances in sync with the external world? With: ?clock?
In
There is always at least one clock object available: a the system real-time clock that advances in sync with the external worldclock. This is the default Clock.
542. change
Replaced: ?resolution - The new resolution of this. The clock association of the resolution parameter is ignored?
With: ?resolution - The new resolution of this, if the requested value is supported by this clock. If resolution is smaller than the minimum resolution supported by this clock then it throws IllegalArgumentException. If the requested resolution is not available and it is larger than the minimum resolution, then the clock will be set to the closest resolution that the clock supports, via truncation. The value of the resolution parameter is not altered. The clock association of the resolution parameter is ignored.?
543. change
Inserted: ?java.lang.IllegalArgumentException - Thrown if resolution is null, or if the requested resolution is smaller than the minimum resolution supported by this clock.?
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 be interpreted as running continuously, with instructions that take no time.?
546. change
Replaced: ?startTime? With: ?targetTime?
Replaced: ?currentTime? With: ?nextTargetTime?
Replaced: ?and? With: ?[if?
Deleted: ?set ?
Replaced: ?=? With: ?<?
Replaced: ?nextTargetTime? With: ?currentTime?
Replaced: ?go? With: ?set?
Replaced: ?to? With: ?targetTime?
Replaced: ?state? With: ?=?
Replaced: ?{active, enabled, absolute}? With: ?currentTime?
Inserted: ?then go to state {active, enabled, absolute}]?
Replaced: ?startTime? With: ?countingTime?
Replaced: ?currentTime? With: ?0?
Replaced: ?countingTime? With: ?durationTime?
Replaced: ?0? With: ?nextDurationTime?
Deleted: ?and set durationTime = nextDurationTime?
In
start ->
[if last_rescheduled_with_AbsoluteTime
then
[set startTimetargetTime = currentTimenextTargetTime
and[if set targetTime =< nextTargetTimecurrentTime
then goset totargetTime state= {active, enabled, absolute}cur rentTime]
then go to state {active, enabled, absolute}]
else
[set startTimecountingTime = currentTime0
and set countingTimedurationTime = 0nextDurationTime
and set durationTime = nextDurationTime
then go to state {active, enabled, relative}]]
547. change
Replaced: ?startTime? With: ?targetTime?
Replaced: ?currentTime? With: ?nextTargetTime?
Replaced: ?set? With: ?if?
Replaced: ?startTime? With: ?targetTime?
Replaced: ?=? With: ?<?
Replaced: ?and? With: ? then?
Replaced: ?nextTargetTime? With: ?currentTime]?
Deleted: ? else?
Replaced: ? [set startTime = currentTime? With: ?else?
Replaced: ? and ? With: ?[?
In
startDisabled ->
[if last_rescheduled_with_AbsoluteTime
then
[set startTimetargetTime = currentTimenextTargetTime
[setif startTimetargetTime =< currentTime
and then set targetTime = nextTargetTimecurrentTime]
then go to state {active, disabled, absolute}]
else
[set startTime = currentTimeelse
and [set countingTime = 0
and set durationTime = nextDurationTime
then go to state {active, disabled, relative}]]
548. change
Inserted: ?[set targetTime = nextTargetTime?
Replaced: ?set? With: ?if?
Replaced: ?startTime? With: ?targetTime?
Replaced: ?=? With: ?<?
Replaced: ?and? With: ? then?
Replaced: ?nextTargetTime? With: ?currentTime]?
Replaced: ? [set startTime = currentTime? With: ?else?
Replaced: ? and ? With: ?[?
In
start ->
[if last_rescheduled_with_AbsoluteTime
then
[set targetTime = nextTargetTime
[setif startTimetargetTime =< currentTime
and then set targetTime = nextTargetTimecurrentTime]
then go to state {active, enabled, absolute}]
[set startTime = currentTimeelse
and [set countingTime = 0
and set durationTime = nextDurationTime
then go to state {active, enabled, relative}]]
549. change
Replaced: ?startTime? With: ?targetTime?
Replaced: ?currentTime? With: ?nextTargetTime?
Replaced: ?and? With: ?[if?
Deleted: ?set ?
Replaced: ?=? With: ?<?
Replaced: ?nextTargetTime? With: ?currentTime?
Replaced: ?go? With: ?set?
Replaced: ?to? With: ?targetTime?
Replaced: ?state? With: ?=?
Replaced: ?{active, disabled, absolute? With: ?currentTime?
Inserted: ?then go to state {active, disabled, absolute}]?
Replaced: ?startTime? With: ?countingTime?
Replaced: ?currentTime? With: ?0?
Replaced: ?countingTime? With: ?durationTime?
Replaced: ?0? With: ?nextDurationTime?
Deleted: ?and set durationTime = nextDurationTime?
In
startDisabled ->
[if last_rescheduled_with_AbsoluteTime
then
[set startTimetargetTime = currentTimenextTargetTime
and[if set targetTime =< nextTargetTimecurrentTime
then goset totargetTime state= {active, disabled, absolute} crrentTime]
then go to state {active, disabled, absolute}]
else
[set startTimecountingTime = currentTime0
and set countingTimedurationTime = 0nextDurationTime
and set durationTime = nextDurationTime
then go to state {active, disabled, relative}]]
550. change
Inserted: ?via targetTime = (targetTime + period)?
Replaced: ?enabled? With: ?enable?
In
{active, enabled, absolute}
[if currentTime >= targetTime
then
[if PeriodicTimer
then
[if period > 0
then
[fire
and set fired_or_skipped_in_current_activation = TRUE
and self reschedule
via targetTime = (targetTime + period)
and re-enter current state]
else
[fire
and go to state {not-active, disabled, absolute}]]
else
[it is a OneShotTimer so
fire
and go to state {not-active, disabled, absolute}]]]
enabledenable -> no state change, do nothing
disable -> go to state {active, disabled, absolute}
stop -> [go to state {not-active, disabled, absolute}
and return TRUE]
start -> throws IllegalStateException
isRunning -> return TRUE
551. change
Inserted: ?[reset the durationTime to relativeTime arg?
Deleted: ?[reset?
Replaced: ?the? With: ?and?
Replaced: ?durationTime? With: ?set?
Replaced: ?to? With: ?countingTime?
Replaced: ?relativeTime? With: ?=?
Replaced: ?arg? With: ?0?
In
reschedule ->
[if NOT fired_or_skipped_in_current_activation
then
[if using an instance of AbsoluteTime
then
[reset the targetTime to absoluteTime arg
and re-enter current state]
else
[reset the durationTime to relativeTime arg
[reset theand durationTimeset tocountingTime relativeTime= arg0
and go to state {active, enabled, relative}]]
else
[if using an instance of AbsoluteTime
then
[reset the nextTargetTime to absoluteTime arg
and set last_rescheduled_with_AbsoluteTime = TRUE
and no state change]
else
[reset the nextDurationTime to relativeTime arg
and set last_rescheduled_with_AbsoluteTime = FALSE
and no state change]]]
552. change
Replaced: ?and? With: ? via durationTime =?
Replaced: ?re-enter? With: ?(durationTime?
Replaced: ?current? With: ?+?
Replaced: ?state]? With: ?period)?
Replaced: ?enabled? With: ?enable?
In
[if countingTime >= durationTime
then
[if PeriodicTimer
then
[if period > 0
then
[fire
and set fired_or_skipped_in_current_activation = TRUE
and self reschedule
and via durationTime = reenter(
durationTime current+ state]period)
and re-enter current state]
else
[fire
and go to state {not-active, disabled, relative}]]
else
[it is a OneShotTimer so
fire
and go to state {not-active, disabled, relative}]]]
enabledenable -> no state change, do nothing
553. change
Replaced: ?re-enter? With: ?set countingTime?
Replaced: ?current? With: ?=?
Replaced: ?state]]? With: ?0?
Inserted: ?and re-enter current state]]?
In
[if using an instance of AbsoluteTime
then
[reset the targetTime to absoluteTime arg
and go to state {active, enabled, absolute}]
else
[reset the durationTime to relativeTime arg
and re-enterset countingTime current= state]]0
and re-enter current state]]
554. change
Deleted: ? return (startTime + durationTime)?
Deleted: ?getFireTime?
Deleted: ?->?
Replaced: ?startTime? With: ?currentTime?
Inserted: ? - countingTime?
In
[if using an instance of AbsoluteTime
then
[reset the nextTargetTime to absoluteTime arg
and set last_rescheduled_with_AbsoluteTime = TRUE
and no state change]
else
[reset the nextDurationTime to relativeTime arg
and set last_rescheduled_with_AbsoluteTime = FALSE
and no state change]]]
getFireTime -> return (startTime + durationTime)
getFireTime -> return (startTimecurrentTime + durationTime -countingTime)
destroy -> go to state {destroyed}
startDisabled -> throws IllegalStateException
555. change
Replaced: ?and? With: ? via targetTime =?
Replaced: ?re-enter? With: ?(targetTime?
Replaced: ?current? With: ?+?
Replaced: ?state]? With: ?period)?
Inserted: ?and re-enter current state]?
In
[if period > 0
then
[skip
and set fired_or_skipped_in_current_activation = TRUE
and self reschedule
and via targetTime = reenter(
targetTime current+ state]period)
and re-enter current state]
556. change
Replaced: ?disabled? With: ?disable?
In
enable -> go to state {active, enabled, absolute}
disableddisable -> no state change, do nothing
stop -> [go to state {not-active, disabled, absolute}
557. change
Replaced: ?go? With: ?set?
Replaced: ?to? With: ?countingTime?
Replaced: ?state? With: ?=?
Replaced: ?{active, disabled, relative}]]? With: ?0?
Inserted: ?and go to state {active, disabled, relative}]]?
reschedule ->
[if NOT fired_or_skipped_in_current_activation
then
[if using an instance of AbsoluteTime
then
[reset the targetTime to absoluteTime arg
and re-enter current state]
else
[reset the durationTime to relativeTime arg
and goset tocountingTime state= {active, disabled, relative}]]0
and go to state {active, disabled, relative}]]
558. change
Replaced: ?and? With: ? via durationTime =?
Replaced: ?reenter? With: ?(durationTime?
Replaced: ?current? With: ?+?
Replaced: ?state]? With: ?period)?
In
{active, disabled, relative}
[if countingTime >= durationTime
then
[if PeriodicTimer
then
[if period > 0
then
[skip
and set fired_or_skipped_in_current_activation = TRUE
and self reschedule
and via durationTime = reenter(
durationTime current+ state]period)
and re-enter current state]
else
[skip
and go to state {not-active, disabled, relative}]]
else
[it is a OneShotTimer so
skip
and go to state {not-active, disabled, relative}]]]
559. change
Replaced: ?disabled? With: ?disable?
In
enable -> go to state {active, enabled, relative}
disableddisable -> no state change, do nothing
stop -> [go to state {not-active, disabled, relative}
560. change
Inserted: ?[reset the durationTime to relativeTime arg?
Deleted: ?[reset?
Replaced: ?the? With: ?and?
Replaced: ?durationTime? With: ?set?
Replaced: ?to? With: ?countingTime?
Replaced: ?relativeTime? With: ?=?
Replaced: ?arg? With: ?0?
In
reschedule ->
[if NOT fired_or_skipped_in_current_activation
then
[if using an instance of AbsoluteTime
then
[reset the targetTime to absoluteTime arg
and go to state {active, disabled, absolute}]
else
[reset the durationTime to relativeTime arg
[reset theand durationTimeset tocountingTime relativeTime= arg0
and re-enter current state]]
561. change
Inserted: ? getFireTime ->?
Deleted: ?getFireTime?
Deleted: ?->?
Replaced: ?startTime? With: ?currentTime?
Inserted: ? - countingTime?
In
getFireTime ->
getFireTime -> return (startTimecurrentTime + durationTime -
countingTime)
destroy -> go to state {destroyed}
startDisabled -> throws IllegalStateException
562. change
Replaced: ?disabled? With: ?disable?
In
{destroyed}
enable | disableddisable | stop | start | isRunning
| reschedule | getFireTime | destroy
| startDisabled -> throws IllegalStateException
563. change
Inserted: ?. The clock associated with the parameter time is always ignored?
In
clock - The clock on which to base this timer, overriding the clock associated with the parameter time. If null, the system Realtime clock is used. The clock associated with the parameter time is always ignored.
564. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the given clock.?
565. change
added override and Inserted: ?Throws:
java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?
566. change
Added override: ?Should not be called.
Throws:
java.lang.UnsupportedOperationException - Thrown if bindTo is 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 all the associated handlers if any, and release as many of its resources as possible back to the system. Every method invoked on a Timer that has been destroyed will throw IllegalStateException.
569. change
Inserted: ?Throws: java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?
570. change
Replaced: ?not enabled? With: ?already disabled, whether it it is active or not-active?
In
These semantics imply also that firings are not queued. Using the above example, if enable was called at time 43 no firing will occur, since at time 42 this was disabled. If the Timer is not enabledalready disabled, whether it is active or not-active, this method does nothing.
571. change
Replaced: ?not disabled? With: ?already enabled, this method does nothing. If the Timer is not-active?
In
Re-enable this timer after it has been disabled. (See disable()374 .) If the
Timer is not disabledalready enabled, this method does nothing. If the Timer is not-active, this method does nothing
572. change
Replaced ?Returns: An instance of AbsoluteTime object representing the absolute time at which this is expected to fire or to skip. If the timer has been created or re-scheduled (see reschedule(HighResolutionTime) ) using an instance of RelativeTime for its time parameter then it will return the sum of such time and the start time. The clock association of the returned time is the clock on which this timer is based.?
With: ?Returns: The absolute time at which this is expected to fire or to skip, in a newly allocated AbsoluteTime object. If the timer has been created or re-scheduled (see reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will return the sum of the current time and the RelativeTime remaining time before the timer is expected to fire/skip. The clock association of the returned time is the clock on which this timer is based.?
573. change
Inserted: ?java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.?
574. change
Added method:
Get the time at which this Timer is expected to fire. If the Timer is disabled, the returned time is that of the skipping of the firing. If the Timer is
not-active it throws IllegalStateException.
Parameters:
fireTime - The instance of AbsoluteTime which will be updated in place and returned. The clock association of the
fireTime parameter is ignored. When fireTime is null a new object is allocated for the result.
Returns: The instance of AbsoluteTime passed as parameter, with time values representing the absolute time at which this is expected to fire or to skip. If the fireTime parameter is null the result is returned in a newly allocated object. If the timer has been created or re-scheduled (see reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will return the sum of the current time and the RelativeTime remaining time before the timer is expected to fire/skip. The clock association of the returned time is the clock on which this timer is based.
Throws:
java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.
java.lang.IllegalStateException - Thrown if this Timer has been destroyed, or if it is not-active.
575. change
Added override
Inserted ?Throws:
java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?
576. change
Inserted: ?Throws:
java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?
577. change
Added override
Inserted ?Throws:
java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?
578. change
Replaced: ?re-scheduling ? With: ?rescheduling ?
In
The re-scheduling rescheduling will take place between the invocation and the return of the method.
579. change
Deleted: ? NOTE: While the scheduled time is changed as described above, the rescheduling itself is applied only on the first firing (or on the first skipping if disabled) or a timer?s activation. ?
Inserted: ?NOTE: While the scheduled time is changed as described above, the rescheduling itself is applied only on the first firing (or on the first skipping if disabled) of a timer?s activation. If reschedule is invoked after the current activation timer?s firing, then the rescheduled time will be effective only upon the next start or startDisabled command (which may need to be preceded by a stop command).
If reschedule is invoked with a RelativeTime time on an active timer before its first firing/skipping, then the rescheduled firing/skipping time is relative to the time of invocation.?
580. change
Inserted: ?. The clock associated with the parameter time is always ignored?
In
time - The time to reschedule for this event firing. If time is null, the previous time is still the time used for the Timer firing. The clock associated with the parameter time is always ignored.
581. change
Inserted: ?java.lang.IllegalArgumentException - Thrown if time is a negative RelativeTime value.?
582. change
Added override.
Inserted: ?java.lang.IllegalStateException - Thrown if this Timer 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-active and retains the enabled or disabled state it had at expiration timedisabled. If the clock time has already passed the timeout time, it will fire immediately after it is started or after it is rescheduled while active
584. change
Replaced: ?at which ? With: ?used to determine when to fire?
Replaced: ?handler is released? With: ?event?
Replaced: ?null ? With: ?time ?
Replaced: ?time ? With: ?null ?
Replaced: ?relative time ? With: ?RelativeTime ?
Inserted: ?, and in this case case the Timer fires immediately upon a call to start()?
In
time - The time at which used to determine when to fire the handler is releasedevent. A null time value of time null is equivalent to a relative time RelativeTime of 0, and in this case the Timer fires immediately upon a call to start().
585. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the clock associated with time.?
586. change
Replaced: ?at which ? With: ?used to determine when to fire?
Replaced: ?handler is released? With: ?event?
Replaced: ?null ? With: ?time ?
Replaced: ?time ? With: ?null ?
Replaced: ?relative time ? With: ?RelativeTime ?
Inserted: ?, and in this case case the Timer fires immediately upon a call to start()?
In
time - The time at which used to determine when to fire the handler is releasedevent. A null time value of time null is equivalent to a relative time RelativeTime of 0, and in this case the Timer fires immediately upon a call to start().
587. change
Replaced: ?clock - The timer will be based on this clock. If the clock is null, the default Realtime clock is used.?
With: ?clock - The clock on which to base this timer, overriding the clock associated with the parameter time. If null, the system Realtime clock is used. The clock associated with the parameter time is always ignored.?
588. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the given clock.?
589. change
Deleted: ?the system guarantees that?
Replaced: ?interval time units after the last firing? With: ?periodically?
Deleted: ?for?
In:
?If an interval greater than 0 is given, the system guarantees that the timer will fire interval time units after the last firingperiodically. If an interval of 0 is given, the PeriodicTimer will only fire once, unless restarted after expiration, behaving like for a OneShotTimer. In all cases, if the timer is disabled when the firing time is reached, that particular firing is lost (skipped). If enabled at a later time, it will fire at its next scheduled time.?
590. change
Insert a paragraph break after ?immediately after it is started?
In:
If the clock time has already passed the beginning of the first period, the PeriodicTimer will fire immediately after it is started.
If one of the HighResolutionTime argument types is RationalTime (now deprecated)?
591. change
Replaced: ?If ? With: ?A ?
Inserted: ?value of null ?
Replaced: ?null then ? With: ?equivalent to a RelativeTime of 0, and in this case?
Replaced: ?first interval will start ? With: ?Timer fires ?
In
start - The time that specifies when the first interval begins, based on the clock associated with it. If A start value of null is null then equivalent to a RelativeTime of 0, and in this case the first interval will start Timer fires immediately upon a call to start().
592. change
Replaced: ?zero? With: ?zero or null?
Deleted: ?is the one of a OneShotTimer . For a PeriodicTimer the method Timer.getClock() returns the clock to which the interval is associated with, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer?
In
interval - The period of the timer. Its usage is based on the clock associated with it. If interval is zerozero or null, the period is ignored and the firing behavior of the PeriodicTimer is the one of a OneShotTimer . For a PeriodicTimer the method Timer.getClock() returns the clock to which the interval is associated with, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer.
593. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the clock associated with start or the clock associated with interval.?
594. change
Replaced: ?If ? With: ?A ?
Inserted: ?value of null ?
Replaced: ?null then ? With: ?equivalent to a RelativeTime of 0, and in this case?
Replaced: ?first interval will start ? With: ?Timer fires ?
In
start - The time that specifies when the first interval begins, based on the clock associated with it. If A start value of null is null then equivalent to a RelativeTime of 0, and in this case the first interval will start Timer fires immediately upon a call to start().
595. change
Replaced: ?zero? With: ?zero or null?
Replaced: ?the one ? With: ?that ?
In
interval - The period of the timer. Its usage is based on the clock specified by the clock parameter. If interval is zerozero or null, the period is ignored and the firing behavior of the PeriodicTimer is the one that of a OneShotTimer.
596. change
Replaced: ?clock - The clock to be used to time the interval. For a PeriodicTimer the method Timer.getClock() returns the clock used to time the interval, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer.?
With: ?clock - The clock to be used to time the interval. If null, the system Realtime clock is used. The Clock association of the parameter interval is always ignored.?
597. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if the timer functionality cannot be supported using the clock associated with start or the given clock.?
598. change
Replaced: ?Create a ReleaseParameters object with the next fire time as the start time and the interval of this as the period.?
With: ?Create a release parameters object with new objects containing copies of the values corresponding to this timer. When the PeriodicTimer interval is greater than 0, create a PeriodicParameters object with a start time and period that correspond to the next firing (or skipping) time, and interval, of this timer. When the interval is 0, create an AperiodicParameters object, since in this case the timer behaves like a OneShotTimer.
If this timer is active, then the start time is the next firing (or skipping) time returned as an AbsoluteTime. Otherwise, the start time is the initial firing (or skipping) time, as set by the last call to reschedule, or if there was no such call, by the constructor of this timer.?
599. change
Replaced: ?Returns: A new instance of ReleaseParameters with a value corresponding to the release characteristics of this timer.?
With ?Returns: A new release parameters object with new objects containing copies of the values corresponding to this timer. If the interval is greater than zero, return a new instance of PeriodicParameters. If the interval is zero return a new instance of AperiodicParameters.?
600. change
Inserted override of getClock
Inserted: ?Returns the instance of Clock that the PeriodicTimer interval is associated with at the time of the call, even when the time value of interval is zero and the PeriodicTimer firing behavior is that of a OneShotTimer.
Returns: The instance of Clock that the interval is associated with at the time of the call.
Throws:
java.lang.IllegalStateException - Thrown if this Timer has been destroyed.?
601. change
Replaced: ?Gets the absolute time this will next fire.?
With: ?Get the time at which this PeriodicTimer is next expected to fire or to skip. If the PeriodicTimer is disabled, the returned time is that of the skipping of the firing. If the PeriodicTimer is not-active it throws IllegalStateException.?
602. change
Replaced: ?Returns: A new AbsoluteTime instance with the value at which this is expected to fire.?
With: ?Returns: The absolute time at which this is next expected to fire or to skip, in a newly allocated AbsoluteTime object. If the timer has been created or re-scheduled (see Timer.reschedule(HighResolutionTime)) using an instance of RelativeTime for its time parameter then it will return the sum of the current time and the RelativeTime remaining time before the timer is expected to fire/skip. Within a periodic timer activation, the returned time is associated with the start clock before the first fire (or skip) time, and associated with the interval clock otherwise.?
603. change
Inserted: ?java.lang.ArithmeticException - Thrown if the result does not fit in the normalized format.?
604. change
Replaced: ?in a not-active state? With: ?not-active?
In
java.lang.IllegalStateException - Thrown if this PeriodicTimer has been destroyed, or if it is in a not-active statenot-active.
605. change
Replaced: ?A new? With: ?The?
In
A newThe RelativeTime instance with the value of this timer?s interval.
606. change
Replaced: ?The semantics of the update are the same? With: ?A null interval is interpreted ?
Replaced: ?for updating the period of a real-time thread? With: ?RelativeTime?
Replaced: ?See the semantics of the priority scheduler? With: ?0,0.?
In
interval - A RelativeTime object which is the interval used to reset this Timer. The semantics of the update are the same A null interval is interpreted as for updating the period of a real-time thread. RelativeTime(See the semantics of the priority scheduler.0,0).
607. change
Inserted: ?The interval does not affect the first firing (or skipping) of a timer?s activation. At each firing (or skipping), the next fire (or skip) time of an active periodic timer is established based on the interval currently in use. Resetting the interval of an active periodic timer only effects future fire (or skip) times after the next.?
608. change
Inserted: ?active ?
In
2. The release of attached handlers occurs in execution eligibility order (priority order with the default PriorityScheduler) and at the active priority of the schedulable object that invoked the fire method.
609. change
Deleted: ?If an AI-method is attempting to acquire an object lock when an associated AIE is generated, the attempt to acquire the lock is abandoned immediately?
And Inserted as a new semantic: ?If an AI-method is attempting to acquire an object lock when an associated AIE is generated, the attempt to acquire the lock is abandoned.?
610. change
Replaced: ?schedule? With: ?system?
In
Since this affects the constraints expressed in the release parameters of an existing schedulable object, this may change the feasibility of the current schedulesystem.
611. change
Replaced: ?schedule? With: ?system?
In
Since this affects the constraints expressed in the release parameters of an existing schedulable object, this may change the feasibility of the current schedulesystem.
612. change
Replaced: ?schedule? With: ?system?
In
Since this affects the constraints expressed in the release parameters of the existing schedulable objects, this may change the feasibility of the current schedulesystem.
613. change
Deleted: ?default ?
Deleted: ?default ?
In
The default scheduler for an asynchronous event handler is inherited from the thread/schedulable object that created it. If it was created from a Java thread, the default scheduler is the current default scheduler.
614. change
Replaced: ?BAEH?s ? With: ?BAEH?s ?
In
release - A ReleaseParameters object which will be associated with the constructed instance. If null, this will have default ReleaseParameters for the BAEH?s BAEH?s scheduler.
Replaced: ?BAEH?s ? With: ?BAEH?s ?
In
logic - The java.lang.Runnable object whose run() method is executed by AsyncEventHandler.handleAsyncEvent(). If null, the logic will default to the BAEH?s BAEH?s run method.
615. change
Replaced: ?current exception is this ? With: ?currently executing schedulable object, ?
Inserted: ?if so, ?
Replaced: ?the exception ? With: ?it ?
Replaced: ?pending if it is current? With: ?pending?
In
Atomically see if this is pending on the current exception is this currently executing schedulable object, and if so, make the exception it nonpending if it is currentpending.
616. change
Replaced: ?the current exception? With: ?pending?
Replaced: ?the current exception? With: ?pending?
In
Returns: True if this was the current exceptionpending. False if this was not the current exceptionpending.
617. change
Inserted: ?The run method of given Interruptible is always entered with the exception in the enabled state, but that state can be modified with enable() and disable() and the state can be observed with isEnabled().?
618. change
Inserted: ?This method is valid only when the caller has a call to doInterruptible() in progress. If invoked when no call to doInterruptible() is in progress, enable returns false and does nothing.?
619. change
Replaced: ?with ? With: ?in the context of ?
Replaced: ?) in progress? With: ?)?
In
Returns: True if this is enabled and the method call was invoked with in the context of the associated doInterruptible() in progress). False otherwise.
620. change
Replaced: ?AsyncEvent? With: ?AsyncEventHandler?
In
Use instances of AsyncEvent398AsyncEventHandler402 to handle POSIX signals.
621. change
Deleted: ?AsyncEvent of the ?
In
Add the given AsyncEventHandler to the list of handlers of the AsyncEvent of the given signal.
622. change
Replaced: ?class? With: ?class or if handler is null?
In
java.lang.IllegalArgumentException - Thrown if signal is not known by this classclass or if handler is null.
Replaced: ?IllegalArgumentException ? With: ?UnsupportedOperationException ?
Deleted: ?not ?
Replaced: ?by ? With: ?to ?
Inserted: ?, but not supported on this implementation?
In
java.lang.IllegalArgumentException UnsupportedOperationException - Thrown if signal is not known by to this class, but not supported on this implementation.
623. change
Deleted: ?of the AsyncEvent?
In
Remove the given AsyncEventHandler402 from the list of handlers of the AsyncEvent of the given signal.
624. change
Replaced: ?class? With: ?class or if handler is null?
In
java.lang.IllegalArgumentException - Thrown if signal is not known by this classclass or if handler is null.
625. change
Deleted: ?AsyncEvent of the ?
In
Set the given AsyncEventHandler as the handler of the AsyncEvent of the given signal.
626. change
Inserted: ?java.lang.UnsupportedOperationException - Thrown if signal is known to this class, but not supported on this implementation.?
627. change
Replaced: ?effect? With: ?effect other than on the value returned by getMaximumConcurrentLocks()?
In
numLocks - An integer whose value becomes the number of locks that can be in simultaneous use without incurring an execution time increase. If number is less than or equal to zero nothing happens. If the system does not use this hint this method has no effecteffect other than on the value returned by
getMaximumConcurrentLocks().
628. change
Replaced: ?effect? With: ?effect other than on the value returned by getMaximumConcurrentLocks()?
In
If the system does not use this hint this method has no effecteffect other than on the value returned by getMaximumConcurrentLocks().
629. change
Replaced: ?a this? With: ?an instance of this class?
In
If an arrival time occurs and should be queued but the queue already holds a number of times equal to the initial queue length defined by this then the fire() method shall throw a thisan instance of this class.
630. change
Replaced: ?active ? With: ?base ?
In
This exception is thrown when a schedulable object or java.lang.Thread attempts to lock an object governed by an instance of PriorityCeilingEmulation and the thread or SO?s active base priority exceeds the policy?s ceiling.
631. change
Replaced: ?active? With: ?base?
In
Gets the active base priority of the SO or thread whose attempt to synchronize resulted in the throwing of this.
Replaced: ?active? With: ?base?
In
Returns: The synchronizing thread?s active base priority.
632. change
Inserted: base
In
Gets the ceiling of the PriorityCeilingEmulation policy which was exceeded by the base priority of an SO or thread that attempted to synchronize on an object governed by the policy, which resulted in throwing of this.