code in matlab for earliest deadline first schedule algorithm
#1

I want fuzzy logic in earliest deadline first algorithm
Reply
#2

code in matlab for earliest deadline first schedule algorithm

Abstract

Scheduling theory has been a popular discipline for a last couple of years. However, there is no tool, which can be used for a complex scheduling algorithms design and validation. Creation of this tool is our goal and its first preview is described in this paper. The tool is written in Matlab object oriented programming language and it is used in Matlab environment as a toolbox. Main objects are Task,TaskSet and Problem. Object Task is a data structure including all parameters of the task as process time, release date, deadline etc. Objects of a type Task can be grouped into a set of tasks and other related information as precedence constrains can be added. Object Problem is a small structure describing classification of deterministic scheduling problems in Graham and Błażewicz notation. These objects are used as a kernel providing general functions and graphical interface, making the toolbox easily extensible by other scheduling algorithms.

classdef Calculation
methods (Static)
%%%%%%%%%%%%%%%%%
% Calcul Factor %
%%%%%%%%%%%%%%%%%
function Factor=Calcul_Factor(Tasks_Param,Options)

%To use gcd and lcm on float, I try to find first the factor that I must
%use in order to have only integer
Factor=1;
Temp=roundn(max(max(mod([Tasks_Param.Tasks(:,Smile ones(Tasks_Param.Nb_Tasks,1)*Options.CST],ones(Tasks_Param.Nb_Tasks,5)))),Options.precision);
while Temp~=0
Factor = 10*Factor;
Tasks_Param.Tasks = Tasks_Param.Tasks*10;
Options.CST = Options.CST*10;
Temp=roundn(max(max(mod([Tasks_Param.Tasks(:,Smile ones(Tasks_Param.Nb_Tasks,1)*Options.CST],ones(Tasks_Param.Nb_Tasks,5)))),Options.precision);
end
end
%%%%%%%%%%%%%%%%%%%%%%%
% Calcul Step_Adviced %
%%%%%%%%%%%%%%%%%%%%%%%
function Step_Adviced=Calcul_Step_Adviced(Tasks_Param,Options)

Step_Adviced=1;
for i=1:1:Tasks_Param.Nb_Tasks
Step_Adviced=gcd(Step_Adviced,Options.Factor*Tasks_Param.Tasks(i,2));
end
Step_Adviced=gcd(Step_Adviced,Options.Factor*Options.CST);
Step_Adviced=Step_Adviced/Options.Factor;
end
%%%%%%%%%%%%%%%%%%%%%%
% Calcul Hyperperiod %
%%%%%%%%%%%%%%%%%%%%%%
function Hyperperiod=Calcul_Hyperperiod(Tasks_Param,Options)

Hyperperiod=1;
for i=1:1:Tasks_Param.Nb_Tasks
Hyperperiod=lcm(Hyperperiod,Options.Factor*Tasks_Param.Tasks(i,2));
end
Hyperperiod=Hyperperiod/Options.Factor;
end
%%%%%%%%%%%%%%%%%%%%%%
% Calcul RMS % Can be use either for Rate Monotonic Scheduling
% and DMS % or Deadline Monotonic Scheduling
% and EDF % or Earliest Deadline First Scheduling
% and LST % or Least Slack Time First Scheduling
%%%%%%%%%%%%%%%%%%%%%%

function [Trace Budget_Tasks Slack Aperiodic_Param Sporadic_Param]=Calcul_Schedule(Time,Tasks_Param,Aperiodic_Param,Sporadic_Param,Options)


Num_Task =(1:1:Tasks_Param.Nb_Tasks)';
Trace.Trace_Utilization_Global =zeros(1,length(Time)+1);
Trace.Trace_Utilization_Tasks =zeros(Tasks_Param.Nb_Tasks,length(Time)+1);
Trace.Trace_CST_Tasks =zeros(Tasks_Param.Nb_Tasks,length(Time)+Options.CST/Options.Step+1);
Trace.Trace_End_Tasks =zeros(Tasks_Param.Nb_Tasks,length(Time)+1);
Budget_Tasks =zeros(Tasks_Param.Nb_Tasks,length(Time)+1);
Budget_Tasks(:,1) =Tasks_Param.Tasks(:,3);
Budget_CST_Tasks =ones(Tasks_Param.Nb_Tasks,1)*2*Options.CST;
if strcmp(Aperiodic_Param.Server,'Sporadic')
Budget_CST_Tasks(Aperiodic_Param.Server_Status==1,1) =0;
end
Slack = zeros(Tasks_Param.Nb_Tasks,length(Time)+1);

Aperiodic_Param.WhoIsAperiodic_Used = zeros(1,length(Time)+1);
Aperiodic_Param.Budget_Aperiodic_Jobs = zeros(Aperiodic_Param.Nb_Aperiodic_Jobs,length(Time)+1);
Aperiodic_Param.Budget_Aperiodic_Jobs(:,1) = Aperiodic_Param.Aperiodic_Jobs(:,2);
Trace.Trace_Utilization_Aperiodic_Tasks = zeros(Aperiodic_Param.Nb_Aperiodic_Jobs,length(Time)+1);
Aperiodic_Param.Temp = zeros(1,length(Time)+1);
Aperiodic_Param.TempTb = zeros(1,length(Time)+1);
Aperiodic_Param.BEGIN = ones(1,length(Time)+1);
Aperiodic_Param.END = ones(1,length(Time)+1);
Aperiodic_Param.Tr = ones(1,length(Time)+1);
Aperiodic_Param.Tf = ones(1,length(Time)+1);
Aperiodic_Param.Te = ones(1,length(Time)+1);
Aperiodic_Param.Tb = ones(1,length(Time)+1)*length(Time);
Aperiodic_Param.Replenished = 0;
Sporadic_Param.Budget_Sporadic_Jobs = zeros(Sporadic_Param.Nb_Sporadic_Jobs,length(Time)+1);
Sporadic_Param.Budget_Sporadic_Jobs(:,1) = Sporadic_Param.Sporadic_Jobs(:,2);
Sporadic_Param.Slack = zeros(Sporadic_Param.Nb_Sporadic_Jobs,length(Time)+1);
Sporadic_Param.WhoIsSporadic_Used = zeros(1,length(Time)+1);
Sporadic_Param.Acceptance_Test = zeros(Sporadic_Param.Nb_Sporadic_Jobs,1);
Sporadic_Param.Jobs_Number = (1:1:Sporadic_Param.Nb_Sporadic_Jobs)';
Sporadic_Param.Jobs_Number_Ext = (1:1:Sporadic_Param.Nb_Sporadic_Jobs)';
Trace.Trace_Utilization_Sporadic_Tasks = zeros(Sporadic_Param.Nb_Sporadic_Jobs,length(Time)+1);
Options.CST_BEGIN = 0;
for t=1:1:length(Time)

Aperiodic_Param.WhoIsAperiodic_Used(t)=0;
Sporadic_Param.WhoIsSporadic_Used(t)=0;

if strcmp(Aperiodic_Param.Server,'Sporadic')

[Aperiodic_Param] = Calculation.Calcul_BEGIN(t,Time,Aperiodic_Param,Trace,Tasks_Param);
[Aperiodic_Param] = Calculation.Calcul_END(t,Options.Step,Time,Aperiodic_Param,Trace,Tasks_Param,Budget_Tasks);
[Aperiodic_Param] = Calculation.Calcul_TF(t,Time,Options.Step,Aperiodic_Param,Budget_Tasks,Tasks_Param.Tasks,Trace);

% %CONSUMPTION C2
[Budget_Tasks] = Calculation.Calcul_C2(t,Options.Step,Time,Aperiodic_Param,Budget_Tasks,Trace);

[Aperiodic_Param] = Calculation.Calcul_Tb(t,Time,Options.Step,Aperiodic_Param,Budget_Tasks,Tasks_Param,Trace);

% REPLENISHMENT (R2)
[Aperiodic_Param] = Calculation.Calcul_R2(t,Options.Step,Aperiodic_Param,Tasks_Param.Tasks);

% REPLENISHMENT (R3a)
[Aperiodic_Param] = Calculation.Calcul_R3a(t,Options.Step,Aperiodic_Param,Budget_Tasks,Tasks_Param.Tasks);

% % REPLENISHMENT (R3b)
[Aperiodic_Param Sporadic_Param] = Calculation.Calcul_R3b(t,Options.Step,Tasks_Param.Nb_Tasks,Time,Tasks_Param.Tasks,Slack,Aperiodic_Param,Sporadic_Param,Budget_Tasks,Budget_CST_Tasks,Trace,Options.CST,Options.schedule);
% % REPLENISHMENT (R1)
[Aperiodic_Param Budget_Tasks Budget_CST_Tasks] = Calculation.Calcul_R1(t,Options.CST,Aperiodic_Param,Budget_Tasks,Budget_CST_Tasks,Tasks_Param.Tasks);
if Aperiodic_Param.HasReplenished
[Aperiodic_Param] = Calculation.Calcul_TF(t,Time,Options.Step,Aperiodic_Param,Budget_Tasks,Tasks_Param.Tasks,Trace);
% REPLENISHMENT (R2)
[Aperiodic_Param] = Calculation.Calcul_R2(t,Options.Step,Aperiodic_Param,Tasks_Param.Tasks);
end
end
[Budget_Tasks Budget_CST_Tasks ...
Slack Aperiodic_Param Sporadic_Param] = ...
Calculation.Calcul_Replenishment(t,Options.Step,Tasks_Param.Nb_Tasks,Time,Tasks_Param.Tasks,...
Slack,Budget_Tasks,Budget_CST_Tasks,Aperiodic_Param,Sporadic_Param,Trace,Options.CST,Options.schedule);
if strcmp(Options.schedule,'RMS')|| strcmp(Options.schedule,'DMS')
Index_Sorting = 1;
Slack(:,1) = Tasks_Param.Tasks(:,2)*strcmp(Options.schedule,'RMS') + Tasks_Param.Tasks(:,4)*strcmp(Options.schedule,'DMS');
elseif strcmp(Options.schedule,'EDF')|| strcmp(Options.schedule,'LST')
Index_Sorting = t;
end
Tasks_Param.Tasks = Calculation.Calcul_Sort(Tasks_Param.Tasks,Slack,Num_Task,Index_Sorting);
Trace.Trace_Utilization_Tasks = Calculation.Calcul_Sort(Trace.Trace_Utilization_Tasks,Slack,Num_Task,Index_Sorting);
Trace.Trace_CST_Tasks = Calculation.Calcul_Sort(Trace.Trace_CST_Tasks,Slack,Num_Task,Index_Sorting);
Trace.Trace_End_Tasks = Calculation.Calcul_Sort(Trace.Trace_End_Tasks,Slack,Num_Task,Index_Sorting);
Budget_Tasks = Calculation.Calcul_Sort(Budget_Tasks,Slack,Num_Task,Index_Sorting);
Budget_CST_Tasks = Calculation.Calcul_Sort(Budget_CST_Tasks,Slack,Num_Task,Index_Sorting);
Aperiodic_Param.Server_Status = Calculation.Calcul_Sort(Aperiodic_Param.Server_Status,Slack,Num_Task,Index_Sorting);
Sporadic_Param.Server_Status = Calculation.Calcul_Sort(Sporadic_Param.Server_Status,Slack,Num_Task,Index_Sorting);
A1=sortrows([Slack Slack Num_Task],[size(Slack,2)+Index_Sorting size([Slack Slack Num_Task],2)]);
A2=sortrows([Num_Task Slack Num_Task],[size(Num_Task,2)+Index_Sorting size([Num_Task Slack Num_Task],2)]);
Slack=A1(:,1:end-size(Slack,2)-1);
Num_Task=A2(:,1:end-size(Slack,2)-1);


Aperiodic_Param.Budget_Aperiodic_Jobs(:,t+1)= Aperiodic_Param.Budget_Aperiodic_Jobs(:,t);
Sporadic_Param.Budget_Sporadic_Jobs(:,t+1)= Sporadic_Param.Budget_Sporadic_Jobs(:,t);
Slack(:,t+1) = Slack(:,t);
Sporadic_Param.Slack(:,t+1) = Sporadic_Param.Slack(:,t);
for i_Tasks=1:1:Tasks_Param.Nb_Tasks
Aperiodic_Param.Reset = 0;
Sporadic_Param.Reset = 0;
if Budget_Tasks(i_Tasks,t)>0
if Trace.Trace_Utilization_Global(t)==0 && (Time(t)>=Tasks_Param.Tasks(i_Tasks,1)||Options.TDA==1) % If the processor is Idle and the time> Tasks_Param.Tasks' phase. NOTE It is possible to remove the first condition to show how the processor is over utilized

if Aperiodic_Param.Server_Status(i_Tasks)==1
for i_Aperiodic_Jobs=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if(Trace.Trace_Utilization_Global(t)==0) && (Time(t)>=Aperiodic_Param.Aperiodic_Jobs(i_Aperiodic_Jobs,1)&& Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,t)~=0)
if (Budget_Tasks(i_Tasks,t)>roundn(Tasks_Param.Tasks(i_Tasks,3)-Options.CST,floor(log(Options.Step))) || Budget_CST_Tasks(i_Tasks)> Options.CST) && ~Options.CST_BEGIN && Trace.Trace_Utilization_Global(t)==0
Trace.Trace_CST_Tasks(i_Tasks,t)=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step)));
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; % with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
elseif Budget_Tasks(i_Tasks,t)>Options.CST && Trace.Trace_Utilization_Global(t)==0
Options.CST_BEGIN = 1;
Aperiodic_Param.Budget_Aperiodic_Jobs = Calculation.Calcul_Decrement(t,i_Aperiodic_Jobs,Options.Step,Aperiodic_Param.Budget_Aperiodic_Jobs);
Trace.Trace_Utilization_Aperiodic_Tasks(i_Aperiodic_Jobs,t)=Trace.Trace_Utilization_Aperiodic_Tasks(i_Aperiodic_Jobs,t)+1;
Trace.Trace_Utilization_Tasks(i_Tasks,t)=Trace.Trace_Utilization_Tasks(i_Tasks,t)+1;
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; % with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
end
Aperiodic_Param.WhoIsAperiodic_Used(t)=i_Aperiodic_Jobs;

