Merge pull request #3 from anatoliykmetyuk/develop

SubScript Actors basic implementation

Author: AndreVanDelft

buildcharacter.properties

@@ -1,24 +1,23 @@
 #Ant properties
-#Mon Jan 06 13:51:32 CET 2014
+#Mon Mar 24 23:35:54 EET 2014
 ant.java.version=1.6
-ant.version=Apache Ant(TM) version 1.8.2 compiled on June 20 2012
-git.commit.date=20140106-103905
-git.commit.sha=b97a422ca6
+ant.version=Apache Ant(TM) version 1.9.3 compiled on January 19 2014
+git.commit.date=20140324-233102
+git.commit.sha=0b9208b7f4
 java.class.version=50.0
 java.runtime.name=Java(TM) SE Runtime Environment
-java.runtime.version=1.6.0_51-b11-457-11M4509
+java.runtime.version=1.6.0_45-b06
 java.specification.version=1.6
-java.version=1.6.0_51
-java.vm.name=Java HotSpot(TM) 64-Bit Server VM
+java.version=1.6.0_45
+java.vm.name=Java HotSpot(TM) Server VM
 java.vm.specification.version=1.0
-java.vm.version=20.51-b01-457
+java.vm.version=20.45-b01
 jline.version=2.11
 junit.version=4.10
 maven.version.number=2.11.0-SNAPSHOT
 maven.version.suffix=-SNAPSHOT
-mrj.version=1070.1.6.0_51-457
-os.version=10.8.5
-osgi.version.number=2.11.0.v20140106-103905-b97a422ca6
+os.version=3.13.6-1-ARCH
+osgi.version.number=2.11.0.v20140324-233102-0b9208b7f4
 osgi.version.suffix=
 partest.version.number=1.0.0-RC8
 partest.versions=1.3.0\:2.11.0-M7\:1.8.4\:1.0.0-RC8\:1.0
@@ -39,19 +38,19 @@ scalac.args.locker=-feature
 scalac.args.optimise=
 scalac.args.quick=-feature  
 scalac.args.strap=-feature  
-scalacfork.jvmargs=-Xms512M -Xmx1536M -Xss1M -XX\:MaxPermSize\=128M 
+scalacfork.jvmargs=-Xms1536M -Xmx1536M -Xss1M -XX\:MaxPermSize\=192M -XX\:+UseParallelGC 
 scalacheck.version.number=1.11.1
 scalacheck.versions=1.11.1\:1.0.0-RC5\:2.11.0-M7\:1.0
 starr.version=2.11.0-M7
-time.DSTAMP=20140106
-time.TODAY=January 6 2014
-time.TSTAMP=1351
-time.human=6 January 2014, 13\:51\:32
-time.short=20140106135132
+time.DSTAMP=20140324
+time.TODAY=March 24 2014
+time.TSTAMP=2335
+time.human=24 March 2014, 23\:35\:54
+time.short=20140324233554
 user.timezone=
 version.bnum=0
 version.major=2
 version.minor=11
-version.number=2.11.0-20140106-103905-b97a422ca6
+version.number=2.11.0-20140324-233102-0b9208b7f4
 version.patch=0
 version.suffix=

lib/extra/akka-actor_2.10-2.3-SNAPSHOT.jar

