├── example_dag.asv ├── example_dag.m ├── README.md ├── updateVMfuc.m ├── responseTimeSepFuc.m ├── responseTimeCheckFuc.m ├── responseTimeFuc.m ├── audsleyALgoFuc.m ├── executionTimeFuc.m ├── responseTimeMergeFuc.m └── responseTimeModelFuc.m /example_dag.asv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Workload-Aware-Scheduling-of-Multiple-Criticality-Real-Time-Applications-in-Vehicular-Edge-Computing/HEAD/example_dag.asv -------------------------------------------------------------------------------- /example_dag.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nucleusbiao/Workload-Aware-Scheduling-of-Multiple-Criticality-Real-Time-Applications-in-Vehicular-Edge-Computing/HEAD/example_dag.m -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Workload-Aware-Scheduling-of-Multiple-Criticality-Real-Time-Applications-in-Vehicular-Edge-Computing 2 | 3 | Please run example_dag to find the dynamic programming. 4 | -------------------------------------------------------------------------------- /updateVMfuc.m: -------------------------------------------------------------------------------- 1 | function vm_update = updateVMfuc(vm_i, DAG_id, j) 2 | 3 | vm_update = []; 4 | for i = 1:size(vm_i, 1) 5 | if ~eq(vm_i(i,1), DAG_id) 6 | vm_update = [vm_update; vm_i(i, :)]; 7 | elseif eq(i, j) 8 | vm_update = [vm_update; vm_i(i, :)]; 9 | end 10 | end -------------------------------------------------------------------------------- /responseTimeSepFuc.m: -------------------------------------------------------------------------------- 1 | function responseTime = responseTimeSepFuc(virtualMachines, newjob, k) 2 | 3 | 4 | virtualMachines_size = size(virtualMachines, 2); 5 | new_virtualMachine = [newjob, k]; 6 | virtualMachines{virtualMachines_size + 1} = new_virtualMachine; 7 | 8 | DAG_id = newjob(1); 9 | exec_priority_array = []; 10 | for i = 1:size(virtualMachines, 2) 11 | vm_i = virtualMachines{i}; 12 | for j = 1:size(vm_i, 1) 13 | if eq(DAG_id, vm_i(j, 1)) 14 | vm_update = updateVMfuc(vm_i, DAG_id, j); 15 | exec_time_j = executionTimeFuc(vm_update, DAG_id); 16 | priority_j = vm_i(j, end-1); 17 | exec_priority_array = [exec_priority_array; exec_time_j, priority_j, i]; 18 | end 19 | end 20 | end 21 | responseTime = responseTimeModelFuc(exec_priority_array, DAG_id); -------------------------------------------------------------------------------- /responseTimeCheckFuc.m: -------------------------------------------------------------------------------- 1 | function pass_DAG_id = responseTimeCheckFuc(virtualMachinesOfi, DAG_id_check) 2 | 3 | DAG_id = DAG_id_check; 4 | exec_priority_array = []; 5 | for i = 1:size(virtualMachinesOfi, 2) 6 | vm_i = virtualMachinesOfi{i}; 7 | for j = 1:size(vm_i, 1) 8 | if eq(DAG_id, vm_i(j, 1)) 9 | deadline = vm_i(j, 4); 10 | vm_update = updateVMfuc(vm_i, DAG_id, j); 11 | exec_time_j = executionTimeFuc(vm_update, DAG_id); 12 | priority_j = vm_i(j, end-1); 13 | exec_priority_array = [exec_priority_array; exec_time_j, priority_j, i]; 14 | end 15 | end 16 | end 17 | responseTime = responseTimeModelFuc(exec_priority_array, DAG_id); 18 | 19 | if responseTime < deadline 20 | pass_DAG_id = true; 21 | else 22 | pass_DAG_id = false; 23 | end -------------------------------------------------------------------------------- /responseTimeFuc.m: -------------------------------------------------------------------------------- 1 | function responseTimeNewJob = responseTimeFuc(job_VM, newjob) 2 | % job_VM = [Job_Period(i), Job_Load_PerUnit(i), Job_Deadline(i), resource]; 3 | resource = job_VM(end, end); 4 | job_VM = [job_VM; newjob, resource]; 5 | 6 | 7 | priority_last = job_VM(end, end-1); 8 | 9 | [rows,cols,vals] = find(job_VM(:,end-1) == priority_last); 10 | 11 | job_VM_options = {}; 12 | for i = 1:size(rows, 1) 13 | job_last = job_VM(rows(i), :); 14 | job_VM_options{i} = [job_VM(1:rows(i)-1, :); job_VM(rows(i)+1:end, :); job_last]; 15 | end 16 | 17 | responseTimeNewJobArray = []; 18 | for j = 1:size(rows, 1) 19 | job_VM = job_VM_options{j}; 20 | responseTimeNewJob = job_VM(end,2)/resource; 21 | for i = 1:size(job_VM, 1)-1 22 | responseTimeNewJob = responseTimeNewJob + ceil(responseTimeNewJob/job_VM(i,1))*job_VM(i,2)/resource; 23 | end 24 | responseTimeNewJobArray = [responseTimeNewJobArray, responseTimeNewJob]; 25 | end 26 | responseTimeNewJob = min(responseTimeNewJobArray); -------------------------------------------------------------------------------- /audsleyALgoFuc.m: -------------------------------------------------------------------------------- 1 | function scheduleFlag = audsleyALgoFuc(job_VM, newjob) 2 | % job_VM = [Job_Period(i), Job_Load_PerUnit(i), Job_Deadline(i), resource]; 3 | resource = job_VM(end, end); 4 | job_VM = [job_VM; newjob, resource]; 5 | 6 | 7 | scheduleFlag = true; 8 | 9 | while 1 10 | for i = size(job_VM, 1):-1:1 11 | testJob = job_VM(i, :); 12 | deadline = testJob(3); 13 | job_VM_temp = [job_VM(1:i-1, :); job_VM(i+1:end, :); testJob]; 14 | 15 | responseTimeTestJob = 0; 16 | for j = 1:size(job_VM_temp, 1) 17 | responseTimeTestJob = responseTimeTestJob + ceil(deadline/job_VM_temp(j,1))*job_VM_temp(j,2)/resource; 18 | end 19 | 20 | if responseTimeTestJob <= deadline 21 | job_VM = job_VM_temp(1:end-1, :); 22 | break 23 | elseif eq(i,1) 24 | scheduleFlag = false; 25 | break 26 | end 27 | end 28 | if ~scheduleFlag 29 | break 30 | elseif isempty(job_VM) 31 | break 32 | end 33 | end -------------------------------------------------------------------------------- /executionTimeFuc.m: -------------------------------------------------------------------------------- 1 | function exec_time_i = executionTimeFuc(vm_update, DAG_id) 2 | % newjob = [DAG_id, DAG_period, DAG_load(i), DAG_period, DAG_priority(i), resource]; 3 | 4 | resource = vm_update(1, end); 5 | position = find(vm_update(:, 1) == DAG_id); 6 | currentJob = vm_update(position,:); 7 | job_ahead = vm_update(1:position-1, :); 8 | job_lag = vm_update(position+1:end, :); 9 | if isempty(job_lag) 10 | execMax = 0; 11 | else 12 | execMax = max(job_lag(:,3)/job_lag(end,end)); 13 | end 14 | 15 | if isempty(job_ahead) 16 | exec_time_i = execMax + currentJob(3)/resource; 17 | else 18 | exec_time_currentJob = currentJob(3)/resource; 19 | reponseTime = exec_time_currentJob; 20 | while 1 21 | exec_time_ahead = exec_time_currentJob; 22 | for i = 1:size(job_ahead, 1) 23 | exec_time_ahead = exec_time_ahead + ceil(reponseTime/job_ahead(i,2))*job_ahead(i,3)/resource; 24 | end 25 | if abs(exec_time_ahead - reponseTime) > 1e-3 26 | reponseTime = exec_time_ahead; 27 | else 28 | exec_time_i = execMax + exec_time_ahead; 29 | break 30 | end 31 | end 32 | end 33 | 34 | 35 | -------------------------------------------------------------------------------- /responseTimeMergeFuc.m: -------------------------------------------------------------------------------- 1 | function [responseTime, insertPosition] = responseTimeMergeFuc(virtualMachines, newjob, k) 2 | % newjob = [DAG_id, DAG_period, DAG_load(i), DAG_period, DAG_priority(i)]; 3 | 4 | priorityMax = newjob(end); 5 | DAG_id = newjob(1); 6 | exec_priority_array = []; 7 | for i = 1:size(virtualMachines, 2) 8 | vm_i = virtualMachines{i}; 9 | if ~eq(i, k) 10 | for j = 1:size(vm_i, 1) 11 | if eq(DAG_id, vm_i(j, 1)) 12 | vm_update = updateVMfuc(vm_i, DAG_id, j); 13 | exec_time_j = executionTimeFuc(vm_update, DAG_id); 14 | priority_j = vm_i(j, end-1); 15 | exec_priority_array = [exec_priority_array; exec_time_j, priority_j, i]; 16 | end 17 | end 18 | end 19 | end 20 | 21 | vm_k = virtualMachines{k}; 22 | index = find(vm_k(:,1) == DAG_id); 23 | if isempty(index) 24 | indexMax = 0; 25 | else 26 | indexMax = max(index); 27 | end 28 | responseTime = inf; 29 | insertPosition = -1; 30 | for position_newjob = indexMax+1:1:size(vm_k,1)+1 31 | vm_k_temp = [vm_k(1:position_newjob-1,:); newjob, vm_k(end,end); vm_k(position_newjob:end,:)]; 32 | pass_DAG = true; 33 | for i = 1:DAG_id-1 34 | DAG_id_check = i; 35 | virtualMachinesOfi = virtualMachines; 36 | virtualMachinesOfi{k} = vm_k_temp; 37 | pass_DAG_id = responseTimeCheckFuc(virtualMachinesOfi, DAG_id_check); 38 | pass_DAG = pass_DAG & pass_DAG_id; 39 | end 40 | 41 | if pass_DAG 42 | for j = 1:size(vm_k_temp, 1) 43 | if eq(DAG_id, vm_k_temp(j, 1)) 44 | vm_update = updateVMfuc(vm_k_temp, DAG_id, j); 45 | exec_time_j = executionTimeFuc(vm_update, DAG_id); 46 | priority_j = vm_k_temp(j, end-1); 47 | exec_priority_array = [exec_priority_array; exec_time_j, priority_j, k]; 48 | end 49 | end 50 | responseTimeTemp = responseTimeModelFuc(exec_priority_array, DAG_id); 51 | if responseTimeTemp < responseTime 52 | responseTime = responseTimeTemp; 53 | insertPosition = position_newjob-1; 54 | end 55 | end 56 | end -------------------------------------------------------------------------------- /responseTimeModelFuc.m: -------------------------------------------------------------------------------- 1 | function responseTime = responseTimeModelFuc(exec_priority_array, DAG_id) 2 | % exec_priority_array = [exec_priority_array; exec_time_j, priority_j, vm_i]; 3 | 4 | responseTime = 0; 5 | feasibleTime_vm = zeros(max(exec_priority_array(:,end)), 1); 6 | if eq(DAG_id, 1) 7 | DAG_edge = zeros(5, 5); 8 | DAG_edge(1, 2) = 1; 9 | DAG_edge(1, 3) = 1; 10 | DAG_edge(1, 4) = 1; 11 | DAG_edge(2, 5) = 1; 12 | DAG_edge(3, 5) = 1; 13 | DAG_edge(4, 5) = 1; 14 | 15 | [temp, index] = sort(exec_priority_array(:,2), 'ascend'); 16 | exec_priority_array = exec_priority_array(index, :); 17 | for i = 1:size(exec_priority_array, 1) 18 | vm_index = exec_priority_array(i, end); 19 | priority = exec_priority_array(i, end-1); 20 | finishTime_i = max(feasibleTime_vm(vm_index), max(DAG_edge(:,priority))) + exec_priority_array(i, 1); 21 | if eq(i, size(exec_priority_array, 1)) 22 | DAG_edge(priority,end) = finishTime_i; 23 | else 24 | DAG_edge(priority,:) = DAG_edge(priority,:)*finishTime_i; 25 | end 26 | feasibleTime_vm(vm_index) = finishTime_i; 27 | end 28 | responseTime = max(max(DAG_edge)); 29 | 30 | elseif eq(DAG_id, 2) 31 | DAG_edge = zeros(10,10); 32 | DAG_edge(1, 2) = 1; 33 | DAG_edge(1, 3) = 1; 34 | DAG_edge(1, 4) = 1; 35 | DAG_edge(1, 5) = 1; 36 | DAG_edge(1, 6) = 1; 37 | DAG_edge(2, 8) = 1; 38 | DAG_edge(2, 9) = 1; 39 | DAG_edge(3, 7) = 1; 40 | DAG_edge(4, 8) = 1; 41 | DAG_edge(4, 9) = 1; 42 | DAG_edge(5, 9) = 1; 43 | DAG_edge(6, 8) = 1; 44 | DAG_edge(7, 10) = 1; 45 | DAG_edge(8, 10) = 1; 46 | DAG_edge(9, 10) = 1; 47 | 48 | [temp, index] = sort(exec_priority_array(:,2), 'ascend'); 49 | exec_priority_array = exec_priority_array(index, :); 50 | for i = 1:size(exec_priority_array, 1) 51 | vm_index = exec_priority_array(i, end); 52 | priority = exec_priority_array(i, end-1); 53 | finishTime_i = max(feasibleTime_vm(vm_index), max(DAG_edge(:,priority))) + exec_priority_array(i, 1); 54 | if eq(i, size(exec_priority_array, 1)) 55 | DAG_edge(priority,end) = finishTime_i; 56 | else 57 | DAG_edge(priority,:) = DAG_edge(priority,:)*finishTime_i; 58 | end 59 | feasibleTime_vm(vm_index) = finishTime_i; 60 | end 61 | responseTime = max(max(DAG_edge)); 62 | end --------------------------------------------------------------------------------