else
if strcmp(Aperiodic_Param.Server,'Deferrable')
Aperiodic_Param.Budget_Aperiodic_Jobs(:,t+1)= Aperiodic_Param.Budget_Aperiodic_Jobs(:,t);
Budget_Tasks(:,t+1) = Budget_Tasks(:,t);
else
Aperiodic_Param.Reset = Aperiodic_Param.Reset+1;
end
end
end
if sum(Aperiodic_Param.Budget_Aperiodic_Jobs(:,t+1)) == 0 && sum(Aperiodic_Param.Budget_Aperiodic_Jobs(:,t)) ~= 0 && Budget_Tasks(i_Tasks,t) > 0 && Trace.Trace_Utilization_Global(t)==0 && strcmp(Aperiodic_Param.Server,'Deferrable')
Index_Forward=1;
while Index_Forward < Options.CST/Options.Step+1
Trace.Trace_CST_Tasks(i_Tasks,min(t+Index_Forward,length(Time)))=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step)));
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))=Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))+1;
Index_Forward=Index_Forward+1;
end
Budget_Tasks(i_Tasks,t) = 0 ;
Options.CST_BEGIN = 0;
end
if Aperiodic_Param.Reset == Aperiodic_Param.Nb_Aperiodic_Jobs && strcmp(Aperiodic_Param.Server,'Polling')
Budget_Tasks(i_Tasks,t) = 0;
end