@@ -0,0 +1,128 @@
+package subscript.akka
+
+import subscript.DSL._scriptType
+import scala.collection.mutable.ListBuffer
+import subscript.vm._
+import akka.actor._
+
+trait SubScriptActor extends Actor {
+
+  private object Terminator {
+    def block = synchronized(wait())
+    def release = synchronized(notify())
+  }
+  
+  private val callHandlers = ListBuffer[PartialFunction[Any, Unit]]()
+
+  
+  
+  // Scripts
+  def _live(): N_call => Unit
+  private def script terminate = {*Terminator.block*}
+  private def script die       = {if (context ne null) context stop self}
+  
+  
+  
+  // Callbacks
+  override def aroundPreStart() {
+    def script lifecycle = (live || terminate) ; die
+    SubScriptActor.executeScript(_lifecycle())
+    super.aroundPreStart()
+  } 
+  
+  override def aroundReceive(receive: Actor.Receive, msg: Any) {    
+    synchronized {
+      sendSynchronizationMessage(this)
+      wait()
+    }
+    
+    var messageWasHandled = false
+    callHandlers.synchronized {
+      for (h <- callHandlers if h isDefinedAt msg) {
+        h(msg)
+        messageWasHandled = true
+      }
+    }
+    
+    // If a message was handled, Akka will try to match it against a function that can handle any message
+    // otherwise it will try to match the message against function that can handle virtually nothing
+    // (except LocalObject, which is certainly local and can't be available from the outside)
+    case object LocalObject
+    super.aroundReceive(if (messageWasHandled) {case _: Any =>} else {case LocalObject =>}, msg)
+  }
+  
+  override def aroundPostStop() {
+    Terminator.release
+    super.aroundPostStop()
+  }
+  
+  final def receive: Actor.Receive = {case _ =>}
+ 
+  
+  
+  // SubScript actor convenience methods
+  def initActor(node: N_code_eventhandling, _handler: PartialFunction[Any, Unit]) {
+    node.codeExecutor = EventHandlingCodeFragmentExecutor(node, node.scriptExecutor)
+    val handler = _handler andThen {_ => node.codeExecutor.executeAA}
+    synchronized {callHandlers += handler}
+    node.onDeactivate {
+      synchronized {callHandlers -= handler}
+    }
+  }
+    
+  def sendSynchronizationMessage(lock: AnyRef) {
+    val vm = SubScriptActor.vm
+    vm insert SynchronizationMessage(vm.rootNode, lock)    
+  }
+
+}
+
+
+object SubScriptActor {
+  
+  private lazy val vm: CommonScriptExecutor = {
+    val _vm = ScriptExecutorFactory.createScriptExecutor(true);
+    
+    _parallelScript()(_vm.anchorNode)
+    _vm addHandler synchMsgHandler
+    
+    new Thread {override def run = {_vm.run}}.start()
+    while (parallelOp == null) wait()
+    
+    _vm
+  }
+  private var parallelOp: CallGraphParentNodeTrait = null
+  
+  private object Stopper {
+    def block   = synchronized(wait())
+    def release = synchronized(notify())
+  }
+  private def script parallelScript = {*Stopper.block*} & {captureParallelOp(here)}
+  private def captureParallelOp(here: CallGraphTreeNode) = synchronized {
+    parallelOp = here.parent.asInstanceOf[CallGraphParentNodeTrait]
+    notify()
+  }
+  
+  val synchMsgHandler: PartialFunction[CallGraphMessage[_ <: CallGraphNodeTrait], Unit] = {
+    case SynchronizationMessage(_, lock) => lock.synchronized(lock.notify())
+  }
+    
+  def executeScript(script: _scriptType) = synchronized {
+    val template = extractTemplate(script)
+    vm.invokeFromET { vm.activateFrom(parallelOp, template) }
+  }
+  
+  
+  def extractTemplate(script: _scriptType) = {
+    val extractor = N_call(T_call(null))
+    script(extractor)
+    extractor.t_callee
+  }
+  
+  def releaseVm() = Stopper.release
+  
+}
+
+case class SynchronizationMessage(node: CallGraphNodeTrait, lock: AnyRef) extends CallGraphMessage[CallGraphNodeTrait] {
+  priority = -1
+}

lib/extra/config-1.2.0.jar

@@ -539,13 +539,14 @@ class GraphicalDebuggerApp extends SimpleSubscriptApplication with ScriptDebugge
   def sleep(duration_ms: Long) = try {Thread.sleep(duration_ms)} catch {case e: InterruptedException => println("sleep interrupted")}
   def confirmExit: Boolean = Dialog.showConfirmation(exitButton, "Are you sure?", "About to exit")==Dialog.Result.Yes
 
+  object MessageStatusLock
+  def messageBeingHandled(value: Boolean): Unit = MessageStatusLock.synchronized {
+    messageBeingHandled = value
+    MessageStatusLock.notify()
+  }
 
