if (_debugging && VERBOSE) {
_debug("Actors that can be scheduled:");
for (Iterator readyActors = readyToScheduleActorList
.iterator(); readyActors.hasNext();) {
Entity readyActor = (Entity) readyActors.next();
_debug(readyActor.getFullName());
}
_debug("Actors with firings left:");
for (Iterator remainingActors = unscheduledActorList
.iterator(); remainingActors.hasNext();) {
Entity remainingActor = (Entity) remainingActors.next();
_debug(remainingActor.getFullName());
}
}
// Pick an actor that is ready to fire.
Actor currentActor = (Actor) readyToScheduleActorList
.getFirst();
// Remove it from the list of actors we are waiting to fire.
while (readyToScheduleActorList.remove(currentActor)) {
}
// Determine the number of times currentActor can fire.
int numberOfFirings = _computeMaximumFirings(currentActor);
// We should never schedule something more than the number
// of times expected by the balance equations. This might
// happen because we assume an infinite number of tokens
// are waiting on external ports.
int firingsRemaining = ((Integer) firingsRemainingVector
.get(currentActor)).intValue();
if (numberOfFirings > firingsRemaining) {
numberOfFirings = firingsRemaining;
}
if (_debugging && VERBOSE) {
_debug("Scheduling actor " + currentActor.getName() + " "
+ numberOfFirings + " times.");
}
// Update the firingsRemainingVector for this actor.
firingsRemaining -= numberOfFirings;
firingsRemainingVector.put(currentActor, Integer
.valueOf(firingsRemaining));
if (_debugging && VERBOSE) {
_debug(currentActor.getName() + " should fire "
+ firingsRemaining + " more times.");
}
// Simulate the tokens that are consumed by the actors
// input ports.
_simulateInputConsumption(currentActor, numberOfFirings);
// Add it to the schedule numberOfFirings times.
Firing firing = new Firing();
firing.setActor(currentActor);
firing.setIterationCount(numberOfFirings);
newSchedule.add(firing);
// Get all its outputPorts
// and simulate the proper production of tokens.
for (Iterator outputPorts = (currentActor).outputPortList()
.iterator(); outputPorts.hasNext();) {
IOPort outputPort = (IOPort) outputPorts.next();
int count = DFUtilities.getTokenProductionRate(outputPort);
_simulateTokensCreated(outputPort, count * numberOfFirings,
unscheduledActorList, readyToScheduleActorList);
}
// Figure out what to do with the actor, now that it has been
// scheduled.
if (firingsRemaining < 0) {
// If we screwed up somewhere, and fired this more
// times than we thought we should have
// then throw an exception.
// This should never happen.
throw new InternalErrorException("Balance Equation "
+ "solution does not agree with "
+ "scheduling algorithm!");
}
if (firingsRemaining == 0) {
// If we've fired this actor all the
// times that it should, then
// we get rid of it entirely.
if (_debugging && VERBOSE) {
_debug("Actor = " + currentActor + " is done firing.");
}
// Remove the actor from the unscheduledActorList
// since we don't need to fire it any more.
while (unscheduledActorList.remove(currentActor)) {
;
}
if (_debugging && VERBOSE) {
_debug("Remaining actors:");
for (Iterator readyActors = readyToScheduleActorList
.iterator(); readyActors.hasNext();) {
Entity entity = (Entity) readyActors.next();
_debug(entity.getFullName());
}
}
} else {
// Otherwise the actor still has firings left.
// Count the number of unfulfilled inputs.
int inputCount = _countUnfulfilledInputs(currentActor,
unscheduledActorList, false);
// We've already removed currentActor from
// readyToSchedule actors, and presumably
// fired it until it can be fired no more.
// This check is here for robustness...
// if the actor can still be scheduled
// i.e. all its inputs are satisfied, and it
// appears in the unscheduled actors list
// then put it on the readyToScheduleActorList.
if ((inputCount <= 0)
&& unscheduledActorList.contains(currentActor)) {
readyToScheduleActorList.addFirst(currentActor);
}
}
}
} catch (IllegalActionException ex) {
// This could happen if we call getTokenConsumptionRate on a
// port that isn't a part of the actor. This probably means
// the graph is screwed up, or somebody else is mucking
// with it.
throw new InternalErrorException(this, ex,
"SDF Scheduler Failed internal consistency check.");
}
// If there are any actors left when we're done, then report the
// error.
if (unscheduledActorList.size() > 0) {
StringBuffer message = new StringBuffer(
"Actors remain that cannot be scheduled!\n"
+ "Unscheduled actors:\n");
// Only display the first 100 connected or disconnected actors.
int count = 0;
for (Iterator actors = unscheduledActorList.iterator(); actors
.hasNext()
&& count < 100; count++) {
Entity entity = (Entity) actors.next();
message.append(entity.getFullName() + " ");
}
if (count >= 99) {
message.append("...");
}
message.append("\nScheduled actors:\n");
List scheduledActorList = new LinkedList();
scheduledActorList.addAll(actorList);
scheduledActorList.removeAll(unscheduledActorList);
count = 0;
for (Iterator actors = scheduledActorList.iterator(); actors
.hasNext()
&& count < 100; count++) {
Entity entity = (Entity) actors.next();
message.append(entity.getFullName() + " ");
}
if (count >= 99) {
message.append("...");
}