The Problem

When the model $PTII/org/terraswarm/accessor/test/auto/WebSocketClientJS.xml:

is run, the following stack trace appears

ptolemy.kernel.util.IllegalActionException: Found a zero delay loop containing .WebSocketClientJS.WebSocketServer
in .WebSocketClientJS and .WebSocketClientJS.WebSocketServer
at ptolemy.actor.util.CausalityInterfaceForComposites._computeOutputPortDepth(CausalityInterfaceForComposites.java:755)
at ptolemy.actor.util.CausalityInterfaceForComposites._computeInputDepth(CausalityInterfaceForComposites.java:694)
at ptolemy.actor.util.CausalityInterfaceForComposites._computeOutputPortDepth(CausalityInterfaceForComposites.java:763)
at ptolemy.actor.util.CausalityInterfaceForComposites._computeInputDepth(CausalityInterfaceForComposites.java:694)
at ptolemy.actor.util.CausalityInterfaceForComposites._computeActorDepth(CausalityInterfaceForComposites.java:530)
at ptolemy.actor.util.CausalityInterfaceForComposites.checkForCycles(CausalityInterfaceForComposites.java:95)
at ptolemy.domains.de.kernel.DEDirector.preinitialize(DEDirector.java:1338)
at ptolemy.actor.CompositeActor.preinitialize(CompositeActor.java:1820)
at ptolemy.actor.Manager.preinitializeAndResolveTypes(Manager.java:1030)
at ptolemy.actor.Manager.initialize(Manager.java:702)
at ptolemy.actor.Manager.execute(Manager.java:354)
at ptolemy.actor.Manager.run(Manager.java:1252)
at ptolemy.actor.Manager$PtolemyRunThread.run(Manager.java:1903)

[$[Get Code]]

The proposed fix is to set the connection output of accessors/web/net/WebSocketServer.js to be spontaneous:

this.output('connection', {'spontaneous': true});

[$[Get Code]]

However, this does not solve the problem.

Analysis

The MicrostepDelay actor can be used to fix the zero delay loop, see $PTII/org/terraswarm/accessor/test/auto/WebSocketClient.xml. However, we want to create a composite accessor that will run on any accessor host and thus does not use the MicrostepDelay actor.

The MicrostepDelay actor has two methods that are used to fix the loop:

/** Declare that the output does not depend on the input in a firing.
* @exception IllegalActionException If the causality interface
* cannot be computed.
* @see #getCausalityInterface()
*/
@Override
public void declareDelayDependency() throws IllegalActionException {
_declareDelayDependency(input, output, 0.0);
}
...
/** Return false indicating that this actor can be fired even if
* the inputs are unknown.
* @return False.
*/
@Override
public boolean isStrict() {
return false;
}

[$[Get Code]]

commonHost.js defines two methods that deal with spontaneous outputs:

/** Assign priorities to contained accessors based on a topological sort of the
* connectivity graph. Priorities are integers (positive or negative), where a lower
* number indicates a higher priority. The number for an accessor is assured of being
* higher than the number for any upstream accessor. An accessor A is upstream of
* an accessor B if A has an output connected to an input of B and that output is not
* marked "spontaneous" (that is, it does not have an option with name "spontaneous"
* and value true). A spontaneous output is produced by an asynchronous callback
* rather than as a response to an input. Every directed cycle in a connectivity
* graph must contain at least one spontaneous output or there will be a deadlock
* due to a causality loop.
*/
Accessor.prototype.assignPriorities = function() {
...

[$[Get Code]]

assignPriorities() calls

/** Assuming that the specified accessor has an assigned priority, follow its
* connections downstream and assign priorities to connected accessors.
* @param accessor The contained accessor with a priority.
* @param cyclePriority If we encounter an accessor with this priority, then
* there is a causality loop.
*/
Accessor.prototype.assignImpliedPrioritiesDownstream = function(accessor, cyclePriority) {
...

[$[Get Code]]

and

/** Assuming that the specified accessor has an assigned priority, follow its
* connections upstream and assign priorities to connected accessors.
* @param accessor The contained accessor with a priority.
* @param cyclePriority If we encounter an accessor with this priority, then
* there is a causality loop.
*/
Accessor.prototype.assignImpliedPrioritiesUpstream = function(accessor, cyclePriority) {
var myPriority = accessor.priority;
// To get repeatable priorities, iterate over outputs in order.
for (var i = 0; i < accessor.outputList.length; i++) {
var output = accessor.outputs[accessor.outputList[i]];
if (output.spontaneous) {
// Output is spontaneous, so my priority has no implications
// for downstream accessors.
continue;
}
if (output.destinations) {
// There are destination accessors.
...

[$[Get Code]]

These two functions loop through the outputs and if the output is marked as spontaneous

The priorities are used here:

/** Schedule a reaction of the specified contained accessor.
* This puts the accessor onto the event queue in priority order.
* This assumes that priorities are unique to each accessor.
* It is necessary for the react() function to be invoked for this event
* to be handled, so this function uses setTimeout(function, time) with time
* argument 0 to schedule a reaction. This ensures that the reaction occurs
* after the currently executing function has completely executed.
* @param accessor The accessor.
*/
Accessor.prototype.scheduleEvent = function(accessor) {
...

[$[Get Code]]

Solution

The solution was to add declareDelayDependency() to the JavaScript actor. First, we loop through the output ports and add a SingletonParameter to the port if the spontaneous argument is present in the accessor. Then, declareDelayDependency() loops through the ports and declares any ports with spontaneous == true as not depending on any of the inputs.

CapeCodeZeroDelayLoops

The Problem

Analysis

Solution