├── 1-MSL ├── DAGgenerateFuc.m ├── ESTForiTaskFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GanteForDVFSTasks.m ├── GanteForPM.m ├── MSLFuc.m ├── ProcessorMergingFuc.m ├── Processor_Merging_smallExample.m ├── forLoopFuc.m ├── lowerBoundFuc.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relMaxFuc.m └── upwardRankFuc.m ├── 2-PM ├── DAGgenerateFuc.m ├── ESTForiTaskFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GanteForDVFSTasks.m ├── GanteForPM.m ├── MSLFuc.m ├── ProcessorMergingFuc.m ├── Processor_Merging_smallExample.m ├── forLoopFuc.m ├── lowerBoundFuc.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relMaxFuc.m └── upwardRankFuc.m ├── 3-DVFS-T ├── DAGgenerateFuc.m ├── DVFS_TasksFuc.m ├── DVFS_Tasks_smallExample.m ├── ESTForiTaskFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GanteForDVFSTasks.m ├── MSLFuc.m ├── RTRForiTaskFuc.m ├── allocateTaskinECUdvfsFuc.m ├── collectBeamDvfsSchedule.m ├── energyCalDvfsFuc.m ├── energyCalPerTaskFuc.m ├── findECUfromScheduleFuc.m ├── findEFTfromScheduleFuc.m ├── findESTfromScheduleFuc.m ├── forLoopFuc.m ├── insertSlot.m ├── lowerBoundFuc.m ├── makeSpanCalFuc.m ├── newGantePerTask.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relArrayMulFuc.m ├── relCal.m ├── relMaxFuc.m ├── scheduleFunctionDVFSFuc.m ├── tickOutChosenTask.m ├── upwardRankFuc.m └── wcetReilCalFuc.m ├── 4-DVFS-T+ ├── DAGgenerateFuc.m ├── DVFS_TasksFuc.m ├── ESTForiTaskFuc.m ├── EnergyConsumptionFreqFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GanteForDVFSTasks.m ├── GanteForPM.m ├── MSLFuc.m ├── Merging_DVFS_Task_smallExample.m ├── ProcessorMergingFuc.m ├── ProcessorMerging_DVFSTaskFuc.m ├── RTRForiTaskFuc.m ├── allocateTaskinECUdvfsFuc.m ├── collectBeamDvfsSchedule.m ├── energyCalDvfsFuc.m ├── energyCalPerTaskFuc.m ├── findECUfromScheduleFuc.m ├── findEFTfromScheduleFuc.m ├── findESTfromScheduleFuc.m ├── forLoopFuc.m ├── insertSlot.m ├── lowerBoundFuc.m ├── makeSpanCalFuc.m ├── newGantePerTask.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relArrayMulFuc.m ├── relCal.m ├── relMaxFuc.m ├── scheduleFunctionDVFSFuc.m ├── tickOutChosenTask.m ├── upwardRankFuc.m └── wcetReilCalFuc.m ├── 5-DVFS-P ├── DAGgenerateFuc.m ├── DVFS_ProcessorFuc.m ├── DVFS_Processor_smallExample.m ├── ESTForiTaskFuc.m ├── EnergyConsumptionFreqFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GanteForDVFSPro.m ├── MSLFuc.m ├── forLoopFuc.m ├── lowerBoundFuc.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relMaxFuc.m └── upwardRankFuc.m ├── 6-DVFS-P+ ├── DAGgenerateFuc.m ├── DVFS_ProcessorFuc.m ├── ESTForiTaskFuc.m ├── EnergyConsumptionFreqFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GanteForDVFSPro.m ├── GanteForPM.m ├── MSLFuc.m ├── Merging_DVFS_Processor_smallExample.m ├── ProcessorMergingFuc.m ├── ProcessorMerging_DVFSFuc.m ├── forLoopFuc.m ├── lowerBoundFuc.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relMaxFuc.m └── upwardRankFuc.m ├── 7-GA ├── ESTForiTaskFuc.m ├── EnergyConsumptionFuc.m ├── FunctionClass.m ├── GeneticAlgorithm_smallExample.m ├── MSLFuc.m ├── cr.m ├── decode.m ├── decode2.m ├── forLoopFuc.m ├── gante.m ├── getHx.m ├── lowerBoundFuc.m ├── mu.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relMaxFuc.m ├── resInformation.m ├── setupData.m ├── setupDataForLoop.m ├── setupDataForRandomLoop.m ├── upwardRankFuc.m ├── xhCalculate.m └── 说明.docx ├── 8-fmincon ├── FunctionClass.m ├── MSLFuc.m ├── OPTI.m ├── fminconFunc1111.m ├── fminconFunc1221.m ├── lowerBoundFuc.m ├── nonlcon1111.m ├── nonlconGeneral.m ├── pickUpPredFuc.m ├── pickUpSuccFuc.m ├── rankUvalueFuc.m ├── relMaxFuc.m ├── resInformation.m ├── run_fmincon6tasks.m ├── testCirclecon.m └── upwardRankFuc.m └── README.md /1-MSL/DAGgenerateFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/DAGgenerateFuc.m -------------------------------------------------------------------------------- /1-MSL/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /1-MSL/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /1-MSL/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /1-MSL/GanteForDVFSTasks.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/GanteForDVFSTasks.m -------------------------------------------------------------------------------- /1-MSL/GanteForPM.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/GanteForPM.m -------------------------------------------------------------------------------- /1-MSL/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/MSLFuc.m -------------------------------------------------------------------------------- /1-MSL/ProcessorMergingFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/ProcessorMergingFuc.m -------------------------------------------------------------------------------- /1-MSL/Processor_Merging_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/Processor_Merging_smallExample.m -------------------------------------------------------------------------------- /1-MSL/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/1-MSL/forLoopFuc.m -------------------------------------------------------------------------------- /1-MSL/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.E, 1); 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /1-MSL/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /1-MSL/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /1-MSL/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /1-MSL/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | numTask = size(DAG.E, 2); 3 | numPro = size(DAG.Wcet, 1); 4 | 5 | wcetArray = DAG.Wcet; 6 | relMax = 1; 7 | relMaxPerTask = []; 8 | for i = 1:numTask 9 | relTempMax = 0; 10 | indexTask = DAG.priority_order(i); 11 | for j = 1:numPro 12 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 13 | end 14 | relMaxPerTask = [relMaxPerTask, relTempMax]; 15 | relMax = relMax * relTempMax; 16 | end -------------------------------------------------------------------------------- /1-MSL/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /2-PM/DAGgenerateFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/DAGgenerateFuc.m -------------------------------------------------------------------------------- /2-PM/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /2-PM/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /2-PM/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /2-PM/GanteForDVFSTasks.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/GanteForDVFSTasks.m -------------------------------------------------------------------------------- /2-PM/GanteForPM.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/GanteForPM.m -------------------------------------------------------------------------------- /2-PM/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/MSLFuc.m -------------------------------------------------------------------------------- /2-PM/ProcessorMergingFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/ProcessorMergingFuc.m -------------------------------------------------------------------------------- /2-PM/Processor_Merging_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/Processor_Merging_smallExample.m -------------------------------------------------------------------------------- /2-PM/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/2-PM/forLoopFuc.m -------------------------------------------------------------------------------- /2-PM/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.E, 1); 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /2-PM/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /2-PM/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /2-PM/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /2-PM/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | numTask = size(DAG.E, 2); 3 | numPro = size(DAG.Wcet, 1); 4 | 5 | wcetArray = DAG.Wcet; 6 | relMax = 1; 7 | relMaxPerTask = []; 8 | for i = 1:numTask 9 | relTempMax = 0; 10 | indexTask = DAG.priority_order(i); 11 | for j = 1:numPro 12 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 13 | end 14 | relMaxPerTask = [relMaxPerTask, relTempMax]; 15 | relMax = relMax * relTempMax; 16 | end -------------------------------------------------------------------------------- /2-PM/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /3-DVFS-T/DAGgenerateFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/DAGgenerateFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/DVFS_TasksFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/DVFS_TasksFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/DVFS_Tasks_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/DVFS_Tasks_smallExample.m -------------------------------------------------------------------------------- /3-DVFS-T/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /3-DVFS-T/GanteForDVFSTasks.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/GanteForDVFSTasks.m -------------------------------------------------------------------------------- /3-DVFS-T/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/MSLFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/RTRForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/RTRForiTaskFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/allocateTaskinECUdvfsFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/allocateTaskinECUdvfsFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/collectBeamDvfsSchedule.m: -------------------------------------------------------------------------------- 1 | function [scheduleBeam, relMaxPerTaskBeam, frequencyOut] = collectBeamDvfsSchedule(scheduleBeamTemp, relMaxPerTaskBeamTemp, beamSize, energySpec, frequencyArray, indexTask) 2 | 3 | energyTotalSet = []; 4 | scheduleCellSetIn = scheduleBeamTemp; 5 | relMaxPerTaskCellSetIn = relMaxPerTaskBeamTemp; 6 | 7 | for i = 1:size(scheduleCellSetIn, 2) 8 | if ~isempty(scheduleCellSetIn{i}) 9 | makeSpanMax = 0; 10 | schedule = scheduleCellSetIn{i}; 11 | energyTotal = energyCalDvfsFuc(schedule, energySpec, frequencyArray, indexTask); 12 | energyTotalSet(i) = energyTotal; 13 | else 14 | energyTotalSet(i) = 1e30; 15 | end 16 | end 17 | 18 | [result, indexS] = sort(energyTotalSet); 19 | 20 | for i = 1:beamSize 21 | scheduleBeam{i} = scheduleCellSetIn{indexS(i)}; 22 | relMaxPerTaskBeam{i} = relMaxPerTaskCellSetIn{indexS(i)}; 23 | frequencyOut = frequencyArray(indexS(i)); 24 | end -------------------------------------------------------------------------------- /3-DVFS-T/energyCalDvfsFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/energyCalDvfsFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/energyCalPerTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/energyCalPerTaskFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/findECUfromScheduleFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/findECUfromScheduleFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/findEFTfromScheduleFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/findEFTfromScheduleFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/findESTfromScheduleFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/findESTfromScheduleFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/forLoopFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/insertSlot.m: -------------------------------------------------------------------------------- 1 | function ecuSchedule = insertSlot(ecuSchedule, slot, iTask,iCountTask) 2 | sceduleL=slot(2)-slot(1); 3 | slot1=[slot(1),sceduleL,slot(2)]; 4 | if eq(size(ecuSchedule,1), 0) 5 | ecuSchedule = [slot1, iCountTask, iTask]; 6 | else 7 | if eq(size(ecuSchedule,1), 1) 8 | if ecuSchedule(1,1) >= slot1(3) 9 | ecuSchedule = [slot1, iCountTask, iTask; ecuSchedule]; 10 | else 11 | ecuSchedule = [ecuSchedule; slot1, iCountTask, iTask]; 12 | end 13 | else 14 | if ecuSchedule(1,1) >= slot1(3) 15 | ecuSchedule = [slot1, iCountTask, iTask; ecuSchedule]; 16 | else 17 | for j = 2:size(ecuSchedule,1) 18 | if ecuSchedule(j,1) >= slot1(3) && ecuSchedule(j-1,3) <= slot1(1) 19 | ecuSchedule = [ecuSchedule(1:j-1,:); slot1, iCountTask, iTask; ecuSchedule(j:end,:)]; 20 | break 21 | end 22 | if eq(j, size(ecuSchedule,1)) 23 | ecuSchedule = [ecuSchedule; slot1, iCountTask, iTask]; 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /3-DVFS-T/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.E, 2); 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /3-DVFS-T/makeSpanCalFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/makeSpanCalFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/newGantePerTask.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/newGantePerTask.m -------------------------------------------------------------------------------- /3-DVFS-T/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /3-DVFS-T/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /3-DVFS-T/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /3-DVFS-T/relArrayMulFuc.m: -------------------------------------------------------------------------------- 1 | function relDenominator = relArrayMulFuc(relMaxPerTask, i) 2 | 3 | relDenominator = 1; 4 | for j = 1:size(relMaxPerTask, 2) 5 | relDenominator = relDenominator * relMaxPerTask(j); 6 | end 7 | 8 | relDenominator = relDenominator/relMaxPerTask(i); -------------------------------------------------------------------------------- /3-DVFS-T/relCal.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/relCal.m -------------------------------------------------------------------------------- /3-DVFS-T/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | numTask = size(DAG.E, 2); 3 | numPro = size(DAG.Wcet, 1); 4 | 5 | wcetArray = DAG.Wcet; 6 | relMax = 1; 7 | relMaxPerTask = []; 8 | for i = 1:numTask 9 | relTempMax = 0; 10 | indexTask = DAG.priority_order(i); 11 | for j = 1:numPro 12 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 13 | end 14 | relMaxPerTask = [relMaxPerTask, relTempMax]; 15 | relMax = relMax * relTempMax; 16 | end -------------------------------------------------------------------------------- /3-DVFS-T/scheduleFunctionDVFSFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/scheduleFunctionDVFSFuc.m -------------------------------------------------------------------------------- /3-DVFS-T/tickOutChosenTask.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/3-DVFS-T/tickOutChosenTask.m -------------------------------------------------------------------------------- /3-DVFS-T/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /3-DVFS-T/wcetReilCalFuc.m: -------------------------------------------------------------------------------- 1 | function wcetLongest = wcetReilCalFuc(relReqForiTask, failureRate, wcetMin, d, energySpec, proIndex) 2 | 3 | wcetMax = -log(relReqForiTask)/failureRate; 4 | wcetMinConstant = wcetMin; 5 | if wcetMax < wcetMin 6 | wcetLongest = wcetMin; 7 | else 8 | while 1 9 | wcetTemp = (wcetMin + wcetMax)/2; 10 | freq = wcetMinConstant/wcetTemp; 11 | relFreqRatio = failureRate*10^(d*(energySpec(proIndex,6)-freq)/(energySpec(proIndex,6)-energySpec(proIndex,5))); 12 | reliability = exp(-relFreqRatio*wcetTemp); 13 | if abs(reliability - relReqForiTask) < 1e-5 14 | wcetLongest = wcetTemp; 15 | break 16 | elseif reliability > relReqForiTask 17 | wcetMin = wcetTemp; 18 | else 19 | wcetMax = wcetTemp; 20 | end 21 | end 22 | end -------------------------------------------------------------------------------- /4-DVFS-T+/DAGgenerateFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/DAGgenerateFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/DVFS_TasksFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/DVFS_TasksFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/EnergyConsumptionFreqFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/EnergyConsumptionFreqFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /4-DVFS-T+/GanteForDVFSTasks.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/GanteForDVFSTasks.m -------------------------------------------------------------------------------- /4-DVFS-T+/GanteForPM.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/GanteForPM.m -------------------------------------------------------------------------------- /4-DVFS-T+/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/MSLFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/Merging_DVFS_Task_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/Merging_DVFS_Task_smallExample.m -------------------------------------------------------------------------------- /4-DVFS-T+/ProcessorMergingFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/ProcessorMergingFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/ProcessorMerging_DVFSTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/ProcessorMerging_DVFSTaskFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/RTRForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/RTRForiTaskFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/allocateTaskinECUdvfsFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/allocateTaskinECUdvfsFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/collectBeamDvfsSchedule.m: -------------------------------------------------------------------------------- 1 | function [scheduleBeam, relMaxPerTaskBeam, frequencyOut] = collectBeamDvfsSchedule(scheduleBeamTemp, relMaxPerTaskBeamTemp, beamSize, energySpec, frequencyArray, indexTask) 2 | 3 | energyTaskISet = []; 4 | scheduleCellSetIn = scheduleBeamTemp; 5 | relMaxPerTaskCellSetIn = relMaxPerTaskBeamTemp; 6 | 7 | for i = 1:size(scheduleCellSetIn, 2) 8 | if ~isempty(scheduleCellSetIn{i}) 9 | makeSpanMax = 0; 10 | schedule = scheduleCellSetIn{i}; 11 | energyTaskI = energyCalDvfsFuc(schedule, energySpec, frequencyArray, indexTask); 12 | energyTaskISet(i) = energyTaskI; 13 | else 14 | energyTaskISet(i) = 1e30; 15 | end 16 | end 17 | 18 | [result, indexS] = sort(energyTaskISet); 19 | 20 | for i = 1:beamSize 21 | scheduleBeam{i} = scheduleCellSetIn{indexS(i)}; 22 | relMaxPerTaskBeam{i} = relMaxPerTaskCellSetIn{indexS(i)}; 23 | frequencyOut = frequencyArray(indexS(i)); 24 | end -------------------------------------------------------------------------------- /4-DVFS-T+/energyCalDvfsFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/energyCalDvfsFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/energyCalPerTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/energyCalPerTaskFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/findECUfromScheduleFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/findECUfromScheduleFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/findEFTfromScheduleFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/findEFTfromScheduleFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/findESTfromScheduleFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/findESTfromScheduleFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/forLoopFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/insertSlot.m: -------------------------------------------------------------------------------- 1 | function ecuSchedule = insertSlot(ecuSchedule, slot, iTask,iCountTask) 2 | sceduleL=slot(2)-slot(1); 3 | slot1=[slot(1),sceduleL,slot(2)]; 4 | if eq(size(ecuSchedule,1), 0) 5 | ecuSchedule = [slot1, iCountTask, iTask]; 6 | else 7 | if eq(size(ecuSchedule,1), 1) 8 | if ecuSchedule(1,1) >= slot1(3) 9 | ecuSchedule = [slot1, iCountTask, iTask; ecuSchedule]; 10 | else 11 | ecuSchedule = [ecuSchedule; slot1, iCountTask, iTask]; 12 | end 13 | else 14 | if ecuSchedule(1,1) >= slot1(3) 15 | ecuSchedule = [slot1, iCountTask, iTask; ecuSchedule]; 16 | else 17 | for j = 2:size(ecuSchedule,1) 18 | if ecuSchedule(j,1) >= slot1(3) && ecuSchedule(j-1,3) <= slot1(1) 19 | ecuSchedule = [ecuSchedule(1:j-1,:); slot1, iCountTask, iTask; ecuSchedule(j:end,:)]; 20 | break 21 | end 22 | if eq(j, size(ecuSchedule,1)) 23 | ecuSchedule = [ecuSchedule; slot1, iCountTask, iTask]; 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /4-DVFS-T+/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.Wcet, 2)-1; 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /4-DVFS-T+/makeSpanCalFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/makeSpanCalFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/newGantePerTask.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/newGantePerTask.m -------------------------------------------------------------------------------- /4-DVFS-T+/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /4-DVFS-T+/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /4-DVFS-T+/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /4-DVFS-T+/relArrayMulFuc.m: -------------------------------------------------------------------------------- 1 | function relDenominator = relArrayMulFuc(relMaxPerTask, i) 2 | 3 | relDenominator = 1; 4 | for j = 1:size(relMaxPerTask, 2) 5 | relDenominator = relDenominator * relMaxPerTask(j); 6 | end 7 | 8 | relDenominator = relDenominator/relMaxPerTask(i); -------------------------------------------------------------------------------- /4-DVFS-T+/relCal.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/relCal.m -------------------------------------------------------------------------------- /4-DVFS-T+/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | 3 | wcetArray = DAG.Wcet; 4 | relMax = 1; 5 | relMaxPerTask = []; 6 | for i = 1:(size(wcetArray, 2)-1) 7 | relTempMax = 0; 8 | indexTask = DAG.priority_order(i); 9 | for j = 1:size(wcetArray, 1) 10 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 11 | end 12 | relMaxPerTask = [relMaxPerTask, relTempMax]; 13 | relMax = relMax * relTempMax; 14 | end -------------------------------------------------------------------------------- /4-DVFS-T+/scheduleFunctionDVFSFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/scheduleFunctionDVFSFuc.m -------------------------------------------------------------------------------- /4-DVFS-T+/tickOutChosenTask.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/4-DVFS-T+/tickOutChosenTask.m -------------------------------------------------------------------------------- /4-DVFS-T+/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /4-DVFS-T+/wcetReilCalFuc.m: -------------------------------------------------------------------------------- 1 | function wcetLongest = wcetReilCalFuc(relReqForiTask, failureRate, wcetMin, d, energySpec, proIndex) 2 | 3 | wcetMax = -log(relReqForiTask)/failureRate; 4 | wcetMinConstant = wcetMin; 5 | if wcetMax < wcetMin 6 | wcetLongest = wcetMin; 7 | else 8 | while 1 9 | wcetTemp = (wcetMin + wcetMax)/2; 10 | freq = wcetMinConstant/wcetTemp; 11 | relFreqRatio = failureRate*10^(d*(energySpec(proIndex,6)-freq)/(energySpec(proIndex,6)-energySpec(proIndex,5))); 12 | reliability = exp(-relFreqRatio*wcetTemp); 13 | if abs(reliability - relReqForiTask) < 1e-5 14 | wcetLongest = wcetTemp; 15 | break 16 | elseif reliability > relReqForiTask 17 | wcetMin = wcetTemp; 18 | else 19 | wcetMax = wcetTemp; 20 | end 21 | end 22 | end -------------------------------------------------------------------------------- /5-DVFS-P/DAGgenerateFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/DAGgenerateFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/DVFS_ProcessorFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/DVFS_ProcessorFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/DVFS_Processor_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/DVFS_Processor_smallExample.m -------------------------------------------------------------------------------- /5-DVFS-P/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/EnergyConsumptionFreqFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/EnergyConsumptionFreqFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /5-DVFS-P/GanteForDVFSPro.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/GanteForDVFSPro.m -------------------------------------------------------------------------------- /5-DVFS-P/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/MSLFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/5-DVFS-P/forLoopFuc.m -------------------------------------------------------------------------------- /5-DVFS-P/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.Wcet, 2)-1; 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /5-DVFS-P/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /5-DVFS-P/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /5-DVFS-P/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /5-DVFS-P/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | 3 | wcetArray = DAG.Wcet; 4 | relMax = 1; 5 | relMaxPerTask = []; 6 | for i = 1:(size(wcetArray, 2)-1) 7 | relTempMax = 0; 8 | indexTask = DAG.priority_order(i); 9 | for j = 1:size(wcetArray, 1) 10 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 11 | end 12 | relMaxPerTask = [relMaxPerTask, relTempMax]; 13 | relMax = relMax * relTempMax; 14 | end -------------------------------------------------------------------------------- /5-DVFS-P/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /6-DVFS-P+/DAGgenerateFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/DAGgenerateFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/DVFS_ProcessorFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/DVFS_ProcessorFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/EnergyConsumptionFreqFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/EnergyConsumptionFreqFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /6-DVFS-P+/GanteForDVFSPro.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/GanteForDVFSPro.m -------------------------------------------------------------------------------- /6-DVFS-P+/GanteForPM.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/GanteForPM.m -------------------------------------------------------------------------------- /6-DVFS-P+/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/MSLFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/Merging_DVFS_Processor_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/Merging_DVFS_Processor_smallExample.m -------------------------------------------------------------------------------- /6-DVFS-P+/ProcessorMergingFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/ProcessorMergingFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/ProcessorMerging_DVFSFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/ProcessorMerging_DVFSFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/6-DVFS-P+/forLoopFuc.m -------------------------------------------------------------------------------- /6-DVFS-P+/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.Wcet, 2)-1; 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /6-DVFS-P+/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /6-DVFS-P+/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /6-DVFS-P+/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /6-DVFS-P+/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | 3 | wcetArray = DAG.Wcet; 4 | relMax = 1; 5 | relMaxPerTask = []; 6 | for i = 1:(size(wcetArray, 2)-1) 7 | relTempMax = 0; 8 | indexTask = DAG.priority_order(i); 9 | for j = 1:size(wcetArray, 1) 10 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 11 | end 12 | relMaxPerTask = [relMaxPerTask, relTempMax]; 13 | relMax = relMax * relTempMax; 14 | end -------------------------------------------------------------------------------- /6-DVFS-P+/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /7-GA/ESTForiTaskFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/ESTForiTaskFuc.m -------------------------------------------------------------------------------- /7-GA/EnergyConsumptionFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/EnergyConsumptionFuc.m -------------------------------------------------------------------------------- /7-GA/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | taskAllo 14 | finishTime 15 | deadlinePerTask 16 | end 17 | end -------------------------------------------------------------------------------- /7-GA/GeneticAlgorithm_smallExample.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/GeneticAlgorithm_smallExample.m -------------------------------------------------------------------------------- /7-GA/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/MSLFuc.m -------------------------------------------------------------------------------- /7-GA/cr.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/cr.m -------------------------------------------------------------------------------- /7-GA/decode.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/decode.m -------------------------------------------------------------------------------- /7-GA/decode2.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/decode2.m -------------------------------------------------------------------------------- /7-GA/forLoopFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/forLoopFuc.m -------------------------------------------------------------------------------- /7-GA/gante.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/gante.m -------------------------------------------------------------------------------- /7-GA/getHx.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/getHx.m -------------------------------------------------------------------------------- /7-GA/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.Wcet, 2)-1; 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /7-GA/mu.m: -------------------------------------------------------------------------------- 1 | function popout=mu(pop,pm) 2 | 3 | popout=pop; 4 | [ps,l]=size(pop); 5 | for i=1:ps 6 | temp=rand(1,1); 7 | if temp 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /7-GA/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /7-GA/rankUvalueFuc.m: -------------------------------------------------------------------------------- 1 | function [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | 10 | if ~eq(rankUvalueInitial(i), 0) 11 | rankUvalueI = rankUvalueInitial(i); 12 | else 13 | succArray = pickUpSuccFuc(Function.E,i); 14 | rankUvalueI = 0; 15 | if size(succArray, 2) > 1e-6 16 | for step = 1:size(succArray, 2) 17 | indexSucc = succArray(step); 18 | if eq(rankUvalueInitial(indexSucc), 0) 19 | succArray2 = pickUpSuccFuc(Function.E,indexSucc); 20 | if size(succArray2, 2) > 1e-6 21 | [rankUvalueIndexSucc, rankUvalueInitial] = rankUvalueFuc(Function, indexSucc, rankUvalueInitial); 22 | rankUvalueInitial(indexSucc) = rankUvalueIndexSucc; 23 | else 24 | rankUvalueInitial(indexSucc) = ceil(mean(Function.Wcet(:,indexSucc))); 25 | end 26 | end 27 | rankUvalueI = max(rankUvalueI, Function.E(i, indexSucc)+rankUvalueInitial(indexSucc)); 28 | end 29 | end 30 | rankUvalueI = ceil(mean(Function.Wcet(:,i))) + rankUvalueI; 31 | rankUvalueInitial(i) = rankUvalueI; 32 | end -------------------------------------------------------------------------------- /7-GA/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | 3 | wcetArray = DAG.Wcet; 4 | relMax = 1; 5 | relMaxPerTask = []; 6 | for i = 1:(size(wcetArray, 2)-1) 7 | relTempMax = 0; 8 | indexTask = DAG.priority_order(i); 9 | for j = 1:size(wcetArray, 1) 10 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 11 | end 12 | relMaxPerTask = [relMaxPerTask, relTempMax]; 13 | relMax = relMax * relTempMax; 14 | end -------------------------------------------------------------------------------- /7-GA/resInformation.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/resInformation.m -------------------------------------------------------------------------------- /7-GA/setupData.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/setupData.m -------------------------------------------------------------------------------- /7-GA/setupDataForLoop.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/setupDataForLoop.m -------------------------------------------------------------------------------- /7-GA/setupDataForRandomLoop.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/setupDataForRandomLoop.m -------------------------------------------------------------------------------- /7-GA/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = 1:size(Function.E, 1) 11 | [rankUvalueI, rankUvalueInitial] = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | if ~eq(min(rankUvalueInitial),0) 13 | break 14 | end 15 | end 16 | Function.upwardRank = rankUvalueInitial; 17 | Function.upwardRankBackUp = rankUvalueInitial; 18 | [B index] = sort(rankUvalueInitial, 'descend'); 19 | Function.priority_order = index; -------------------------------------------------------------------------------- /7-GA/xhCalculate.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/xhCalculate.m -------------------------------------------------------------------------------- /7-GA/说明.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/7-GA/说明.docx -------------------------------------------------------------------------------- /8-fmincon/FunctionClass.m: -------------------------------------------------------------------------------- 1 | classdef FunctionClass 2 | properties 3 | Wcet 4 | E 5 | priority_order 6 | upwardRank 7 | upwardRankBackUp 8 | arrivalTime 9 | lowerbound 10 | lowerBoundArray 11 | deadlineSlack 12 | relativeDeadline 13 | relMax 14 | relReq 15 | taskAllo 16 | finishTime 17 | deadlinePerTask 18 | end 19 | end -------------------------------------------------------------------------------- /8-fmincon/MSLFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/MSLFuc.m -------------------------------------------------------------------------------- /8-fmincon/OPTI.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/OPTI.m -------------------------------------------------------------------------------- /8-fmincon/fminconFunc1111.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/fminconFunc1111.m -------------------------------------------------------------------------------- /8-fmincon/fminconFunc1221.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/fminconFunc1221.m -------------------------------------------------------------------------------- /8-fmincon/lowerBoundFuc.m: -------------------------------------------------------------------------------- 1 | function F = lowerBoundFuc(F) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % lowerbound 8 | % end 9 | % end 10 | %% 11 | numECU = size(F.Wcet, 1); 12 | numTask = size(F.Wcet, 2)-1; 13 | 14 | EFTarray = []; 15 | AFTarray = []; 16 | availECU = zeros(numECU,1); 17 | for i = 1:numTask 18 | EFTperTask = []; 19 | indexTask = F.priority_order(i); 20 | for j = 1:numECU 21 | if abs(indexTask-1) < 1e-6 22 | EFTperTask = [EFTperTask, F.Wcet(j,indexTask)]; 23 | else 24 | ESTperECU = 0; 25 | predArray = pickUpPredFuc(F.E,indexTask); 26 | for indexPred = 1:size(predArray, 2) 27 | taskPred = predArray(indexPred); 28 | ESTperECU = max(ESTperECU, AFTarray(taskPred, 1) + abs(sign(AFTarray(taskPred, 2) - j))*F.E(taskPred, indexTask)); 29 | end 30 | ESTperECU = max(availECU(j), ESTperECU); 31 | EFTperTask = [EFTperTask, ESTperECU+F.Wcet(j,indexTask)]; 32 | end 33 | end 34 | EFTarray = [EFTarray; EFTperTask]; 35 | [maxEFT, ecuOFmaxEFT] = min(EFTperTask); 36 | availECU(ecuOFmaxEFT) = maxEFT; 37 | % AFTarray = [AFTarray; availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 38 | AFTarray(indexTask,:) = [availECU(ecuOFmaxEFT), ecuOFmaxEFT]; 39 | end 40 | F.lowerbound = min(EFTarray(end,:)); -------------------------------------------------------------------------------- /8-fmincon/nonlcon1111.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/nonlcon1111.m -------------------------------------------------------------------------------- /8-fmincon/nonlconGeneral.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/nonlconGeneral.m -------------------------------------------------------------------------------- /8-fmincon/pickUpPredFuc.m: -------------------------------------------------------------------------------- 1 | function predArray = pickUpPredFuc(matrixF,i) 2 | 3 | vector = matrixF(:,i); 4 | predArray = []; 5 | for go = 1:size(vector, 1) 6 | if vector(go) > 0 7 | predArray = [predArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /8-fmincon/pickUpSuccFuc.m: -------------------------------------------------------------------------------- 1 | function succArray = pickUpSuccFuc(matrixF,i) 2 | 3 | vector = matrixF(i,:); 4 | succArray = []; 5 | for go = 1:size(vector, 2) 6 | if vector(go) > 0 7 | succArray = [succArray, go]; 8 | end 9 | end -------------------------------------------------------------------------------- /8-fmincon/rankUvalueFuc.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/rankUvalueFuc.m -------------------------------------------------------------------------------- /8-fmincon/relMaxFuc.m: -------------------------------------------------------------------------------- 1 | function [relMax, relMaxPerTask] = relMaxFuc(DAG, failureRate) 2 | 3 | wcetArray = DAG.Wcet; 4 | relMax = 1; 5 | relMaxPerTask = []; 6 | for i = 1:(size(wcetArray, 2)-1) 7 | relTempMax = 0; 8 | indexTask = DAG.priority_order(i); 9 | for j = 1:size(wcetArray, 1) 10 | relTempMax = max(relTempMax, exp(-failureRate(j)*wcetArray(j,indexTask))); 11 | end 12 | relMaxPerTask = [relMaxPerTask, relTempMax]; 13 | relMax = relMax * relTempMax; 14 | end -------------------------------------------------------------------------------- /8-fmincon/resInformation.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/resInformation.m -------------------------------------------------------------------------------- /8-fmincon/run_fmincon6tasks.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S/5e56c110a609e6543c000f78955bcd5ce777e612/8-fmincon/run_fmincon6tasks.m -------------------------------------------------------------------------------- /8-fmincon/testCirclecon.m: -------------------------------------------------------------------------------- 1 | function [c,ceq] = testCirclecon(x) 2 | c = (x(1)-1/3)^2 + (x(2)-1/3)^2 - (1/3)^2; 3 | ceq = []; -------------------------------------------------------------------------------- /8-fmincon/upwardRankFuc.m: -------------------------------------------------------------------------------- 1 | function Function = upwardRankFuc(Function, rankUvalueInitial) 2 | % classdef FunctionClass 3 | % properties 4 | % wcet_tasks 5 | % DAG_matrix 6 | % priority_order 7 | % end 8 | % end 9 | rankUarray = []; 10 | for i = size(Function.E, 1):-1:1 11 | rankUvalueI = rankUvalueFuc(Function, i, rankUvalueInitial); 12 | rankUvalueInitial(i) = rankUvalueI; 13 | rankUarray = [rankUvalueI, rankUarray]; 14 | end 15 | Function.upwardRank = rankUarray; 16 | Function.upwardRankBackUp = rankUarray; 17 | [B, index] = sort(rankUarray, 'descend'); 18 | Function.priority_order = index; -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Energy-Minimized-Scheduling-of-Real-Time-Parallel-Workflows-on-Heterogeneous-Distributed-Computing-S 2 | The code of paper Energy-Minimized Scheduling of Real-Time Parallel Workflows on Heterogeneous Distributed Computing Systems 3 | 4 | This file provides the MATLAB source code of compared approaches in experiments in the paper. 5 | There is an executable file in each folder. 6 | Run this executable file to get the solution of a small example. 7 | 8 | @article{hu2021energy, 9 | 10 | title={Energy-Minimized Scheduling of Real-Time Parallel Workflows on Heterogeneous Distributed Computing Systems}, 11 | author={Hu, Biao and Cao, Zhengcai and Zhou, Mengchu}, 12 | journal={IEEE Transactions on Services Computing}, 13 | year={2021}, 14 | publisher={IEEE} 15 | } 16 | --------------------------------------------------------------------------------