elseif Sporadic_Param.Server_Status(i_Tasks)==1
for i_Sporadic_Jobs=1:1:Sporadic_Param.Nb_Sporadic_Jobs
if(Trace.Trace_Utilization_Global(t)==0) && Time(t)>=Sporadic_Param.Sporadic_Jobs(i_Sporadic_Jobs,1)&& Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,t)~=0 && Sporadic_Param.Acceptance_Test(i_Sporadic_Jobs)>0
if (Budget_Tasks(i_Tasks,t)>roundn(Tasks_Param.Tasks(i_Tasks,3)-Options.CST,floor(log(Options.Step))) || Budget_CST_Tasks(i_Tasks)> Options.CST) && Trace.Trace_Utilization_Global(t)==0
Trace.Trace_CST_Tasks(i_Tasks,t)=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step)));
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; % with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
elseif Budget_Tasks(i_Tasks,t)>Options.CST && Trace.Trace_Utilization_Global(t)==0
Sporadic_Param.Budget_Sporadic_Jobs = Calculation.Calcul_Decrement(t,i_Sporadic_Jobs,Options.Step,Sporadic_Param.Budget_Sporadic_Jobs);
Trace.Trace_Utilization_Sporadic_Tasks(i_Sporadic_Jobs,t)=Trace.Trace_Utilization_Sporadic_Tasks(i_Sporadic_Jobs,t)+1;
Trace.Trace_Utilization_Tasks(i_Tasks,t)=Trace.Trace_Utilization_Tasks(i_Tasks,t)+1;
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; % with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
end

Sporadic_Param.WhoIsSporadic_Used(t)=Sporadic_Param.Jobs_Number_Ext(i_Sporadic_Jobs);

