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 f