Asynchronous Transfer of Control - Revision history

Suhridk: /* Requirements for ATC */

2012-01-11T14:12:10Z

Requirements for ATC

Suhridk: /* Nested ATC */

2012-01-11T13:43:56Z

Nested ATC

Suhridk: /* Interruptible */

2012-01-11T12:39:02Z

Interruptible

Suhridk: /* Catching an AIE */

2012-01-11T11:58:59Z

Catching an AIE

Suhridk: /* AIE Semantics */

2012-01-11T11:37:22Z

AIE Semantics

Suhridk: /* AIE Semantics */

2012-01-11T11:31:29Z

AIE Semantics

Suhridk at 02:11, 3 January 2012

2012-01-03T02:11:27Z

Suhridk: /* Timed Class */

2012-01-02T21:29:50Z

Timed Class

Suhridk: /* Interruptible */

2012-01-02T21:28:40Z

Interruptible

Suhridk: /* Nested ATC */

2012-01-02T20:51:08Z

Nested ATC

@@ Line 14: / Line 14: @@
 * Error recovery: To support coordinated error recovery between real-time threads.
 ** Where several threads are performing a computation, an error detected by one thread needs to be quickly and safely communicated to other threads.
-* Mode changes: Where changes between modes are expected but cannot be planned.
+* Mode changes:
 ** A fault may lead to aircraft abandoning take off and entering emergency mode.
 ** An accident in a manufacturing plant may required mode change to shutdown the plant.
 ** Threads must be quickly and safely informed that the mode in which they are operating has changed and they now need to perform different sets of actions.
 * Scheduling using partial/imprecise computations: Many algos whose accuracy depends on how much time has been allocated to their calculation, when times up thread must be interrupted to stop refinement of result.
 * User Interrupts - Users may want to cancel current operation because they have detected an error condition and want to start again.
 == How to solve ==

@@ Line 337: / Line 337: @@
 * Now assume aie2 is fired while method1() is in progress.
 * After a short while aie3 is fired. Now aie-3 becomes the current aie because it is at a higher level of nesting. '''aie2's fire event is discarded.'''
-* When method1() completes, aie2's interruptaction is called, since aie3 is not aie2, aie3 is held pending till it reaches interruptaction of aie3.
+* When ATC def method (method1()) completes, the currently pending AIE is thrown to which is caught by the innermost nested AIE first ie. aie2's interruptaction is called. Since clear is not called, aie3 is propagated till it reaches interruptaction of aie3.
 <syntaxhighlight lang="java5">
 public class NestedATC {
-	private AsynchronouslyInterruptedException aie1 = new AsynchronouslyInterruptedException();
+	private MyAIE2 aie2 = new MyAIE2();
-	private AsynchronouslyInterruptedException aie2 = new AsynchronouslyInterruptedException();
+	private MyAIE3 aie3 = new MyAIE3();
 	public static void main(String[] args) throws InterruptedException {
@@ Line 371: / Line 376: @@
 				public void interruptAction(AsynchronouslyInterruptedException exception) {
-					System.out.println("AIE2 Interrupt Action ");
+					System.out.println("AIE2 Interrupt Action received exception : " + exception);
+				}
 			});
@@ Line 385: / Line 390: @@
 						public void interruptAction(AsynchronouslyInterruptedException exception) {
-							System.out.println("AIE3 Interrupt Action");
+							System.out.println("AIE3 Interrupt Action received exception : " + exception);
+						}
 					});
@@ Line 409: / Line 414: @@
+}
 </syntaxhighlight>

@@ Line 320: / Line 320: @@
 * The interruptible interface has two methods:
 ** public void run(AIE) throws AIE. This is the method that is interruptible.
-** public void interruptAction(AIE). This is the method that is called by the RTJVM when the run() method is interrupted.
+** public void interruptAction(AIE). This is the method that is called by the RTJVM when the run() method is interrupted. Note, the interruptAction() will be called when any AIE is thrown at the SO executing the code.
 * Any interruptible object can be passed as a parameter to the doInterruptible() method in the AIE class.
 * The doInterruptible() method then calls the run() method of the object, passing the associated AIE as a parameter.
 * If a SO is executing a method this way, it can then be interrupted by calling the fire() method of the AIE. (As opposed to calling RT.interrupt() which only fires the generic AIE).
-* Note that only one doInterruptible method for a particular AsynchronouslyInterruptedException can be active at one time. If a call is outstanding, the doInterruptible() method returns immediately with a false value.
+* Note that only one doInterruptible method for a '''particular''' AsynchronouslyInterruptedException object can be active at one time. If a call is outstanding, the doInterruptible() method returns immediately with a false value. Otherwise doI() returns with true once the run method completes.
 * AIE can be further controlled using the enable(), disable() methods.
 * Firing the AIE has no effect, if there is no active doInterruptible() for that AIE.

@@ Line 243: / Line 243: @@
 * If the AIE is the current AIE, the AIE is no longer pending; true is returned.
 * If the AIE is not the current AIE, the AIE is still pending; false is returned.
 = Interruptible =

@@ Line 112: / Line 112: @@
 * If t is executing in an ATC deferred region and is blocked inside a call to wait(), sleep(), join() t is rescheduled and '''is thrown as a synchronous exception and also marked as pending.'''
-* Example for last case:
+* Example for third case.
 <syntaxhighlight lang="java5">
@@ Line 149: / Line 149: @@
+	}
 	private void launchSleep() throws AsynchronouslyInterruptedException {
 		longRunningSleep();
-                 System.out.println("Finished launchSleep()"); //This wont print as method aborts when AIE is delivered.
+                 System.out.println("Finished launchSleep()"); //This wont print as method aborts when AIE propagates...
+	}
-         //AI method is blocked during a call to sleep, so AIE is delivered as a synchronous exception and propagated to calling method
+         //AI method is blocked during a call to sleep, so t is recheduled immediately and AIE is delivered.
 	private void longRunningSleep() throws AsynchronouslyInterruptedException {
 		try {

@@ Line 149: / Line 149: @@
+	}
-		//AIE will be delivered here.
+	//AIE will be delivered here
 	private void launchSleep() throws AsynchronouslyInterruptedException {
 		longRunningSleep();
-                 System.out.println("Finished launchSleep()"); //This wont print as method aborts.
+                 System.out.println("Finished launchSleep()"); //This wont print as method aborts when AIE is delivered.
+	}
 	private void longRunningSleep() throws AsynchronouslyInterruptedException {
 		try {
 			Thread.sleep(10000);
 		} catch (InterruptedException ie) {
-			System.out.println("Interrupted from sleep"); //Wont print
+			System.out.println("Interrupted from sleep"); //Wont print since IE catch clauses are not executed in AI method.
+		}
+	}

@@ Line 347: / Line 347: @@
 * Timer can be reset for the next call of doInterruptible() by using resetTime() method.
 * Consider the following example:
 [[Category:RealtimeJava]]

← Older revision		Revision as of 20:51, 2 January 2012
Line 339:		Line 339:

	</syntaxhighlight>		</syntaxhighlight>
		+
		+	= Timed Class =
		+
		+	* There is a subclass of ASE called Timed. A time value is passed to it when being created.
		+	* Now when doInterruptible() of Timed class is called, the timer is started.
		+	* Timer can be reset for the next call of doInterruptible() by using resetTime() method.
		+	* Consider the following example:
		+

	[[Category:RealtimeJava]]		[[Category:RealtimeJava]]