public String[][] buildPlan()
{
buildProc();
buildTasks();
List <DiagramRow> rows = initRows();
while (!isAllTaskFinished())
{
for (int i = 0; i < quee.getQueue().Count; i++)
{
Task task = taskMap[quee.getQueue().ElementAt(i)];
if (task.state == TaskState.FINISHED)
{
continue;
}
int stepForDeploy = getStepForDeployTask(task, rows);
if (stepForDeploy == Int32.MinValue)
{
continue;
}
int[] planTaskInfo = plann(task, stepForDeploy, rows);
addTaskToDiagram(task, planTaskInfo, rows);
}
}
int maxRowCount = 0;
for (int i = 0; i < rows.Count; i++)
{
DiagramRow row = rows.ElementAt(i);
if (row.usedProc.Count != 0)
{
continue;
}
bool isUseState = false;
for (int j = 0; j < row.states.Length; j++)
{
DiagramState state = row.states[j];
if (state.transm.Count != 0 || state.task != null)
{
isUseState = true;
break;
}
}
if (isUseState)
{
continue;
}
maxRowCount = i;
break;
}
String[][] result = new String[maxRowCount][];
for (int i = 0; i < result.Length; i++)
{
result[i] = new String[procesors.Length];
for (int j = 0; j < procesors.Length; j++)
{
if (rows.ElementAt(i).states[j].task != null)
{
Task task = rows.ElementAt(i).states[j].task;
result[i][j] = "Task " + task.number + ";";
}
}
}
for (int i = 0; i < result.Length; i++)
{
for (int j = 0; j < procesors.Length; j++)
{
DiagramState diagramState = rows.ElementAt(i).states[j];
for (int k = 0; k < diagramState.transm.Count; k++)
{
Transmission transm = diagramState.transm.ElementAt(k);
Task taskFrom = taskMap[transm.taskFromNumber];
Task taskTo = taskMap[transm.taskToNumber];
if (j == taskTo.procNumber)
{
result[i][j] += "Receive from ";
}
else
{
result[i][j] += "Send from ";
}
result[i][j] += taskFrom.number + " to " + taskTo.number + ";";
}
}
}
return(result);
}
private int[] plannAlg5Task(Task task, int stepNumber, List <DiagramRow> rows)
{
int currentStep = stepNumber;
List <Processor> freeProc = null;
while (true)
{
freeProc = getAllFreeProcOnStep(currentStep, rows);
if (freeProc.Count > 0)
{
break;
}
currentStep++;
}
List <Tuple <Processor, Int32> > relatedProc = new List <Tuple <Processor, Int32> >();
for (int i = 0; i < task.requiredTransmission.Count; i++)
{
Transmission transm = task.requiredTransmission.ElementAt(i);
relatedProc.Add(new Tuple <Processor, Int32>(procMap[taskMap[transm.taskFromNumber].procNumber], incidenceTask[transm.taskFromNumber][transm.taskToNumber]));
}
List <Processor> minProc = new List <Processor>();
int minCharValue = Int32.MaxValue;
for (int i = 0; i < freeProc.Count; i++)
{
Processor currentProc = freeProc.ElementAt(i);
int charValue = 0;
for (int j = 0; j < relatedProc.Count; j++)
{
charValue += getShortestWayForTransm(currentProc.number, relatedProc.ElementAt(j).Item1.number, relatedProc.ElementAt(j).Item2).Count;
}
if (charValue == minCharValue)
{
if (minProc == null)
{
minProc = new List <Processor>();
}
minProc.Add(currentProc);
}
else if (charValue < minCharValue)
{
minProc = new List <Processor>();
minProc.Add(currentProc);
minCharValue = charValue;
}
}
if (minProc == null || minProc.Count == 0)
{
return(null);
}
if (minProc.Count == 1)
{
return(new int[] { currentStep, minProc.ElementAt(0).number });
}
int maxRelCount = minProc.ElementAt(0).relationCount;
List <Processor> maxProcList = new List <Processor>();
maxProcList.Add(minProc.ElementAt(0));
for (int i = 1; i < minProc.Count; i++)
{
if (minProc.ElementAt(i).relationCount == maxRelCount)
{
maxProcList.Add(minProc.ElementAt(i));
}
if (minProc.ElementAt(i).relationCount > maxRelCount)
{
maxProcList = new List <Processor>();
maxProcList.Add(minProc.ElementAt(i));
maxRelCount = minProc.ElementAt(i).relationCount;
}
}
Random random = new Random();
Processor proc = maxProcList.ElementAt(random.Next(maxProcList.Count));
return(new int[] { currentStep, proc.number });
}
