public void Individual_Equals_Test() { TaskSchedulingProblem Gauss18 = new TaskSchedulingProblem(TaskSchedulingInstanceDescription.Gauss18(2)); TaskSchedulingSolution thisObj = new TaskSchedulingSolution( Gauss18, new int[2, 18] { {0, 5, 1, 2, 6, 10, 7, 3, 8, 11, 12, 4, 9, 13, 15, 16, 14, 17}, {1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1} } ); TaskSchedulingSolution thisObjAgain = new TaskSchedulingSolution( Gauss18, new int[2, 18] { {0, 5, 1, 2, 6, 10, 7, 3, 8, 11, 12, 4, 9, 13, 15, 16, 14, 17}, {1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1} } ); TaskSchedulingSolution thatObj = new TaskSchedulingSolution( Gauss18, new int[2, 18] { {0, 5, 1, 2, 6, 10, 7, 3, 8, 11, 12, 4, 9, 13, 15, 16, 14, 18}, {1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1} } ); Assert.AreEqual(thisObj, thisObjAgain); Assert.AreNotEqual(thisObj, thatObj); }
public override IndividualBase CreateRandomSolution() { IndividualBase schedulingSolution = new TaskSchedulingSolution(this); ValidateIndividual(schedulingSolution); // Random Solutions do not need Validation in this case. return schedulingSolution; }
// TODO: Testing public override void ValidateIndividual(IndividualBase individual) { TaskSchedulingSolution schedulingSolution = (individual as TaskSchedulingSolution); List <List <TaskIndexingNode> > TasksGroupedByProcessor = GroupTasksByProcessor(schedulingSolution); for (int processorIdx = 0; processorIdx < ProcessorCount; ++processorIdx) { List <TaskIndexingNode> TasksInProcessor = TasksGroupedByProcessor[processorIdx]; for (int probableDependantIdx = 0; probableDependantIdx < TasksInProcessor.Count; ++probableDependantIdx) { int probableDependantTask = TasksInProcessor[probableDependantIdx].Task; for (int probableDependencyIdx = probableDependantIdx + 1; probableDependencyIdx < TasksInProcessor.Count; ++probableDependencyIdx) { int probableDependencyTask = TasksInProcessor[probableDependencyIdx].Task; if (CommGraph.DependsOn(probableDependantTask, probableDependencyTask)) { schedulingSolution.SwapGenesAt(TasksInProcessor[probableDependantIdx].Index, TasksInProcessor[probableDependencyIdx].Index); TasksInProcessor.Swap(probableDependantIdx, probableDependencyIdx); int Temp = TasksInProcessor[probableDependantIdx].Index; TasksInProcessor[probableDependantIdx].Index = TasksInProcessor[probableDependencyIdx].Index; TasksInProcessor[probableDependencyIdx].Index = Temp; probableDependantIdx = -1; break; } } } } }
public override IndividualBase CreateRandomSolution() { IndividualBase schedulingSolution = new TaskSchedulingSolution(this); ValidateIndividual(schedulingSolution); // Random Solutions do not need Validation in this case. return(schedulingSolution); }
public override void MutateIndividual(IndividualBase individual) { TaskSchedulingSolution schedulingSolution = (individual as TaskSchedulingSolution); int indexA = Aleatoriety.GetRandomInt(TaskCount); int indexB; do { indexB = Aleatoriety.GetRandomInt(TaskCount); } while (indexB == indexA); schedulingSolution.SwapGenesAt(indexA, indexB); schedulingSolution.SwapProcessorAt(indexA); }
public override void PMXCrossover(IndividualBase parent1, IndividualBase parent2, out IndividualBase child1, out IndividualBase child2) { int[,] parent1Scheduling = (parent1 as TaskSchedulingSolution).GeneticMaterial; int[,] parent2Scheduling = (parent2 as TaskSchedulingSolution).GeneticMaterial; int startIdxInclusive = Aleatoriety.GetRandomInt(TaskCount - 1); int endIdxExclusive = Aleatoriety.GetRandomInt(startIdxInclusive + 1, TaskCount + 1); int[,] L1 = new int[2, TaskCount]; int[,] L2 = new int[2, TaskCount]; int L1idx; int L2idx; for (int idx = 0; idx < TaskCount; ++idx) { if ((idx < startIdxInclusive) || (idx >= endIdxExclusive)) { int L1CopyFromTask = parent1Scheduling[0, idx]; int L1CopyFromProcessor = parent1Scheduling[1, idx]; while ((L1idx = IndexOfTaskInInterval(L1CopyFromTask, startIdxInclusive, endIdxExclusive, parent2Scheduling)) != -1) { L1CopyFromTask = parent1Scheduling[0, L1idx]; L1CopyFromProcessor = parent1Scheduling[1, L1idx]; } L1[0, idx] = L1CopyFromTask; L1[1, idx] = L1CopyFromProcessor; int L2CopyFromTask = parent2Scheduling[0, idx]; int L2CopyFromProcessor = parent2Scheduling[1, idx]; while ((L2idx = IndexOfTaskInInterval(L2CopyFromTask, startIdxInclusive, endIdxExclusive, parent1Scheduling)) != -1) { L2CopyFromTask = parent2Scheduling[0, L2idx]; L2CopyFromProcessor = parent2Scheduling[1, L2idx]; } L2[0, idx] = L2CopyFromTask; L2[1, idx] = L2CopyFromProcessor; } else { L1[0, idx] = parent2Scheduling[0, idx]; L1[1, idx] = parent2Scheduling[1, idx]; L2[0, idx] = parent1Scheduling[0, idx]; L2[1, idx] = parent1Scheduling[1, idx]; } } child1 = new TaskSchedulingSolution(this, L1); child2 = new TaskSchedulingSolution(this, L2); }
private List <List <TaskIndexingNode> > GroupTasksByProcessor(TaskSchedulingSolution schedulingSolution) { List <List <TaskIndexingNode> > tasksGroupedByProcessor = new List <List <TaskIndexingNode> >(); for (int pCount = 0; pCount < ProcessorCount; ++pCount) { tasksGroupedByProcessor.Add(new List <TaskIndexingNode>()); } for (int idx = 0; idx < TaskCount; ++idx) { int Processor = schedulingSolution.GeneticMaterial[1, idx]; int Task = schedulingSolution.GeneticMaterial[0, idx]; tasksGroupedByProcessor[Processor].Add(new TaskIndexingNode(Task, idx)); } return(tasksGroupedByProcessor); }
public override string NewSerializeIndividual(IndividualBase individual) { TaskSchedulingSolution schedulingSolution = (individual as TaskSchedulingSolution); List <List <TaskIndexingNode> > tasksGroupedByProcessor = GroupTasksByProcessor(schedulingSolution); StringBuilder sb = new StringBuilder(); sb.Append("MakeSpan: " + individual.GetValueForObjective(MultiObjectiveGoal.First()) + " _ "); sb.Append("Potencia: " + individual.GetValueForObjective(MultiObjectiveGoal.Last()) + " _ "); for (int idx = 0; idx < TaskCount - 1; ++idx) { sb.Append(" " + schedulingSolution.GeneticMaterial[0, idx] + " (" + schedulingSolution.GeneticMaterial[1, idx] + ") -"); } sb.Append(" " + schedulingSolution.GeneticMaterial[0, TaskCount - 1] + " (" + schedulingSolution.GeneticMaterial[1, TaskCount - 1] + ")"); return(sb.ToString()); }
public override bool Equals(object obj) { TaskSchedulingSolution scheduling = (obj as TaskSchedulingSolution); IEnumerator enumThis = GeneticMaterial.GetEnumerator(); IEnumerator enumThat = scheduling.GeneticMaterial.GetEnumerator(); while (enumThis.MoveNext() && enumThat.MoveNext()) { if (!int.Equals(enumThis.Current, enumThat.Current)) { return(false); } } if (enumThis.MoveNext() == false && enumThat.MoveNext() == false) { return(true); } return(false); }
public override string SerializeIndividual(IndividualBase individual) { TaskSchedulingSolution schedulingSolution = (individual as TaskSchedulingSolution); List <List <TaskIndexingNode> > tasksGroupedByProcessor = GroupTasksByProcessor(schedulingSolution); StringBuilder sb = new StringBuilder(); sb.AppendLine("Individual:"); sb.AppendLine("\t" + "Value: " + individual.GetValueForObjective(MonoObjectiveGoal)); for (int processorIdx = 0; processorIdx < ProcessorCount; ++processorIdx) { sb.Append("\t" + "P" + processorIdx + ": " + "["); foreach (int task in tasksGroupedByProcessor[processorIdx].Select(TIN => TIN.Task)) { sb.Append(" " + task + " |"); } sb.Append("| " + schedulingSolution.ProcessorStatus[processorIdx] + " ]"); sb.Append(Environment.NewLine); } return(sb.ToString()); }
public void StaticProblem_EvaluateIndividual_Test() { TaskSchedulingProblem Gauss18 = new TaskSchedulingProblem(TaskSchedulingInstanceDescription.Gauss18(2)); TaskSchedulingSolution solution = new TaskSchedulingSolution( Gauss18, new int[2, 18] { {0, 5, 1, 2, 6, 10, 7, 3, 8, 11, 12, 4, 9, 13, 15, 16, 14, 17}, {1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1} } ); Gauss18.ValidateIndividual(solution); Gauss18.EvaluateIndividual(solution); Assert.AreEqual(44.0, solution.MakeSpan); Assert.AreEqual(691.2, solution.SpentPower); solution = new TaskSchedulingSolution( Gauss18, new int[2, 18] { {8, 5, 1, 2, 6, 10, 7, 3, 0, 11, 12, 4, 9, 13, 15, 16, 14, 17}, {1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1} } ); Gauss18.ValidateIndividual(solution); Gauss18.EvaluateIndividual(solution); Assert.AreEqual(48.0, solution.MakeSpan); Assert.AreEqual(691.2, solution.SpentPower); TaskSchedulingSolution solutionWithDeadLock = new TaskSchedulingSolution( Gauss18, new int[2, 18] { {1, 10, 7, 8, 12, 0, 2, 6, 3, 11, 5, 4, 9, 13, 15, 16, 14, 17}, {0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} } ); Gauss18.ValidateIndividual(solutionWithDeadLock); Gauss18.EvaluateIndividual(solutionWithDeadLock); }
private List<List<TaskIndexingNode>> GroupTasksByProcessor(TaskSchedulingSolution schedulingSolution) { List<List<TaskIndexingNode>> tasksGroupedByProcessor = new List<List<TaskIndexingNode>>(); for (int pCount = 0; pCount < ProcessorCount; ++pCount) tasksGroupedByProcessor.Add(new List<TaskIndexingNode>()); for (int idx = 0; idx < TaskCount; ++idx) { int Processor = schedulingSolution.GeneticMaterial[1, idx]; int Task = schedulingSolution.GeneticMaterial[0, idx]; tasksGroupedByProcessor[Processor].Add(new TaskIndexingNode(Task, idx)); } return tasksGroupedByProcessor; }
public override void PMXCrossover(IndividualBase parent1, IndividualBase parent2, out IndividualBase child1, out IndividualBase child2) { int[,] parent1Scheduling = (parent1 as TaskSchedulingSolution).GeneticMaterial; int[,] parent2Scheduling = (parent2 as TaskSchedulingSolution).GeneticMaterial; int startIdxInclusive = Aleatoriety.GetRandomInt(TaskCount - 1); int endIdxExclusive = Aleatoriety.GetRandomInt(startIdxInclusive + 1, TaskCount + 1); int[,] L1 = new int[2, TaskCount]; int[,] L2 = new int[2, TaskCount]; int L1idx; int L2idx; for (int idx = 0; idx < TaskCount; ++idx) { if ((idx < startIdxInclusive) || (idx >= endIdxExclusive)) { int L1CopyFromTask = parent1Scheduling[0, idx]; int L1CopyFromProcessor = parent1Scheduling[1, idx]; while ((L1idx = IndexOfTaskInInterval(L1CopyFromTask, startIdxInclusive, endIdxExclusive, parent2Scheduling)) != -1) { L1CopyFromTask = parent1Scheduling[0, L1idx]; L1CopyFromProcessor = parent1Scheduling[1, L1idx]; } L1[0, idx] = L1CopyFromTask; L1[1, idx] = L1CopyFromProcessor; int L2CopyFromTask = parent2Scheduling[0, idx]; int L2CopyFromProcessor = parent2Scheduling[1, idx]; while ((L2idx = IndexOfTaskInInterval(L2CopyFromTask, startIdxInclusive, endIdxExclusive, parent1Scheduling)) != -1) { L2CopyFromTask = parent2Scheduling[0, L2idx]; L2CopyFromProcessor = parent2Scheduling[1, L2idx]; } L2[0, idx] = L2CopyFromTask; L2[1, idx] = L2CopyFromProcessor; } else { L1[0, idx] = parent2Scheduling[0, idx]; L1[1, idx] = parent2Scheduling[1, idx]; L2[0, idx] = parent1Scheduling[0, idx]; L2[1, idx] = parent1Scheduling[1, idx]; } } child1 = new TaskSchedulingSolution(this, L1); child2 = new TaskSchedulingSolution(this, L2); }
public override void EvaluateIndividual(IndividualBase individual) { REDO: TaskSchedulingSolution schedulingSolution = individual as TaskSchedulingSolution; schedulingSolution.SpentPower = 0; double pCommunication = 0; int pTask = 0; bool[] scheduledTasks = new bool[TaskCount]; int remainingTasks = TaskCount; int[] processorsSchedullingTimeForTask = new int[TaskCount]; schedulingSolution.ProcessorStatus = new int[ProcessorCount]; int currentAllocationCost; List <List <TaskIndexingNode> > tasksGroupedByProcessor = GroupTasksByProcessor(schedulingSolution); bool deadLockOcurred; do { for (int currentProcessor = 0; currentProcessor < ProcessorCount; ++currentProcessor) { if (tasksGroupedByProcessor[currentProcessor].Count != 0) { int nextTaskForProcessor = tasksGroupedByProcessor[currentProcessor][0].Task; IEnumerable <int> notScheduledTaskDependencies = CommGraph.GetDirectDependencies(nextTaskForProcessor).Where(Dep => scheduledTasks[Dep] == false); bool readyForScheduling = (notScheduledTaskDependencies.Count() == 0); if (readyForScheduling) { int currentTask = nextTaskForProcessor; currentAllocationCost = schedulingSolution.ProcessorStatus[currentProcessor]; foreach (int dependencyTask in CommGraph.GetDirectDependencies(currentTask)) { int idx = 0; while (schedulingSolution.GeneticMaterial[0, idx] != dependencyTask) { ++idx; } int dependencyProcessor = schedulingSolution.GeneticMaterial[1, idx]; if (dependencyProcessor != currentProcessor) { pCommunication += Math.Pow(CommGraph.GetCommunicationCost(dependencyTask, currentTask), 2); int dependencyCost = processorsSchedullingTimeForTask[dependencyTask] + CommGraph.GetCommunicationCost(dependencyTask, currentTask); if (dependencyCost > currentAllocationCost) { currentAllocationCost = dependencyCost; } } } currentAllocationCost += CommGraph.GetEdgeCost(currentTask); schedulingSolution.ProcessorStatus[currentProcessor] = currentAllocationCost; processorsSchedullingTimeForTask[currentTask] = currentAllocationCost; pTask += CommGraph.GetEdgeCost(currentTask); scheduledTasks[currentTask] = true; tasksGroupedByProcessor[currentProcessor].RemoveAt(0); remainingTasks--; currentProcessor = -1; } } } if (remainingTasks != 0) { deadLockOcurred = true; // Tratamento de DeadLock int chosenSourceProcessor; do { chosenSourceProcessor = Aleatoriety.GetRandomInt(ProcessorCount); } while (tasksGroupedByProcessor[chosenSourceProcessor].Count == 0); int chosenDestProcessor; do { chosenDestProcessor = Aleatoriety.GetRandomInt(ProcessorCount); } while (chosenSourceProcessor == chosenDestProcessor); int taskToBeTransfered = tasksGroupedByProcessor[chosenSourceProcessor].First().Task; int idx = 0; while (schedulingSolution.GeneticMaterial[0, idx] != taskToBeTransfered) { ++idx; } schedulingSolution.GeneticMaterial[1, idx] = chosenDestProcessor; ValidateIndividual(schedulingSolution); goto REDO; } else { deadLockOcurred = false; } } while (deadLockOcurred); // Houve DeadLock schedulingSolution.MakeSpan = schedulingSolution.ProcessorStatus.Max(); schedulingSolution.SpentPower = (pTask * k1) + (pCommunication * k2); }