Commit 32126a75 authored by Felipe Cerqueira's avatar Felipe Cerqueira

Major Changes in RTA and Directory Structure

- Removed unnecessary assumption in RTA about task precedence/no intra-task parallelism.
- Scheduler models and analyses are organized in separate modules/folders.
- Added RTA for FP and EDF for schedulers with release jitter.
- The scheduling invariants were split into more fine-grained assumptions:
  (a) scheduler is work-conserving
  (b) scheduler enforces FP/JLDP priority X
- New helper lemmas about counting, and sorted/uniq lists
- Inclusion of tactics feed and feed_n (see documentation).
- Added a Makefile generator
parent d3e96fc8
......@@ -14,7 +14,7 @@
#
# This Makefile was generated by the command line :
# coq_makefile arrival_sequence.v bertogna_edf_comp.v bertogna_edf_theory.v bertogna_fp_comp.v bertogna_fp_theory.v interference_bound_edf.v interference.v job.v platform.v priority.v response_time.v schedulability.v schedule.v ssromega.v task_arrival.v task.v util_divround.v util_lemmas.v Vbase.v workload_bound.v workload.v
# coq_makefile -R . rt ./util/ssromega.v ./util/lemmas.v ./util/Vbase.v ./util/divround.v ./analysis/basic/bertogna_fp_theory.v ./analysis/basic/bertogna_edf_comp.v ./analysis/basic/bertogna_fp_comp.v ./analysis/basic/bertogna_edf_theory.v ./analysis/jitter/bertogna_fp_theory.v ./analysis/jitter/bertogna_edf_comp.v ./analysis/jitter/bertogna_fp_comp.v ./analysis/jitter/bertogna_edf_theory.v ./model/basic/schedulability.v ./model/basic/interference_bound_edf.v ./model/basic/task.v ./model/basic/interference_bound_fp.v ./model/basic/task_arrival.v ./model/basic/interference_bound.v ./model/basic/platform.v ./model/basic/schedule.v ./model/basic/priority.v ./model/basic/interference_edf.v ./model/basic/interference.v ./model/basic/workload.v ./model/basic/job.v ./model/basic/arrival_sequence.v ./model/basic/response_time.v ./model/basic/platform_fp.v ./model/basic/workload_bound.v ./model/jitter/schedulability.v ./model/jitter/interference_bound_edf.v ./model/jitter/task.v ./model/jitter/interference_bound_fp.v ./model/jitter/task_arrival.v ./model/jitter/interference_bound.v ./model/jitter/platform.v ./model/jitter/schedule.v ./model/jitter/priority.v ./model/jitter/interference_edf.v ./model/jitter/interference.v ./model/jitter/workload.v ./model/jitter/job.v ./model/jitter/arrival_sequence.v ./model/jitter/response_time.v ./model/jitter/platform_fp.v ./model/jitter/workload_bound.v -o Makefile
#
.DEFAULT_GOAL := all
......@@ -39,8 +39,8 @@ $(call includecmdwithout@,$(COQBIN)coqtop -config)
# #
##########################
COQLIBS?=-I .
COQDOCLIBS?=
COQLIBS?= -R . rt
COQDOCLIBS?=-R . rt
##########################
# #
......@@ -80,35 +80,57 @@ endif
# #
######################
VFILES:=arrival_sequence.v\
bertogna_edf_comp.v\
bertogna_edf_theory.v\
bertogna_fp_comp.v\
bertogna_fp_theory.v\
interference_bound_edf.v\
interference.v\
interference_edf.v\
job.v\
platform.v\
platform_edf.v\
priority.v\
response_time.v\
schedulability.v\
schedule.v\
ssromega.v\
task_arrival.v\
task.v\
util_divround.v\
util_lemmas.v\
Vbase.v\
workload_bound.v\
workload.v
VFILES:=util/ssromega.v\
util/lemmas.v\
util/Vbase.v\
util/divround.v\
analysis/basic/bertogna_fp_theory.v\
analysis/basic/bertogna_edf_comp.v\
analysis/basic/bertogna_fp_comp.v\
analysis/basic/bertogna_edf_theory.v\
analysis/jitter/bertogna_fp_theory.v\
analysis/jitter/bertogna_edf_comp.v\
analysis/jitter/bertogna_fp_comp.v\
analysis/jitter/bertogna_edf_theory.v\
model/basic/schedulability.v\
model/basic/interference_bound_edf.v\
model/basic/task.v\
model/basic/interference_bound_fp.v\
model/basic/task_arrival.v\
model/basic/interference_bound.v\
model/basic/platform.v\
model/basic/schedule.v\
model/basic/priority.v\
model/basic/interference_edf.v\
model/basic/interference.v\
model/basic/workload.v\
model/basic/job.v\
model/basic/arrival_sequence.v\
model/basic/response_time.v\
model/basic/platform_fp.v\
model/basic/workload_bound.v\
model/jitter/schedulability.v\
model/jitter/interference_bound_edf.v\
model/jitter/task.v\
model/jitter/interference_bound_fp.v\
model/jitter/task_arrival.v\
model/jitter/interference_bound.v\
model/jitter/platform.v\
model/jitter/schedule.v\
model/jitter/priority.v\
model/jitter/interference_edf.v\
model/jitter/interference.v\
model/jitter/workload.v\
model/jitter/job.v\
model/jitter/arrival_sequence.v\
model/jitter/response_time.v\
model/jitter/platform_fp.v\
model/jitter/workload_bound.v
-include $(addsuffix .d,$(VFILES))
.SECONDARY: $(addsuffix .d,$(VFILES))
VOFILES:=$(VFILES:.v=.vo)
VOFILESINC=$(filter $(wildcard ./*),$(VOFILES))
GLOBFILES:=$(VFILES:.v=.glob)
VIFILES:=$(VFILES:.v=.vi)
GFILES:=$(VFILES:.v=.g)
......@@ -178,15 +200,15 @@ userinstall:
+$(MAKE) USERINSTALL=true install
install:
install -d $(DSTROOT)$(COQLIBINSTALL)/$(INSTALLDEFAULTROOT); \
for i in $(VOFILESINC); do \
install -m 0644 $$i $(DSTROOT)$(COQLIBINSTALL)/$(INSTALLDEFAULTROOT)/`basename $$i`; \
for i in $(VOFILES); do \
install -d `dirname $(DSTROOT)$(COQLIBINSTALL)/rt/$$i`; \
install -m 0644 $$i $(DSTROOT)$(COQLIBINSTALL)/rt/$$i; \
done
install-doc:
install -d $(DSTROOT)$(COQDOCINSTALL)/$(INSTALLDEFAULTROOT)/html
install -d $(DSTROOT)$(COQDOCINSTALL)/rt/html
for i in html/*; do \
install -m 0644 $$i $(DSTROOT)$(COQDOCINSTALL)/$(INSTALLDEFAULTROOT)/$$i;\
install -m 0644 $$i $(DSTROOT)$(COQDOCINSTALL)/rt/$$i;\
done
clean:
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
coq_makefile -R . rt $(find -name "*.v" ! -name "*#*" ! -name "*eqdec*.v" -print) -o Makefile
......@@ -21,6 +21,10 @@ Tactics taken from the standard library of Viktor Vafeiadis.
- `exploit H`: When applied to a hypothesis/lemma H, converts pre-conditions into goals in order to infer the post-condition of H, which is then added to the local context.
- `feed H`: Same as exploit, but only generates a goal for the first pre-condition. That is, applying exploit to (H: P1 -> P2 -> P3) produces (H: P2 -> P3) and converts P1 into a goal. This is useful for cleaning up induction hypotheses.
- `feed_n k H`: Same as feed, but generates goals up to the k-th pre-condition.
- `specialize (H x1 x2 x3)`: instantiates hypothesis H in place with values x1, x2, x3.
*To be continued… please help out.*
......
Require Import Vbase job task util_lemmas
ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas rt.model.basic.job rt.model.basic.task.
Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
(* Definitions and properties of job arrival sequences. *)
Module ArrivalSequence.
......
Require Import Vbase task job schedule priority workload util_divround
util_lemmas ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas rt.util.divround.
Require Import rt.model.basic.task rt.model.basic.job rt.model.basic.schedule
rt.model.basic.priority rt.model.basic.workload.
Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Module Interference.
Import ScheduleOfSporadicTask Priority Workload.
Import Schedule ScheduleOfSporadicTask Priority Workload.
Section InterferingTasks.
Section PossibleInterferingTasks.
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
......@@ -15,25 +18,25 @@ Module Interference.
Section FP.
(* Assume an FP policy. *)
Variable higher_eq_priority: fp_policy sporadic_task.
Variable higher_eq_priority: FP_policy sporadic_task.
(* Then, tsk_other is said to interfere with tsk if it's a different
task with higher or equal priority. *)
Definition is_interfering_task_fp (tsk tsk_other: sporadic_task) :=
(* Under constrained dealdines, tsk_other can only interfere with tsk
if it's a different task with higher or equal priority. *)
Definition fp_can_interfere_with (tsk tsk_other: sporadic_task) :=
higher_eq_priority tsk_other tsk && (tsk_other != tsk).
End FP.
Section JLFP.
(* Under JLFP policies, any two different tasks can interfere with
(* Under JLFP/JLDP policies, any two different tasks can interfere with
each other. *)
Definition is_interfering_task_jlfp (tsk tsk_other: sporadic_task) :=
Definition jldp_can_interfere_with (tsk tsk_other: sporadic_task) :=
tsk_other != tsk.
End JLFP.
End InterferingTasks.
End PossibleInterferingTasks.
Section InterferenceDefs.
......
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import rt.model.basic.schedule rt.model.basic.workload_bound.
Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Module InterferenceBoundGeneric.
Section Definitions.
Import Schedule WorkloadBound.
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
Variable task_period: sporadic_task -> nat.
Variable task_deadline: sporadic_task -> nat.
(* Let tsk be the task to be analyzed. *)
Variable tsk: sporadic_task.
Let task_with_response_time := (sporadic_task * time)%type.
(* Assume a known response-time bound for each interfering task ... *)
Variable R_prev: seq task_with_response_time.
(* ... and an interval length delta. *)
Variable delta: time.
Section PerTask.
Variable tsk_R: task_with_response_time.
Let tsk_other := fst tsk_R.
Let R_other := snd tsk_R.
(* Based on the workload bound, Bertogna and Cirinei define the
following interference bound for a task. *)
Definition interference_bound_generic :=
minn (W task_cost task_period tsk_other R_other delta) (delta - (task_cost tsk) + 1).
End PerTask.
End Definitions.
End InterferenceBoundGeneric.
\ No newline at end of file
Require Import Vbase task job task_arrival schedule platform interference
workload workload_bound schedulability priority response_time
bertogna_fp_theory util_divround interference_edf util_lemmas
ssreflect ssrbool eqtype ssrnat seq fintype bigop div path.
(* In the following section, we define Bertogna and Cirinei's
EDF-specific per-task interference bound. *)
Module EDFSpecificBound.
Import Job SporadicTaskset ScheduleOfSporadicTask Schedulability ResponseTime
Priority SporadicTaskArrival Interference InterferenceEDF.
Section EDFBoundDef.
Add LoadPath "../.." as rt.
Require Import rt.util.Vbase rt.util.lemmas rt.util.divround.
Require Import rt.model.basic.task rt.model.basic.job rt.model.basic.schedule
rt.model.basic.task_arrival rt.model.basic.platform rt.model.basic.response_time
rt.model.basic.workload rt.model.basic.workload_bound rt.model.basic.priority
rt.model.basic.schedulability rt.model.basic.interference
rt.model.basic.interference_edf rt.model.basic.interference_bound.
Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop div path.
Module InterferenceBoundEDF.
Import Job SporadicTaskset Schedule ScheduleOfSporadicTask Schedulability
WorkloadBound ResponseTime Priority
SporadicTaskArrival Interference InterferenceEDF.
Export InterferenceBoundGeneric.
(* In this section, we define Bertogna and Cirinei's EDF-specific
interference bound. *)
Section SpecificBoundDef.
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
......@@ -37,9 +43,64 @@ Module EDFSpecificBound.
(div_floor d_tsk p_other) * e_other +
minn e_other ((d_tsk %% p_other) - (d_other - R_other)).
End EDFBoundDef.
End SpecificBoundDef.
(* Next, we define the total interference bound for EDF, which combines the generic
and the EDF-specific bounds. *)
Section TotalInterferenceBoundEDF.
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
Variable task_period: sporadic_task -> nat.
Variable task_deadline: sporadic_task -> nat.
(* Let tsk be the task to be analyzed. *)
Variable tsk: sporadic_task.
Let task_with_response_time := (sporadic_task * time)%type.
(* Assume a known response-time bound for each interfering task ... *)
Variable R_prev: seq task_with_response_time.
(* ... and an interval length delta. *)
Variable delta: time.
Section PerTask.
Section ProofInterferenceBound.
Variable tsk_R: task_with_response_time.
Let tsk_other := fst tsk_R.
Let R_other := snd tsk_R.
(* By combining Bertogna's interference bound for a work-conserving
scheduler ... *)
Let basic_interference_bound := interference_bound_generic task_cost task_period tsk delta tsk_R.
(* ... with and EDF-specific interference bound, ... *)
Let edf_specific_bound := edf_specific_interference_bound task_cost task_period task_deadline tsk tsk_other R_other.
(* Bertogna and Cirinei define the following interference bound
under EDF scheduling. *)
Definition interference_bound_edf :=
minn basic_interference_bound edf_specific_bound.
End PerTask.
Section AllTasks.
Let interferes_with_tsk := jldp_can_interfere_with tsk.
(* The total interference incurred by tsk is bounded by the sum
of individual task interferences. *)
Definition total_interference_bound_edf :=
\sum_((tsk_other, R_other) <- R_prev | interferes_with_tsk tsk_other)
interference_bound_edf (tsk_other, R_other).
End AllTasks.
End TotalInterferenceBoundEDF.
(* In this section, we show that the EDF-specific interference bound is safe. *)
Section ProofSpecificBound.
Import Schedule Interference Platform SporadicTaskset.
......@@ -96,12 +157,10 @@ Module EDFSpecificBound.
Let response_time_bounded_by (tsk: sporadic_task) :=
is_response_time_bound_of_task job_cost job_task tsk sched.
(* Assume that the schedule satisfies the global scheduling invariant
for EDF, i.e., if any job of tsk is backlogged, every processor
must be busy with jobs with no larger absolute deadline. *)
Let higher_eq_priority := @EDF Job arr_seq job_deadline. (* TODO: implicit params broken *)
Hypothesis H_global_scheduling_invariant:
JLFP_JLDP_scheduling_invariant_holds job_cost num_cpus sched higher_eq_priority.
(* Assume that the scheduler is a work-conserving EDF scheduler. *)
Hypothesis H_work_conserving: work_conserving job_cost sched.
Hypothesis H_edf_scheduler:
enforces_JLDP_policy job_cost sched (EDF job_deadline).
(* Let tsk_i be the task to be analyzed, ...*)
Variable tsk_i: sporadic_task.
......@@ -1055,6 +1114,60 @@ Module EDFSpecificBound.
End MainProof.
End ProofInterferenceBound.
End ProofSpecificBound.
(* As required by the proof of convergence of EDF RTA, we show that the
EDF-specific bound is monotonically increasing with both the size
of the interval and the value of the previous response-time bounds. *)
Section MonotonicitySpecificBound.
End EDFSpecificBound.
\ No newline at end of file
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
Variable task_period: sporadic_task -> nat.
Variable task_deadline: sporadic_task -> nat.
Variable tsk tsk_other: sporadic_task.
Hypothesis H_period_positive: task_period tsk_other > 0.
Variable delta delta' R R': time.
Hypothesis H_delta_monotonic: delta <= delta'.
Hypothesis H_response_time_monotonic: R <= R'.
Hypothesis H_cost_le_rt_bound: task_cost tsk_other <= R.
Lemma interference_bound_edf_monotonic :
interference_bound_edf task_cost task_period task_deadline tsk delta (tsk_other, R) <=
interference_bound_edf task_cost task_period task_deadline tsk delta' (tsk_other, R').
Proof.
rename H_response_time_monotonic into LEr, H_delta_monotonic into LEx,
H_cost_le_rt_bound into LEcost, H_period_positive into GEperiod.
unfold interference_bound_edf, interference_bound_generic.
rewrite leq_min; apply/andP; split.
{
rewrite leq_min; apply/andP; split.
apply leq_trans with (n := (minn (W task_cost task_period (fst (tsk_other, R))
(snd (tsk_other, R)) delta) (delta - task_cost tsk + 1)));
first by apply geq_minl.
apply leq_trans with (n := W task_cost task_period (fst (tsk_other, R))
(snd (tsk_other, R)) delta);
[by apply geq_minl | by apply W_monotonic].
apply leq_trans with (n := minn (W task_cost task_period (fst (tsk_other, R)) (snd (tsk_other, R)) delta) (delta - task_cost tsk + 1));
first by apply geq_minl.
apply leq_trans with (n := delta - task_cost tsk + 1);
first by apply geq_minr.
by rewrite leq_add2r leq_sub2r.
}
{
apply leq_trans with (n := edf_specific_interference_bound task_cost task_period
task_deadline tsk tsk_other R);
first by apply geq_minr.
unfold edf_specific_interference_bound; simpl.
rewrite leq_add2l leq_min; apply/andP; split; first by apply geq_minl.
apply leq_trans with (n := task_deadline tsk %% task_period tsk_other -
(task_deadline tsk_other - R));
[by apply geq_minr | by rewrite 2?leq_sub2l 2?leq_sub2r // leq_sub2l].
}
Qed.
End MonotonicitySpecificBound.
End InterferenceBoundEDF.
\ No newline at end of file
Add LoadPath "../.." as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import rt.model.basic.schedule rt.model.basic.priority rt.model.basic.workload
rt.model.basic.workload_bound rt.model.basic.interference
rt.model.basic.interference_bound.
Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Module InterferenceBoundFP.
Import Schedule WorkloadBound Priority Interference.
Export InterferenceBoundGeneric.
Section Definitions.
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
Variable task_period: sporadic_task -> nat.
Variable task_deadline: sporadic_task -> nat.
(* Let tsk be the task to be analyzed. *)
Variable tsk: sporadic_task.
Let task_with_response_time := (sporadic_task * time)%type.
(* Assume a known response-time bound for each interfering task ... *)
Variable R_prev: seq task_with_response_time.
(* ... and an interval length delta. *)
Variable delta: time.
(* Assume an FP policy. *)
Variable higher_eq_priority: FP_policy sporadic_task.
Let can_interfere_with_tsk := fp_can_interfere_with higher_eq_priority tsk.
Let total_interference_bound := interference_bound_generic task_cost task_period tsk delta.
(* The total interference incurred by tsk is bounded by the sum
of individual task interferences. *)
Definition total_interference_bound_fp :=
\sum_((tsk_other, R_other) <- R_prev | can_interfere_with_tsk tsk_other)
total_interference_bound (tsk_other, R_other).
End Definitions.
End InterferenceBoundFP.
\ No newline at end of file
Require Import Vbase task schedule job priority interference task_arrival
arrival_sequence platform util_lemmas
ssreflect ssrbool ssrfun eqtype ssrnat seq fintype bigop.
Add LoadPath "../.." as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import rt.model.basic.task rt.model.basic.job rt.model.basic.schedule
rt.model.basic.priority rt.model.basic.task_arrival rt.model.basic.interference
rt.model.basic.arrival_sequence rt.model.basic.platform.
Require Import ssreflect ssrbool ssrfun eqtype ssrnat seq fintype bigop.
Module InterferenceEDF.
Import Schedule Priority Platform Interference.
Import Schedule Priority Platform Interference Priority.
Section Lemmas.
......@@ -22,9 +25,8 @@ Module InterferenceEDF.
(* Assume that the schedule satisfies the global scheduling invariant
for EDF, i.e., if any job of tsk is backlogged, every processor
must be busy with jobs with no larger absolute deadline. *)
Let higher_eq_priority := @EDF Job arr_seq job_deadline. (* TODO: implicit params broken *)
Hypothesis H_global_scheduling_invariant:
JLFP_JLDP_scheduling_invariant_holds job_cost num_cpus sched higher_eq_priority.
Hypothesis H_scheduler_uses_EDF:
enforces_JLDP_policy job_cost sched (EDF job_deadline).
(* Under EDF scheduling, a job only causes interference if its deadline
is not larger than the deadline of the analyzed job. *)
......@@ -33,17 +35,14 @@ Module InterferenceEDF.
job_interference job_cost sched j' j t1 t2 != 0 ->
job_arrival j + job_deadline j <= job_arrival j' + job_deadline j'.
Proof.
rename H_global_scheduling_invariant into INV.
clear - INV.
rename H_scheduler_uses_EDF into PRIO.
intros j j' t1 t2 INTERF.
unfold job_interference in INTERF.
destruct ([exists t': 'I_t2, (t' >= t1) && backlogged job_cost sched j' t' &&
scheduled sched j t']) eqn:EX.
{
move: EX => /existsP EX; destruct EX as [t' EX];move: EX => /andP [/andP [LE BACK] SCHED].
eapply interfering_job_has_higher_eq_prio in BACK;
[ | by apply INV | by apply SCHED].
by apply BACK.
by eapply PRIO in SCHED; last by apply BACK.
}
{
apply negbT in EX; rewrite negb_exists in EX; move: EX => /forallP ALL.
......
Require Import task util_lemmas ssrnat ssrbool eqtype.
Add LoadPath "../../" as rt.
Require Import rt.model.basic.task rt.util.lemmas.
Require Import ssrnat ssrbool eqtype.
(* Properties of different types of job: *)
Module Job.
......@@ -65,32 +67,4 @@ Module Job.
End ValidSporadicTaskJob.
(* 4) Job of sporadic task with jitter *)
Section ValidSporadicTaskJobWithJitter.
Context {sporadic_task: eqType}.
Variable task_cost: sporadic_task -> nat.
Variable task_deadline: sporadic_task -> nat.
Variable task_jitter: sporadic_task -> nat.
Context {Job: eqType}.
Variable job_cost: Job -> nat.
Variable job_deadline: Job -> nat.
Variable job_task: Job -> sporadic_task.
Variable job_jitter: Job -> nat.
Variable j: Job.
(* The job jitter cannot be larger than the task (maximum) jitter.*)
Definition job_jitter_leq_task_jitter :=
job_jitter j <= task_jitter (job_task j).
Let j_is_valid_job :=
valid_sporadic_job task_cost task_deadline job_cost job_deadline job_task j.
Definition valid_sporadic_job_with_jitter :=
j_is_valid_job /\ job_jitter_leq_task_jitter.
End ValidSporadicTaskJobWithJitter.
End Job.
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Require Import Vbase task job task_arrival schedule util_lemmas
ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import rt.model.basic.task rt.model.basic.job rt.model.basic.task_arrival
rt.model.basic.schedule.
Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
(* Definition of response-time bound and some simple lemmas. *)
Module ResponseTime.
......
Require Import Vbase job task schedule util_lemmas
ssreflect eqtype ssrbool ssrnat seq bigop.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import rt.model.basic.job rt.model.basic.task rt.model.basic.schedule.
Require Import ssreflect eqtype ssrbool ssrnat seq bigop.
(* Definitions of deadline miss. *)
Module Schedulability.
......
This diff is collapsed.
Require Import Vbase util_lemmas ssrnat ssrbool eqtype fintype seq.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import ssrnat ssrbool eqtype fintype seq.
(* Attributes of a valid sporadic task. *)
Module SporadicTask.
......
Require Import Vbase task job schedule util_lemmas
ssreflect ssrbool eqtype ssrnat seq fintype bigop.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas.
Require Import rt.model.basic.task rt.model.basic.job rt.model.basic.schedule.
Require Import ssreflect ssrbool eqtype ssrnat seq.
(* Properties of the job arrival. *)
Module SporadicTaskArrival.
......
Require Import Vbase job task schedule task_arrival response_time
schedulability util_divround util_lemmas
ssreflect ssrbool eqtype ssrnat seq div fintype bigop path.
Add LoadPath "../../" as rt.
Require Import rt.util.Vbase rt.util.lemmas rt.util.divround.
Require Import rt.model.basic.job rt.model.basic.task rt.model.basic.schedule
rt.model.basic.task_arrival rt.model.basic.response_time
rt.model.basic.schedulability.
Require Import ssreflect ssrbool eqtype ssrnat seq div fintype bigop path.
Module Workload.
Import Job SporadicTaskset ScheduleOfSporadicTask SporadicTaskArrival ResponseTime Schedulability.
Import Job SporadicTaskset Schedule ScheduleOfSporadicTask SporadicTaskArrival ResponseTime Schedulability.
(* Let's define the workload. *)
Section WorkloadDef.
......
Add LoadPath "../../" as rt.
(* All definitions from arrival sequence can be safely imported. *)
Require Export rt.model.basic.arrival_sequence.
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Add LoadPath "../../" as rt.
(* Because we define EDF using the *original job arrivals*, we can safely import the
definitions. *)
Require Export rt.model.basic.priority.
\ No newline at end of file
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.