public DirectorNodeService(string TAG, IEnumerable <NodeName> allNodeNames, INodeProxyProvider proxyProvider, DCEPSettings settings)
{
this.TAG = TAG + "[DirectorNodeService] ";
this.allNodeNames = allNodeNames;
this.settings = settings;
this.localNodeCanTerminate = false;
if (settings.duration != 0)
{
this.durationMS = settings.timeUnit.GetTimeSpanFromDuration(settings.duration).TotalMilliseconds;
}
experimentRunMessageQueue = new SerializableQueue <ExperimentRunNodeDataMessage>();
nodesToWaitWithStartingFor = new HashSet <NodeName>(allNodeNames);
systemState = NodeExecutionState.WaitForStart;
lastReadyToTerminateSignalTime = new Dictionary <NodeName, double>();
experimentRunDataByNodeName = new Dictionary <NodeName, ExperimentRunData>();
foreach (var nodeName in allNodeNames)
{
lastReadyToTerminateSignalTime[nodeName] = -1;
experimentRunDataByNodeName[nodeName] = null;
}
this.proxyProvider = proxyProvider;
Thread t = new Thread(new ThreadStart(threadStartMethod));
t.Start();
}
public void terminateImmediately()
{
state = NodeExecutionState.DoTerminate;
if (directorNodeService != null)
{
directorNodeService.terminateAllNodesImmediately();
}
}
public virtual void OnPostExecute(Connector prevConnector)
{
if (NodeGraphManager.OutputDebugInfo)
{
System.Diagnostics.Debug.WriteLine("Node.OnPostExecute()");
}
ExecutionState = NodeExecutionState.Executed;
}
private void broadcastUpdatedExecutionState(NodeExecutionState newstate)
{
var m = new UpdatedExecutionStateMessage(settings.directorNodeName, newstate);
foreach (var item in allNodeNames)
{
(proxyProvider.getProxy(item) as IAmbrosiaNodeProxy).ReceiveDCEPControlMessageFork(m);
}
}
public DCEPNode(NodeName name, string[] inputlines, DCEPSettings settings)
{
TAG = "[" + name + "] ";
Console.WriteLine(TAG + "DCEPNode Constructor called.");
state = NodeExecutionState.WaitForStart;
receivedEventCount = 0;
sentReadyToStartMessage = false;
nodeName = name;
externalEventQueue = new SerializableQueue <AbstractEvent>();
internalEventQueue = new SerializableQueue <AbstractEvent>();
controlMessageQueue = new SerializableQueue <DCEPControlMessage>();
queryProcessors = new List <QueryProcessor>();
this.settings = settings;
executionPlan = new ExecutionPlan(inputlines);
benchmarkMeter = new BenchmarkMeter(settings, nodeName);
createQueryProcessors(executionPlan.queriesByNodeName[nodeName]);
}
public void processControlMessages()
{
while (!controlMessageQueue.Data.IsEmpty)
{
DCEPControlMessage controlMessage = null;
if (controlMessageQueue.Data.TryDequeue(out controlMessage))
{
if (controlMessage is NodeInfoForCoordinatorMessage)
{
directorNodeService.ProcessNodeInfoForCoordinatorMessage(controlMessage as NodeInfoForCoordinatorMessage);
}
else if (controlMessage is UpdatedExecutionStateMessage)
{
var newState = (controlMessage as UpdatedExecutionStateMessage).newState;
Console.WriteLine(TAG + "updated execution state from " + state.ToString() + " to " + newState.ToString());
state = newState;
}
}
}
}
public UpdatedExecutionStateMessage(NodeName sendingNode, NodeExecutionState newState) : base(sendingNode)
{
this.newState = newState;
}
public void threadStartMethod()
{
while (keepRunning)
{
switch (systemState)
{
case NodeExecutionState.WaitForStart:
// check if nodes are ready to start and start them when everyone is ready
if (nodesToWaitWithStartingFor.Count() == 0)
{
Console.WriteLine(TAG + " All nodes ready. Transitioning into run phase.");
broadcastUpdatedExecutionState(NodeExecutionState.DoStartInputGeneration);
if (settings.duration == 0)
{
Console.WriteLine(TAG + "running indefinitely from now on, DirectorNodeService is terminating.");
return;
}
systemState = NodeExecutionState.Running;
stopwatch.Start();
}
else
{
Console.WriteLine(TAG + "Waiting for node(s) " + string.Join(",", nodesToWaitWithStartingFor.Select(x => x.ToString())) + " to signal they are ready to start.");
Thread.Sleep(1000);
}
break;
case NodeExecutionState.Running:
// check the timer and send "stop input generation" requests once the timer is over
if ((stopwatch.ElapsedMilliseconds - this.durationMS) > 0)
{
broadcastUpdatedExecutionState(NodeExecutionState.DoStopInputGeneration);
systemState = NodeExecutionState.ProcessingRemainder;
Console.WriteLine(TAG + "Requested to stop input event generation on all nodes. Now waiting for all nodes to finish processing their event queues.");
}
break;
case NodeExecutionState.ProcessingRemainder:
// wait until all message queues are empty, then possibly count messages and send "terminate" requests
var nowMS = stopwatch.ElapsedMilliseconds;
if (lastReadyToTerminateSignalTime.Values.ToList().All(timestamp => timestamp != -1 && nowMS - timestamp < 1000))
{
Console.WriteLine(TAG + "Done. All nodes signaled their queues are empty within the last second. Requesting to terminate query processing on all nodes.");
broadcastUpdatedExecutionState(NodeExecutionState.DoSendExperimentDataAndTerminate);
// gathering experiment run data
Console.WriteLine(TAG + "Waiting for all nodes to send their ExperimentRunData");
while (experimentRunDataByNodeName.Values.ToList().Contains(null))
{
while (!experimentRunMessageQueue.Data.IsEmpty)
{
ExperimentRunNodeDataMessage m = null;
if (experimentRunMessageQueue.Data.TryDequeue(out m))
{
experimentRunDataByNodeName[m.sendingNode] = m.nodeData;
Console.WriteLine(TAG + "Received experiment data from node " + m.sendingNode);
}
}
Thread.Sleep(100);
}
// all experiment data was received
Console.WriteLine(TAG + "ExperimentRunData was received from all nodes. Printing the result and terminating.");
long totalSentEvents = 0;
long totalGeneratedComplexEvents = 0;
long totalGeneratedPrimtiveEvents = 0;
long totalDroppedComplexEvents = 0;
foreach (var item in experimentRunDataByNodeName)
{
totalSentEvents += item.Value.receivedEventCount;
totalGeneratedComplexEvents += item.Value.locallyGeneratedComplexEventCount;
totalGeneratedPrimtiveEvents += item.Value.locallyGeneratedPrimitiveEventCount;
totalDroppedComplexEvents += item.Value.locallyDroppedComplexEvents;
}
Console.WriteLine("");
Console.WriteLine("Total number of generated complex events: " + totalGeneratedComplexEvents);
Console.WriteLine("Total number of generated primitive events: " + totalGeneratedPrimtiveEvents);
Console.WriteLine("Total number of events sent over network: " + totalSentEvents);
Console.WriteLine("Total number of dropped complex events: " + totalDroppedComplexEvents);
localNodeCanTerminate = true;
return;
}
else
{
Thread.Sleep(100);
}
break;
}
}
}
public override void OnHandle(NodeExecutionState evt)
{
this.ExecutionState = evt;
}
public void threadStartMethod()
{
stopwatch.Start();
while (true)
{
processControlMessages();
switch (state)
{
case NodeExecutionState.WaitForStart:
/* // broadcast isready signal to directorNode every second
* if (stopwatch.ElapsedMilliseconds - lastStatusMessageToCoordinator > 1000){
* proxyProvider.getProxy(settings.directorNodeName).ReceiveDCEPControlMessageFork(new NodeIsReadyToStartMessage(nodeName));
* //Console.WriteLine(TAG + "sending ready to start message to director node "+settings.directorNodeName.ToString());
* lastStatusMessageToCoordinator = stopwatch.ElapsedMilliseconds;
* } */
if (!sentReadyToStartMessage)
{
proxyProvider.getProxy(settings.directorNodeName).ReceiveDCEPControlMessageFork(new NodeIsReadyToStartMessage(nodeName));
sentReadyToStartMessage = true;
}
break;
case NodeExecutionState.DoStartInputGeneration:
// TODO: check if this is not already running and throw an error if it is
primitiveEventSourceService.start();
state = NodeExecutionState.Running;
processingStep();
break;
case NodeExecutionState.Running:
processingStep();
break;
case NodeExecutionState.DoStopInputGeneration:
primitiveEventSourceService.stop();
state = NodeExecutionState.ProcessingRemainder;
break;
case NodeExecutionState.ProcessingRemainder:
processingStep();
// when queues are empty, send isReadyToTerminate message every second
if (getQueuedEventCount() == 0)
{
if (stopwatch.ElapsedMilliseconds - lastStatusMessageToCoordinator > 1000)
{
proxyProvider.getProxy(settings.directorNodeName)
.ReceiveDCEPControlMessageFork(new NodeIsReadyToTerminateMessage(nodeName));
lastStatusMessageToCoordinator = stopwatch.ElapsedMilliseconds;
}
}
break;
case NodeExecutionState.DoSendExperimentDataAndTerminate:
var data = new ExperimentRunData(
locallyGeneratedComplexEventCount,
receivedEventCount,
locallyGeneratedPrimitiveEventCount,
locallyDroppedComplexEvents);
proxyProvider.getProxy(settings.directorNodeName).ReceiveDCEPControlMessageFork(new ExperimentRunNodeDataMessage(nodeName, data));
Console.WriteLine(TAG + "Sent experiment data. Update loop is terminating.");
Thread.Sleep(500);
if (getQueuedEventCount() > 0)
{
Console.WriteLine(TAG + String.Format("WARNING: requested to terminate with {0} events left in queue.", getQueuedEventCount()));
}
if (directorNodeService != null)
{
while (!directorNodeService.localNodeCanTerminate)
{
processControlMessages();
}
}
return;
case NodeExecutionState.DoTerminate:
if (getQueuedEventCount() > 0)
{
Console.WriteLine(TAG + String.Format("WARNING: requested to terminate with {0} events left in queue.", getQueuedEventCount()));
}
return;
}
}
}