end
end
for i_Sporadic_Jobs=1:1:Sporadic_Param.Nb_Sporadic_Jobs
if Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,t+1)==0 % Sporadic_Param.Acceptance_Test(i_Sporadic_Jobs,t)==1 &&
Sporadic_Param.Reset = Sporadic_Param.Reset+1;
end
end
if Sporadic_Param.Reset == Sporadic_Param.Nb_Sporadic_Jobs
Budget_Tasks(i_Tasks,t+1:end) = 0;
end
else
if Budget_Tasks(i_Tasks,t)>roundn(Tasks_Param.Tasks(i_Tasks,3)-Options.CST,floor(log(Options.Step))) && Trace.Trace_Utilization_Global(t)==0
Trace.Trace_CST_Tasks(i_Tasks,t)=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step)));
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; % with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
elseif Budget_Tasks(i_Tasks,t)>Options.CST && Trace.Trace_Utilization_Global(t)==0
Trace.Trace_Utilization_Tasks(i_Tasks,t)=Trace.Trace_Utilization_Tasks(i_Tasks,t)+1;
Budget_Tasks = Calculation.Calcul_Decrement(t,i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; % with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
end

end

if Budget_Tasks(i_Tasks,t)== Options.CST && Options.CST~=0
Index_Forward=0;
while Index_Forward < Options.CST/Options.Step+0
Trace.Trace_CST_Tasks(i_Tasks,min(t+Index_Forward,length(Time)))=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step)));
Budget_Tasks = Calculation.Calcul_Decrement(min(t+Index_Forward,length(Time)),i_Tasks,Options.Step,Budget_Tasks); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))=Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))+1;
Index_Forward=Index_Forward+1;
end
Budget_Tasks(i_Tasks,t+1:end) = 0;
end
else
Budget_Tasks(i_Tasks,t+1:end) = Budget_Tasks(i_Tasks,t);
end

end

end

if strcmp(Aperiodic_Param.Server,'Background')
[Aperiodic_Param Trace] = Calculation.Calcul_Background(t,Options.Step,Time,Aperiodic_Param,Trace);
end