-  def awaitMessageBeingHandled(value: Boolean) = {
-    var sleeptime = 1
-    while (messageBeingHandled!=value) {
-      sleep(sleeptime)
-      if (sleeptime<100) sleeptime *=2
-    }
+  def awaitMessageBeingHandled(value: Boolean) = MessageStatusLock.synchronized {
+    while (messageBeingHandled != value) MessageStatusLock.wait()
   }
 
   def shouldStep: Boolean =
@@ -618,7 +619,7 @@ class GraphicalDebuggerApp extends SimpleSubscriptApplication with ScriptDebugge
      live       = {*awaitMessageBeingHandled(true)*}
                   if (shouldStep) ( @{gui(there)}: {!updateDisplay!} stepCommand 
                                  || if(autoCheckBox.selected) {*waitForStepTimeout*} else (-) )
-                  {messageBeingHandled=false}
+                  {messageBeingHandled(false)}
                   ... // TBD: parsing goes wrong without this comment; lineStartOffset was incremented unexpectedly
                || exitDebugger
 
@@ -647,7 +648,7 @@ class GraphicalDebuggerApp extends SimpleSubscriptApplication with ScriptDebugge
 
   def messageHandled(m: CallGraphMessage[_ <: subscript.vm.CallGraphNodeTrait]): Unit = {
     currentMessage = m
-    messageBeingHandled=true 
+    messageBeingHandled(true) 
     awaitMessageBeingHandled(false)
     currentMessage = null
   }

src/subscript/subscript/akka/SubScriptActor.scala

@@ -104,3 +104,5 @@ import scala.collection.mutable._
 	// i.e. 
 	// ->..?p:Int? loops and matches all sent integers like <-*1  <-*3
 
+	case class InvokeFromET(node: CallGraphNodeTrait, payload: () => Unit) extends CallGraphMessage[CallGraphNodeTrait]
+	

src/subscript/subscript/swing/GraphicalDebugger.scala

@@ -66,7 +66,7 @@ trait CallGraphNodeTrait {
   def isExecuting  = false
   var numberOfBusyActions = 0
   def isActionBusy = numberOfBusyActions>0
-
+  
   var index = -1
   var stamp = 0
   var aaStartedCount = 0
@@ -226,6 +226,9 @@ abstract class CallGraphTreeNode_n_ary extends CallGraphTreeParentNode {
   var lastActivatedChild: CallGraphNodeTrait = null
   var aaStartedSinceLastOptionalBreak = false
   def mustBreak = hadBreak = true
+  
+  var breakWaker: CallGraphNodeTrait = null
+  
 }
 
 // The case classes for the bottom node types

src/subscript/subscript/vm/CallGraphMessage.scala

@@ -26,6 +26,7 @@
 
 package subscript.vm
 import scala.collection.mutable._
+import scala.collection.mutable.ListBuffer
 
 /*
  * Factory for script executors. Produces a CommonScriptExecutor
@@ -148,6 +149,7 @@ trait ScriptExecutor {
 
 class CommonScriptExecutor extends ScriptExecutor {
 
+  var waitsForMessage = false
 
   // send out a success when in an And-like context
   def doNeutral(n: CallGraphNodeTrait) =
@@ -165,7 +167,14 @@ class CommonScriptExecutor extends ScriptExecutor {
     childNode.parent = parentNode
     childNode.scriptExecutor = parentNode.scriptExecutor
     parentNode.children.append(childNode)
-    parentNode match {case p: CallGraphTreeNode_n_ary => p.lastActivatedChild = childNode case _ =>}
+    
+    parentNode match {
+      case p: CallGraphTreeNode_n_ary =>
+        childNode match {case N_break(_) | N_optional_break(_) | N_optional_break_loop(_) => p.breakWaker = p.lastActivatedChild case _ =>}
+        p.lastActivatedChild = childNode
+      
+      case _ =>
+    }
   }
   // disconnect a child node from its parent
   def disconnect(childNode: CallGraphNodeTrait) {
@@ -192,6 +201,9 @@ class CommonScriptExecutor extends ScriptExecutor {
       case maa@AAToBeReexecuted(n: CallGraphNodeTrait) => n.asInstanceOf[N_atomic_action].msgAAToBeExecuted = maa
       case _ =>
     }
+    
+    // Notify this
+    synchronized { notify() }
   }
   // remove a message from the queue
   def remove(m: CallGraphMessage[_ <: CallGraphNodeTrait]) = {
@@ -665,8 +677,12 @@ class CommonScriptExecutor extends ScriptExecutor {
 		    if (nodesToBeSuspended!=null) nodesToBeSuspended.foreach((n) => insert(Suspend(n)))
        case _ =>	    
 	  }
-      // message.child may be null now
-      message.node.forEachParent(p => insert(AAStarted(p, message.node)))
+    
+    val operator = message.node.n_ary_op_ancestor
+    if (operator != null && (operator.breakWaker eq message.node)) operator.aaStartedSinceLastOptionalBreak = true
+    
+    // message.child may be null now
+    message.node.forEachParent(p => insert(AAStarted(p, message.node)))
   }
   /*
    * Handle an AAEnded message
@@ -892,7 +908,7 @@ class CommonScriptExecutor extends ScriptExecutor {
       case _          => if (message.activation!=null || message.aaStarteds!=Nil || message.success!=null || message.deactivations != Nil) {
                            val b  = message.break
                            val as = message.aaStarteds
-                           n.aaStartedSinceLastOptionalBreak = n.aaStartedSinceLastOptionalBreak || as!=Nil
+                           // n.aaStartedSinceLastOptionalBreak = n.aaStartedSinceLastOptionalBreak || as!=Nil
                            if (b==null||b.activationMode==ActivationMode.Optional) {
                              if (n.activationMode==ActivationMode.Optional) {
                                  activateNextOrEnded = n.aaStartedSinceLastOptionalBreak
@@ -1001,12 +1017,12 @@ class CommonScriptExecutor extends ScriptExecutor {
     if (activateNext) {
       val t = message.node.template.children(nextActivationTemplateIndex)
       activateFrom(message.node, t, Some(nextActivationPass))
-      if (message.activation!=null) {
-        val nary_op_isLeftMerge = n match {
-          case nary@N_n_ary_op (t: T_n_ary, isLeftMerge) => isLeftMerge case _ => false
-        }
-        if (!nary_op_isLeftMerge) insertContinuation(message.activation, n)
+      val activation = if (message.activation != null) message.activation else Activation(message.node)
+      
+      val nary_op_isLeftMerge = n match {
+        case nary@N_n_ary_op (t: T_n_ary, isLeftMerge) => isLeftMerge case _ => false
       }
+      if (!nary_op_isLeftMerge) insertContinuation(activation, n)
     }
     else if (n.children.isEmpty) {
       insertDeactivation(n, null)
@@ -1015,12 +1031,11 @@ class CommonScriptExecutor extends ScriptExecutor {
     // decide on deactivation of n
 
   }
-
-  /*
-   * message dispatcher; not really OO, but all real activity should be at the executors; other things should be passive
-   */
-  def handle(message: CallGraphMessage[_ <: subscript.vm.CallGraphNodeTrait]):Unit = {
-    message match {
+  
+  
+  type MessageHandler = PartialFunction[CallGraphMessage[_ <: CallGraphNodeTrait], Unit]
+  
+  val defaultHandler: MessageHandler = {
       case a@ Activation        (_) => handleActivation   (a)
       case a@Continuation       (_) => handleContinuation (a)
       case a@Continuation1      (_) => handleContinuation1(a)
@@ -1040,8 +1055,23 @@ class CommonScriptExecutor extends ScriptExecutor {
       case a@AAToBeExecuted     (_) => handleAAToBeExecuted     (a)
       case CommunicationMatchingMessage => handleCommunicationMatchingMessage
     }
+  val communicationHandler: MessageHandler = {
+    case InvokeFromET(_, payload) => payload()
   }
 
+  private val messageHandlers = ListBuffer[MessageHandler](defaultHandler, communicationHandler)
+  def addHandler(h: MessageHandler)    = messageHandlers.synchronized { messageHandlers += h }
+  def removeHandler(h: MessageHandler) = messageHandlers.synchronized { messageHandlers -= h }
+  
+  def invokeFromET(f: => Unit) = insert(InvokeFromET(rootNode, () => f))
+  
+  /*
+   * message dispatcher; not really OO, but all real activity should be at the executors; other things should be passive
+   */
+  def handle(message: CallGraphMessage[_ <: subscript.vm.CallGraphNodeTrait]):Unit =
+    for (h <- messageHandlers if h isDefinedAt message) h(message)
+  
+  
   /*
    * Main method of BasicExecutioner
    * Handle all messages until there is nothing more to do:
@@ -1069,10 +1099,10 @@ class CommonScriptExecutor extends ScriptExecutor {
     else if (!rootNode.children.isEmpty) {
       messageAwaiting
       synchronized { // TBD: there should also be a synchronized call in the CodeExecutors
+        waitsForMessage = true
         if (callGraphMessageCount==0) // looks stupid, but event may have happened&notify() may have been called during tracing
-          synchronized {
             wait() // for an event to happen 
-          }
+        waitsForMessage = false
       }
       // note: there may also be deadlock because of unmatching communications
       // so there should preferably be a check for the existence of waiting event handling actions