void SetupDependecyMachinesRecursive(AbstractMachine machine)
{
machine.OnStateChanged += Con_OnStateChanged;
foreach (AbstractMachine m in machine._dependentOnMachines)
{
SetupDependecyMachinesRecursive(m);
}
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
Debug.WriteLine($"<ScheduleDebug> Created task '{machineInfo.Id}' for machine " +
$"'{machineInfo.Machine.Id}'.");
this.TaskMap.TryAdd(id, machineInfo);
}
/// <summary>
/// Notify that the machine received an event that it was waiting for.
/// </summary>
/// <param name="machine">Machine</param>
internal void NotifyTaskReceivedEvent(AbstractMachine machine)
{
var machineInfo = this.TaskMap.Values.First(mi => mi.Machine.Equals(machine) && !mi.IsCompleted);
machineInfo.IsWaitingToReceive = false;
Debug.WriteLine($"<ScheduleDebug> Task '{machineInfo.Id}' of machine " +
$"'{machineInfo.Machine.Id}' received an event and unblocked.");
}
/// <summary>
/// Creates a scheduling choice trace step.
/// </summary>
/// <param name="index">Index</param>
/// <param name="scheduledMachine">Scheduled machine</param>
/// <returns>TraceStep</returns>
internal static TraceStep CreateSchedulingChoice(int index, AbstractMachine scheduledMachine)
{
var traceStep = new TraceStep();
traceStep.Index = index;
traceStep.Type = TraceStepType.SchedulingChoice;
traceStep.ScheduledMachine = scheduledMachine;
traceStep.Previous = null;
traceStep.Next = null;
return traceStep;
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal virtual void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
IO.Debug($"<ScheduleDebug> Created task '{machineInfo.Id}' for machine " +
$"'{machineInfo.Machine.Id}'.");
if (this.TaskMap.Count == 0)
{
machineInfo.IsActive = true;
}
this.TaskMap.TryAdd(id, machineInfo);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal MachineInfo(int id, AbstractMachine machine)
{
this.Id = id;
this.Machine = machine;
this.IsEnabled = true;
this.IsWaitingToReceive = false;
this.IsActive = false;
this.HasStarted = false;
this.IsCompleted = false;
this.BlockingWrappedTasks = new List <MachineInfo>();
this.BlockingUnwrappedTasks = new List <Task>();
this.WaitAll = false;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal MachineInfo(int id, AbstractMachine machine)
{
this.Id = id;
this.Machine = machine;
this.IsEnabled = true;
this.IsWaitingToReceive = false;
this.IsBlocked = false;
this.IsActive = false;
this.HasStarted = false;
this.IsCompleted = false;
this.BlockingWrappedTasks = new List<MachineInfo>();
this.BlockingUnwrappedTasks = new List<Task>();
this.WaitAll = false;
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal override void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
IO.Debug($"<ScheduleDebug> Created task '{machineInfo.Id}' for machine " +
$"'{machineInfo.Machine.Id}'.");
if (base.TaskMap.Count == 0)
{
machineInfo.IsActive = true;
}
base.TaskMap.TryAdd(id, machineInfo);
if (machine is TaskMachine)
{
this.WrappedTaskMap.TryAdd((machine as TaskMachine).WrappedTask.Id, machineInfo);
}
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal override void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
IO.Debug($"<ScheduleDebug> Created task '{machineInfo.Id}' for machine " +
$"'{machineInfo.Machine.Id}'.");
if (base.MachineInfos.Count == 0)
{
machineInfo.IsActive = true;
}
base.MachineInfos.Add(machineInfo);
base.TaskMap.TryAdd(id, machineInfo);
if (machine is TaskMachine)
{
this.WrappedTaskMap.TryAdd((machine as TaskMachine).WrappedTask.Id, machineInfo);
}
}
protected void Con_OnStateChanged(AbstractMachine obj)
{
UpdateIsWorkingState();
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal virtual void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
IO.Debug($"<ScheduleDebug> Created task '{machineInfo.Id}' for machine " +
$"'{machineInfo.Machine.Id}'.");
if (this.MachineInfos.Count == 0)
{
machineInfo.IsActive = true;
}
this.MachineInfos.Add(machineInfo);
this.TaskMap.TryAdd(id, machineInfo);
}
/// <summary>
/// Returns the info of the given machine.
/// </summary>
/// <param name="machine">Machine</param>
/// <returns>TaskId</returns>
protected MachineInfo GetInfoFromMachine(AbstractMachine machine)
{
MachineInfo machineInfo = null;
foreach (var mi in this.MachineInfos)
{
if (mi.Machine.Equals(machine))
{
machineInfo = mi;
break;
}
}
return machineInfo;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="sender"></param>
public AbstractMessage(AbstractMachine sender)
{
this.sender = sender;
}
public SegmentRequestMessage(AbstractMachine from) : base(from)
{
}
/// <summary>
/// Creates a schedule step.
/// </summary>
/// <param name="index">Index</param>
/// <param name="scheduledMachine">Scheduled machine</param>
/// <returns>ScheduleStep</returns>
internal static ScheduleStep CreateSchedulingChoice(int index, AbstractMachine scheduledMachine)
{
var scheduleStep = new ScheduleStep();
scheduleStep.Index = index;
scheduleStep.Type = ScheduleStepType.SchedulingChoice;
scheduleStep.ScheduledMachine = scheduledMachine;
scheduleStep.ScheduledMachineType = scheduledMachine.Id.Type;
scheduleStep.ScheduledMachineId = scheduledMachine.Id.Value;
scheduleStep.BooleanChoice = null;
scheduleStep.IntegerChoice = null;
scheduleStep.Previous = null;
scheduleStep.Next = null;
return scheduleStep;
}
protected internal override Task <bool> SendEventAndExecute(MachineId mid, Event e, AbstractMachine sender, SendOptions options)
{
throw new NotImplementedException();
}
protected internal override void Monitor(Type type, AbstractMachine sender, Event e)
{
throw new NotImplementedException();
}
protected internal override int GetNondeterministicIntegerChoice(AbstractMachine machine, int maxValue)
{
throw new NotImplementedException();
}
protected internal override bool GetFairNondeterministicBooleanChoice(AbstractMachine machine, string uniqueId)
{
throw new NotImplementedException();
}
public CountMessage(AbstractMachine from) : base(from)
{
}
public RemapPartitionMessage(AbstractMachine from, IEnumerable <KeyValuePair <int, int> > map)
: base(from)
{
this.map = map.ToArray();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="from"></param>
/// <param name="pairs"></param>
public SegmentResponseMessage(AbstractMachine from, IEnumerable <KeyValuePair <TNode, int> > pairs)
: base(from)
{
this.pairs = pairs.ToArray();
}
public EstimateRefinedMessage(AbstractMachine from) : base(from)
{
}
protected internal override void SendEventRemotely(MachineId mid, Event e, AbstractMachine sender, SendOptions options)
{
throw new NotImplementedException();
}
public StopMessage(AbstractMachine from) : base(from)
{
}
public ExactRefinedMessage(AbstractMachine from, IEnumerable <KeyValuePair <Tuple <TLabel, HashSet <Tuple <TLabel, int> > >, int> > partitionMap)
: base(from)
{
this.partitionMap = partitionMap.ToArray();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="from"></param>
/// <param name="workers"></param>
public CoordinatorMessage(AbstractMachine from, IEnumerable <AbstractMachine> workers)
: base(from)
{
this.workers = workers.ToArray();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="from"></param>
/// <param name="changes"></param>
/// <param name="signatureSize"></param>
public UpdatePartitionMessage(AbstractMachine from, IEnumerable <KeyValuePair <TNode, int> > changes)
: base(from)
{
this.changes = changes.ToArray();
}
/// <summary>
/// Notify that the machine received an event that it was waiting for.
/// </summary>
/// <param name="machine">Machine</param>
internal void NotifyTaskReceivedEvent(AbstractMachine machine)
{
var machineInfo = this.GetInfoFromMachine(machine);
IO.Debug("<ScheduleDebug> Task {0} of machine {1}({2}) " +
"received an event and unblocked.", machineInfo.Id, machineInfo.Machine.GetType(),
machineInfo.Machine.Id.MVal);
machineInfo.IsWaiting = false;
}
/// <summary>
/// Notify that the machine received an event that it was waiting for.
/// </summary>
/// <param name="machine">Machine</param>
internal void NotifyTaskReceivedEvent(AbstractMachine machine)
{
var machineInfo = this.MachineInfos.First(mi => mi.Machine.Equals(machine) && !mi.IsCompleted);
machineInfo.IsWaitingToReceive = false;
IO.Debug($"<ScheduleDebug> Task '{machineInfo.Id}' of machine " +
$"'{machineInfo.Machine.Id}' received an event and unblocked.");
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal virtual void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
IO.Debug("<ScheduleDebug> Created task {0} for machine {1}({2}).",
machineInfo.Id, machineInfo.Machine.GetType(), machineInfo.Machine.Id.MVal);
if (this.MachineInfos.Count == 0)
{
machineInfo.IsActive = true;
}
this.MachineInfos.Add(machineInfo);
this.TaskMap.Add(id, machineInfo);
}
/// <summary>
/// Checks if there is already an enabled task for the given machine.
/// </summary>
/// <param name="machine">Machine</param>
/// <returns>Boolean</returns>
internal bool HasEnabledTaskForMachine(AbstractMachine machine)
{
var enabledTasks = this.TaskMap.Values.Where(machineInfo => machineInfo.IsEnabled).ToList();
return(enabledTasks.Any(machineInfo => machineInfo.Machine.Equals(machine)));
}
/// <summary>
/// Checks if there is already an enabled task for the given machine.
/// </summary>
/// <param name="machine">Machine</param>
/// <returns>Boolean</returns>
internal bool HasEnabledTaskForMachine(AbstractMachine machine)
{
var enabledTasks = this.MachineInfos.Where(machineInfo => machineInfo.IsEnabled).ToList();
return enabledTasks.Any(machineInfo => machineInfo.Machine.Equals(machine));
}
public ClearMessage(AbstractMachine from) : base(from)
{
}
/// <summary>
/// Notify that a new task has been created for the given machine.
/// </summary>
/// <param name="id">TaskId</param>
/// <param name="machine">Machine</param>
internal override void NotifyNewTaskCreated(int id, AbstractMachine machine)
{
var machineInfo = new MachineInfo(id, machine);
IO.Debug("<ScheduleDebug> Created task {0} for machine {1}({2}).",
machineInfo.Id, machineInfo.Machine.GetType(), machineInfo.Machine.Id.MVal);
if (base.MachineInfos.Count == 0)
{
machineInfo.IsActive = true;
}
base.MachineInfos.Add(machineInfo);
base.TaskMap.Add(id, machineInfo);
if (machine is TaskMachine)
{
this.WrappedTaskMap.Add((machine as TaskMachine).WrappedTask.Id, machineInfo);
}
}
public RefineMessage(AbstractMachine from) : base(from)
{
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="from"></param>
/// <param name="count"></param>
public CountedMessage(AbstractMachine from, IEnumerable <int> blocks)
: base(from)
{
this.blocks = blocks.ToArray();
}
public ShareMessage(AbstractMachine from) : base(from)
{
}