end
for t=1:1:length(Time)
for i_Tasks=1:1:Tasks_Param.Nb_Tasks
Trace = Calculation.Calcul_Detection_End_Job(t,i_Tasks,Tasks_Param.Tasks,Budget_Tasks,Aperiodic_Param,Sporadic_Param,Trace,Options);
end
end
%% Sorting
Index_Sorting = 1;
Tasks_Param.Tasks = Calculation.Calcul_Sort(Tasks_Param.Tasks,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Trace.Trace_Utilization_Tasks = Calculation.Calcul_Sort(Trace.Trace_Utilization_Tasks,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Trace.Trace_CST_Tasks = Calculation.Calcul_Sort(Trace.Trace_CST_Tasks,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Trace.Trace_End_Tasks = Calculation.Calcul_Sort(Trace.Trace_End_Tasks,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Budget_Tasks = Calculation.Calcul_Sort(Budget_Tasks,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Budget_CST_Tasks = Calculation.Calcul_Sort(Budget_CST_Tasks,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Aperiodic_Param.Server_Status = Calculation.Calcul_Sort(Aperiodic_Param.Server_Status,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
Sporadic_Param.Server_Status = Calculation.Calcul_Sort(Sporadic_Param.Server_Status,zeros(Tasks_Param.Nb_Tasks,1),Num_Task,Index_Sorting);
A1=sortrows([Slack zeros(Tasks_Param.Nb_Tasks,1) Num_Task],size(Slack,2)+Index_Sorting+size(Num_Task,2));
A2=sortrows([Num_Task zeros(Tasks_Param.Nb_Tasks,1) Num_Task],size(Num_Task,2)+Index_Sorting+size(Num_Task,2));
Slack=A1(:,1:end-size(Num_Task,2)-1);
Num_Task=A2(:,1:end-size(Num_Task,2)-1);



end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Calcul Weighted Round-Robin Scheduling (WRRS) %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function Trace = Calcul_Schedule_WRRS(Time,Tasks_Param,Weight_Tasks,Options)


Trace.Trace_Utilization_Global=zeros(1,length(Time));
Trace.Trace_Utilization_Tasks=zeros(Tasks_Param.Nb_Tasks,length(Time));
Trace.Trace_End_Tasks=zeros(Tasks_Param.Nb_Tasks,length(Time));
Budget_Tasks=Tasks_Param.Tasks(:,3);
Time_Slice_Tasks=Weight_Tasks*Options.Step;
Temp=0; %Use to detect when the execution time finished. (This variable is used as a state variable)
for i_Tasks=1:1:Tasks_Param.Nb_Tasks
for t=1:1:length(Time)
if rem(Time(t),Tasks_Param.Tasks(i_Tasks,2))==0
Budget_Tasks(i_Tasks)=Tasks_Param.Tasks(i_Tasks,3); %Budget replenishment after every period
end
if rem(Time(t),Options.Step*sum(Weight_Tasks(Smile))==0
Time_Slice_Tasks(i_Tasks)=Weight_Tasks(i_Tasks)*Options.Step; %Budget replenishment every Nb_Tasks time slices
end
if (Budget_Tasks(i_Tasks)>0 && Time_Slice_Tasks(i_Tasks)>0)
if Trace.Trace_Utilization_Global(t)==0 % If the processor is Idle and the time> Tasks' phase. NOTE It is possible to remove the first condition to show how the processor is over utilized
if Time(t)>=Tasks_Param.Tasks(i_Tasks,1)
Budget_Tasks(i_Tasks)=roundn(Budget_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step))); % Theoritically same thing than Budget_Tasks(i_Tasks)-Step but problems
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1; %with the least significant bit causing a variation of +-1LSB for the variable Budget_Tasks
Trace.Trace_Utilization_Tasks(i_Tasks,t)=Trace.Trace_Utilization_Tasks(i_Tasks,t)+1;
Time_Slice_Tasks(i_Tasks)=roundn(Time_Slice_Tasks(i_Tasks)-Options.Step,floor(log(Options.Step)));
end
end
Temp=0;
elseif(Budget_Tasks(i_Tasks)<=0 && Temp==0) %Detection of when the budget reach 0 for each tasks
Trace.Trace_End_Tasks(i_Tasks,t)=1;
Temp=1;
else
Temp=1;
end

end
end
end

%Put other function below
function Utilization_Max=Calcul_Utilization_Max(Tasks_Param,Options)

switch Options.schedule
case{'RMS','DMS','EDF','LST'}
test_Simple_Periodic=0;
for i_Tasks=1:1:Tasks_Param.Nb_Tasks-1
test_Simple_Periodic=test_Simple_Periodic+mod(Tasks_Param.Tasks(i_Tasks+1,2),Tasks_Param.Tasks(i_Tasks,2));
end
if(test_Simple_Periodic==0) %Schedule is Simple Periodic
Utilization_Max=1;
else %Schedule is NOT Simple Periodic
Utilization_Max=Tasks_Param.Nb_Tasks*(2^(1/Tasks_Param.Nb_Tasks)-1);
end
otherwise
Utilization_Max='Not Relevant';

end

end

function Utilization=Calcul_Utilization(Tasks_Param,Options)

switch Options.schedule
case{'RMS','DMS','EDF','LST'}
Utilization=sum((Tasks_Param.Tasks(:,3)+2*Options.CST)./Tasks_Param.Tasks(:,2));

otherwise
Utilization='Not Relevant';
end

end
function Density=Calcul_Density(Tasks_Param,Options)

switch Options.schedule
case{'RMS','DMS','EDF','LST'}
Density=sum((Tasks_Param.Tasks(:,3)+2*Options.CST)./min(Tasks_Param.Tasks(:,2),Tasks_Param.Tasks(:,4)));
otherwise
Density='Not Relevant';

end

end

function Param_Sorted=Calcul_Sort(Param_To_Sort,Reference1,Reference2,t)
A=sortrows([Param_To_Sort Reference1 Reference2],[size(Param_To_Sort,2)+t size([Param_To_Sort Reference1 Reference2],2)]);
Param_Sorted=A(:,1:end-size(Reference1,2)-size(Reference2,2));
end

function [Budget_Tasks Budget_CST_Tasks Slack Aperiodic_Param Sporadic_Param] = Calcul_Replenishment(t,Step,Nb_Tasks,Time,Tasks,Slack,Budget_Tasks,Budget_CST_Tasks,Aperiodic_Param,Sporadic_Param,Trace,CST,schedule)

for i_Tasks=1:1:Nb_Tasks
if ~(strcmp(Aperiodic_Param.Server,'Sporadic') && Aperiodic_Param.Server_Status(i_Tasks)==1) % if it is not the sporadic server (aperiodic)
if rem(Time(t)-Tasks(i_Tasks,1),Tasks(i_Tasks,2))==0
if Aperiodic_Param.Server_Status(i_Tasks)==1 && ~strcmp(Aperiodic_Param.Server,'Deferrable')
Budget_Tasks(i_Tasks,t)=0+2*CST;
Budget_CST_Tasks(i_Tasks)=0;
for i_Aperiodic_Jobs=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if (Time(t)>=Aperiodic_Param.Aperiodic_Jobs(i_Aperiodic_Jobs,1)&& Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,t)~=0)
Budget_Tasks(i_Tasks,t)=roundn(min(Budget_Tasks(i_Tasks,t)+Aperiodic_Param.Aperiodic_Jobs(i_Aperiodic_Jobs,2),Tasks(i_Tasks,3)),floor(log(Step))); %Budget replenishment after every period
Budget_CST_Tasks(i_Tasks)=2*CST; %Budget for CST replenishment
end
end
else
Budget_Tasks(i_Tasks,t)=Tasks(i_Tasks,3)+0*CST; %Budget replenishment after every period
Budget_CST_Tasks(i_Tasks)=2*CST; %Budget for CST replenishment
end

if Sporadic_Param.Server && Sporadic_Param.Server_Status(i_Tasks)
Budget_Tasks(i_Tasks,t)=0+2*CST;
Budget_CST_Tasks(i_Tasks)=0;

for i_Sporadic_Jobs=1:1:Sporadic_Param.Nb_Sporadic_Jobs
if Time(t) >= Sporadic_Param.Sporadic_Jobs(i_Sporadic_Jobs,1) && Time(t) <= Sporadic_Param.Sporadic_Jobs(i_Sporadic_Jobs,3) && Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,t)>0

Sporadic_Param.Slack(i_Sporadic_Jobs,t)= floor((Sporadic_Param.Sporadic_Jobs(i_Sporadic_Jobs,3)-Time(t))/Tasks(i_Tasks,2))*Tasks(i_Tasks,3)-Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,t)...
-sum(Sporadic_Param.Budget_Sporadic_Jobs(:,t).*Sporadic_Param.Acceptance_Test(Smile)+Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,t).*Sporadic_Param.Acceptance_Test(i_Sporadic_Jobs);
else
Sporadic_Param.Slack(i_Sporadic_Jobs,t)= -1;
end
if Sporadic_Param.Slack(i_Sporadic_Jobs,t) >= 0
Sporadic_Param.Acceptance_Test(i_Sporadic_Jobs) = 1;
Budget_CST_Tasks(i_Tasks)=2*CST; %Budget for CST replenishment

else
Sporadic_Param.Acceptance_Test(i_Sporadic_Jobs) = 0;
end

end
Budget_Tasks(i_Tasks,t)=min(sum(Sporadic_Param.Budget_Sporadic_Jobs(:,t).*Sporadic_Param.Acceptance_Test),Tasks(i_Tasks,3)); %Budget replenishment after every period


end

end
if ~any(Sporadic_Param.Acceptance_Test(Smile)
Budget_CST_Tasks(Sporadic_Param.Server_Status==1) = 0;
end
end
if strcmp(schedule,'EDF')|| strcmp(schedule,'LST')
if Budget_Tasks(i_Tasks,t)~=0
Slack(i_Tasks,t)= floor(Time(t)./Tasks(i_Tasks,2)).*Tasks(i_Tasks,2)+Tasks(i_Tasks,4)-Time(t)-Budget_Tasks(i_Tasks,t)*strcmp(schedule,'LST');
else
Slack(i_Tasks,t)= 0;
end
end

end
end

function [Aperiodic_Param Trace] = Calcul_Background(t,Step,Time,Aperiodic_Param,Trace)
for i_Aperiodic_Jobs=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if(Trace.Trace_Utilization_Global(t)==0) && (Time(t)>=Aperiodic_Param.Aperiodic_Jobs(i_Aperiodic_Jobs,1)&& Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,t)~=0)
Aperiodic_Param.Budget_Aperiodic_Jobs = Calculation.Calcul_Decrement(t,i_Aperiodic_Jobs,Step,Aperiodic_Param.Budget_Aperiodic_Jobs);
Trace.Trace_Utilization_Global(t)=Trace.Trace_Utilization_Global(t)+1;
Trace.Trace_Utilization_Aperiodic_Tasks(i_Aperiodic_Jobs,t)=Trace.Trace_Utilization_Aperiodic_Tasks(i_Aperiodic_Jobs,t)+1;
end
end
end

function Trace = Calcul_Detection_End_Job(t,i_Tasks,Tasks,Budget_Tasks,Aperiodic_Param,Sporadic_Param,Trace,Options)
if Aperiodic_Param.Server_Status(i_Tasks)
for i_Aperiodic_Jobs=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if(Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,t)==0 && Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,max(1,t-1))~=0) %Detection of when the budget reach 0 for each tasks
Trace.Trace_End_Tasks(i_Tasks,t)=1;
end
end
elseif Sporadic_Param.Server_Status(i_Tasks)
for i_Sporadic_Jobs=1:1:Sporadic_Param.Nb_Sporadic_Jobs
if(Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,t)==0 && Sporadic_Param.Budget_Sporadic_Jobs(i_Sporadic_Jobs,max(1,t-1))~=0) %Detection of when the budget reach 0 for each tasks
Trace.Trace_End_Tasks(i_Tasks,t)=1;
end
end
else


if t>1 && Budget_Tasks(i_Tasks,max(1,t-1))~=0 && Budget_Tasks(i_Tasks,t)==Tasks(i_Tasks,3) && Trace.Trace_Utilization_Tasks(i_Tasks,max(1,t-1))~=0
Trace.Trace_End_Tasks(i_Tasks,t)=1;
end
if Budget_Tasks(i_Tasks,t)==Options.CST && Budget_Tasks(i_Tasks,max(1,t-1))~=Options.CST
% Budget_Tasks(i_Tasks,max(1,t-1))~=0 && Budget_Tasks(i_Tasks,t)==Tasks(i_Tasks,3) && Trace.Trace_Utilization_Tasks(i_Tasks,max(1,t-1))~=0 %Detection of when the budget reach 0 for each tasks
Trace.Trace_End_Tasks(i_Tasks,t)=1;
end
end
end

function [Trace Budget_CST_Tasks Aperiodic_Param Budget_Tasks] = Calcul_CST(Limit_Budget,CST,t,Step,Aperiodic_Param,Time,i_Tasks,Budget_Tasks,Trace,Budget_CST_Tasks)
if Aperiodic_Param.Server_Status(i_Tasks)==1 && Budget_CST_Tasks(i_Tasks)>CST && ~strcmp(Aperiodic_Param.Server,'Sporadic')
for i_Aperiodic_Jobs=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if(Trace.Trace_Utilization_Global(t)==0) && (Time(t)>=Aperiodic_Param.Aperiodic_Jobs(i_Aperiodic_Jobs,1)&& Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,t)~=0)
Index_Forward=0;
while Budget_CST_Tasks(i_Tasks)>Limit_Budget
Trace.Trace_CST_Tasks(i_Tasks,min(t+Index_Forward,length(Time)))=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Step,floor(log(Step)));
Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))=Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))+1;
Index_Forward=Index_Forward+1;
end
end
end
else
Index_Forward=0;
while Budget_CST_Tasks(i_Tasks)>Limit_Budget
Trace.Trace_CST_Tasks(i_Tasks,min(t+Index_Forward,length(Time)))=1;
Budget_CST_Tasks(i_Tasks)=roundn(Budget_CST_Tasks(i_Tasks)-Step,floor(log(Step)));
Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))=Trace.Trace_Utilization_Global(min(t+Index_Forward,length(Time)))+1;
Index_Forward=Index_Forward+1;
end
end

end

function A = Calcul_Decrement(t,i,Step,A)
A(i,t+1:end) = roundn( A(i,t)-Step,floor(log(Step)));
end
%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% END is the end of the latest busy interval in the above
% defined sequence if this interval ends before t and equal to
% its infinity if the interval ends after t
function [Aperiodic_Param] = Calcul_END(t,Step,Time,Aperiodic_Param,Trace,Tasks_Param,Budget_Tasks)
Aperiodic_Param.Temp = sum(Trace.Trace_Utilization_Tasks(1:max(find(Aperiodic_Param.Server_Status==1)-1,1),Smile,1);
Busy=0;
if t-2>0
for i_Tasks=1:1:max(find(Aperiodic_Param.Server_Status==1)-1)
if t<length(Time)
if rem(Time(t+1)-Tasks_Param.Tasks(i_Tasks,1),Tasks_Param.Tasks(i_Tasks,2))==0
Busy=1;
end
end
end
if sum(Budget_Tasks(1:max(find(Aperiodic_Param.Server_Status==1)-1,1),t),1)== Step && Busy==0
Aperiodic_Param.END(t:end) = t;
end
else
Aperiodic_Param.END(1:end) = 1;
end
end
%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% At any time t, BEGIN is the beginning instant of the earliest
% busy interval among the latest contiguous sequence of
% busy intervals of the higher priority subsystem T that
% started before t
function [Aperiodic_Param] = Calcul_BEGIN(t,Time,Aperiodic_Param,Trace,Tasks_Param)
Aperiodic_Param.Temp = sum(Trace.Trace_Utilization_Tasks(1:max(find(Aperiodic_Param.Server_Status==1)-1,1),Smile,1);
Busy=0;
if t-2>0

if Aperiodic_Param.Temp(t-1) ==0
for i_Tasks=1:1:max(find(Aperiodic_Param.Server_Status==1)-1)
if rem(Time(t)-Tasks_Param.Tasks(i_Tasks,1),Tasks_Param.Tasks(i_Tasks,2))==0
Busy=1;
end
end
end
if Busy==1
Aperiodic_Param.BEGIN(t:end) = t;
end

else
Aperiodic_Param.BEGIN(1:end) = 1;
end

end
%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% TF denotes the first instant after TR at which the
% server begins to execute
function [Aperiodic_Param] = Calcul_TF(t,Time,Step,Aperiodic_Param,Budget_Tasks,Tasks,Trace)
if t>1

Busy=0;
for i_Tasks=1:1:max(find(Aperiodic_Param.Server_Status==1)-1,1)% task above the server will replenish?
if rem(Time(t)-Tasks(i_Tasks,1),Tasks(i_Tasks,2))==0
Busy=1; % 1 Yes, 0 No
end
end
busy=0;

for i_Tasks=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if Aperiodic_Param.Budget_Aperiodic_Jobs(i_Tasks,t)>0 && Aperiodic_Param.Aperiodic_Jobs(i_Tasks,1)<=Time(t)
busy=1;
end
end
if sum(Budget_Tasks(1:max(find(Aperiodic_Param.Server_Status==1)-1,1),t),1) == 0 ...
&& Budget_Tasks((Aperiodic_Param.Server_Status==1),t) == Tasks((Aperiodic_Param.Server_Status==1),3) ...
&& busy==1 && Busy==0
Aperiodic_Param.Tf(t:end) = t;
end
else
Aperiodic_Param.Tf(t:end) = 1;
end

end

%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% Tb denotes the first instant where the system becomes busy again (after an idle period)
%
function [Aperiodic_Param] = Calcul_Tb(t,Time,Step,Aperiodic_Param,Budget_Tasks,Tasks_Param,Trace)
if t>1
Busy=0;
if sum(Trace.Trace_Utilization_Tasks(:,t-1),1)==0
for i_Tasks=1:1:Tasks_Param.Nb_Tasks
if i_Tasks == max(find(Aperiodic_Param.Server_Status==1),1)
%nothing
else
if rem(Time(t)-Tasks_Param.Tasks(i_Tasks,1),Tasks_Param.Tasks(i_Tasks,2))==0
if sum(Budget_Tasks(i_Tasks,t),1)==0
Busy=1;
end
end
end
end
if Busy==1
Aperiodic_Param.Tb(t:end) = t;
end

end
else
Aperiodic_Param.Tb(Smile = length(Time);
end
end

%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% R2 At time TF , if END = TF , TE = max(TR , BEGIN). If
% END < TF , TE = TF . The next replenishment time is
% set at TE + PERIOD
%TE denotes the latest effective replenishment time
function [Aperiodic_Param] = Calcul_R2(t,Step,Aperiodic_Param,Tasks)
if t-1>0
if Aperiodic_Param.Tf(t) == Aperiodic_Param.END(t)+1 && t==Aperiodic_Param.Tf(t)% (R2)
Aperiodic_Param.Te(t:end) = max(Aperiodic_Param.Tr(t),Aperiodic_Param.BEGIN(t));
Aperiodic_Param.Tr(t:end) = Aperiodic_Param.Te(t)+Tasks(Aperiodic_Param.Server_Status==1,2)/Step;%Aperiodic_Param.Next_Replenishment = Time(Aperiodic_Param.Te(t))+Tasks(Server_Status==1,2);
elseif Aperiodic_Param.Tf(t) > Aperiodic_Param.END(t)+1 && t==Aperiodic_Param.Tf(t)
Aperiodic_Param.Te(t:end) = Aperiodic_Param.Tf(t);
Aperiodic_Param.Tr(t:end) = Aperiodic_Param.Te(t)+Tasks(Aperiodic_Param.Server_Status==1,2)/Step;%Aperiodic_Param.Next_Replenishment = Time(Aperiodic_Param.Te(t))+Tasks(Server_Status==1,2);
end
else
Aperiodic_Param.Te(Smile=1;
Aperiodic_Param.Tr(Smile=1;
end
end
%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% R3 The next replenishment occurs at the next
% replenishment time, except under the following
% conditions. Under these conditions,
% replenishment is done at times stated below:
% ?(R3a) If the next replenishment time TE+PERIOD is earlier than TF ,
% the budget is replenished as soon as it is exhausted
% ?(R3b) If the system T becomes idle before the next
% replenishment time TE+PERIOD and becomes busy again at
% TB , the budget is replenished at min(TE+PERIOD,TB)

function [Aperiodic_Param Sporadic_Param] = Calcul_R3b(t,Step,Nb_Tasks,Time,Tasks,Slack,Aperiodic_Param,Sporadic_Param,Budget_Tasks,Budget_CST_Tasks,Trace,CST,schedule)
if t>1
Aperiodic_Param.TempTb = sum(Budget_Tasks(:,Smile,1) ; % 0 if system is idle
TEMP = Aperiodic_Param.Te(t)+Tasks(Aperiodic_Param.Server_Status==1,2)/Step; % TE+PERIOD
if Aperiodic_Param.TempTb(t)==0 && t < TEMP
Aperiodic_Param.Tr(t:end) = min(TEMP,Aperiodic_Param.Tb(t));
end
end
end

function [Aperiodic_Param] = Calcul_R3a(t,Step,Aperiodic_Param,Budget_Tasks,Tasks)
TEMP = Aperiodic_Param.Te(t)+Tasks(Aperiodic_Param.Server_Status==1,2)/Step; % TE+PERIOD
if TEMP < Aperiodic_Param.Tf(t) && Aperiodic_Param.Replenished == 0
Aperiodic_Param.Replenished = 1;
end

end

%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% CONSUMPTION C2
% At any time t after Tr , the servers execution budget
% is consumed at the rate of 1 per unit time until the
% budget is exhausted when either one of the
% following to conditions are true. When these
% conditions are not true, the server holds its budget:
% ? C1 The server is executing (rule followed by every tasks)
% ? C2 The server has executed since Tr and END < t
function [Budget_Tasks] = Calcul_C2(t,Step,Time,Aperiodic_Param,Budget_Tasks,Trace)
DECREMENT = 0;
Aperiodic_Jobs_On_Go=0;
Aperiodic_Jobs_Finished=0;
Aperiodic_Param.Temp = sum(Trace.Trace_Utilization_Tasks(1:max(find(Aperiodic_Param.Server_Status==1)-1,1),Smile,1);
if t>2
if Aperiodic_Param.Temp(t-1)==0
for i_Aperiodic_Jobs=1:1:Aperiodic_Param.Nb_Aperiodic_Jobs
if Time(t-1)>=Aperiodic_Param.Aperiodic_Jobs(i_Aperiodic_Jobs,1)
Aperiodic_Jobs_On_Go=Aperiodic_Jobs_On_Go+1;
if Aperiodic_Param.Budget_Aperiodic_Jobs(i_Aperiodic_Jobs,t-1)==0
Aperiodic_Jobs_Finished=Aperiodic_Jobs_Finished+1;
end
end
end
if Aperiodic_Jobs_Finished == Aperiodic_Jobs_On_Go && Aperiodic_Jobs_Finished~=0
DECREMENT = 1;
end
if (t>Aperiodic_Param.END(t) && DECREMENT && Budget_Tasks((Aperiodic_Param.Server_Status==1),t)>0)
Budget_Tasks((Aperiodic_Param.Server_Status==1),t:end) = roundn( Budget_Tasks((Aperiodic_Param.Server_Status==1),t-1)-Step,floor(log(Step)));
end
end
end
end

%%%%%%
% Reference: The course Embedded Software at the university of KTH
% (Stockholm, Sweden)
% Given by Ingo Sander :
% (http://web.it.kth.se/~ingo/)
% Website : http://ict.kth.se/courses/IL2212/1112/index.htm
%%%%%%
% REPLENISHMENT (R1)
% Initially when the system begins execution
% and each time when the budget is replenished
% TR denotes the latest actual replenishment time
function [Aperiodic_Param Budget_Tasks Budget_CST_Tasks] = Calcul_R1(t,CST,Aperiodic_Param,Budget_Tasks,Budget_CST_Tasks,Tasks)
Aperiodic_Param.HasReplenished = 0;
if Aperiodic_Param.Tr(t)==t || (Aperiodic_Param.Replenished == 1 && Budget_Tasks(Aperiodic_Param.Server_Status==1,t)==0 )
Budget_Tasks(Aperiodic_Param.Server_Status==1,t:end) = Tasks(Aperiodic_Param.Server_Status==1,3) + 0*CST;
Aperiodic_Param.Replenished = 0;
Aperiodic_Param.HasReplenished = 1;
end

end


end %END METHODS
end
Reply

Important Note..!

If you are not satisfied with above reply ,..Please

ASK HERE

So that we will collect data for you and will made reply to the request....OR try below "QUICK REPLY" box to add a reply to this page
Popular Searches: voters registration deadline, priority scheduling algorithm deadline, coding of deadline aware virtual machine scheduler for grid and cloud computing project, ismrm abstract deadline, application deadline for westfield, sum of, sensible thing,

[-]
Quick Reply
Message
Type your reply to this message here.

Image Verification
Please enter the text contained within the image into the text box below it. This process is used to prevent automated spam bots.
Image Verification
(case insensitive)

Possibly Related Threads...
Thread Author Replies Views Last Post
  image encryption and decryption using rsa algorithm in matlab 2 7,826 29-05-2017, 04:17 PM
Last Post: Priyanka Bidikar
  download liver tumor ct scan image in matlab with source code 4 7,983 21-05-2017, 09:54 PM
Last Post: abdulrahmanmashaal
  MATLAB codes needed for powerline communication 1 7,993 12-04-2017, 05:00 PM
Last Post: jaseela123d
  source code for task scheduling using genetic algorithm using java 2 8,444 11-04-2017, 08:31 PM
Last Post: Guest
  vhdl code for radix 2 modified booth algorithm 4 1,015 04-04-2017, 10:24 AM
Last Post: Garlapati nikitha
  matlab code for wavelet based ofdm transmitter 1 921 24-02-2017, 11:18 AM
Last Post: ijasti
  code to extract brain tumor detection using matlab 2 1,062 17-10-2016, 04:32 PM
Last Post: girish123ak
  secure chat using RSA algorithm karthik1218 2 2,576 14-10-2016, 02:48 PM
Last Post: info togel
  f5 algorithm steganography matlab code 2 863 04-10-2016, 03:00 AM
Last Post: [email protected]
  color image segmentation using jseg algorithm in matlab code 2 860 29-09-2016, 12:07 PM
Last Post: Guest

Forum Jump: