Commit 064a1c75 authored by Björn Brandenburg's avatar Björn Brandenburg

re-organization of the analysis module, part 1

This is not yet the final organization, but already an improvement.

Move main high-level results to separate top-level `results` module.
Rationale: Let's make it very clear where to find the main, high-level
results in Prosa, and at the same time let's declutter the analysis
namespace.

Other notable change, apart from moving files around:

- move two key analysis definitions to analysis.definitions
- split RBF definition and facts into separate files
- move facts about ideal schedule to ideal_schedule.v
parent ddcd2790
Require Export rt.restructuring.analysis.schedulability.
Require Export rt.restructuring.analysis.abstract.core.reduction_of_search_space.
Require Export rt.restructuring.analysis.abstract.core.sufficient_condition_for_run_to_completion_threshold.
Require Export rt.restructuring.analysis.concepts.schedulability.
Require Export rt.restructuring.analysis.abstract.search_space.
Require Export rt.restructuring.analysis.abstract.run_to_completion.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
......
Require Export rt.restructuring.analysis.task_schedule.
Require Export rt.restructuring.analysis.arrival.rbf.
Require Export rt.restructuring.analysis.basic_facts.task_arrivals.
Require Export rt.restructuring.analysis.abstract.core.abstract_rta.
Require Export rt.restructuring.analysis.definitions.task_schedule.
Require Export rt.restructuring.analysis.facts.rbf.
Require Export rt.restructuring.analysis.facts.behavior.task_arrivals.
Require Export rt.restructuring.analysis.abstract.abstract_rta.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
......
Require Export rt.restructuring.analysis.definitions.priority_inversion.
Require Export rt.restructuring.analysis.abstract.core.abstract_seq_rta.
Require Export rt.restructuring.analysis.concepts.priority_inversion.
Require Export rt.restructuring.analysis.abstract.abstract_seq_rta.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
(** In this file we consider an ideal uni-processor ... *)
......
Require Export rt.restructuring.analysis.basic_facts.preemption.rtc_threshold.job_preemptable.
Require Export rt.restructuring.analysis.abstract.core.definitions.
Require Export rt.restructuring.analysis.facts.preemption.rtc_threshold.job_preemptable.
Require Export rt.restructuring.analysis.abstract.definitions.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
......
Require Export rt.restructuring.analysis.definitions.job_properties.
Require Export rt.restructuring.analysis.arrival.workload_bound.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
(** * Request Bound Functions (RBF) *)
(** In this section, we prove some properties of Request Bound Functions (RBF). *)
Section RequestBoundFunctions.
(** Consider any type of tasks ... *)
Context {Task : TaskType}.
Context `{TaskCost Task}.
(** ... and any type of jobs associated with these tasks. *)
Context {Job : JobType}.
Context `{JobTask Job Task}.
Context `{JobArrival Job}.
(** Consider any arrival sequence. *)
Variable arr_seq : arrival_sequence Job.
Hypothesis H_arrival_times_are_consistent:
consistent_arrival_times arr_seq.
(** Let tsk be any task. *)
Variable tsk : Task.
(** Let max_arrivals be a family of valid arrival curves, i.e., for any task tsk in ts
[max_arrival tsk] is (1) an arrival bound of tsk, and (2) it is a monotonic function
that equals 0 for the empty interval delta = 0. *)
Context `{MaxArrivals Task}.
Hypothesis H_valid_arrival_curve : valid_arrival_curve tsk (max_arrivals tsk).
Hypothesis H_is_arrival_curve : respects_max_arrivals arr_seq tsk (max_arrivals tsk).
(** Let's define some local names for clarity. *)
Let task_rbf := task_request_bound_function tsk.
(** We prove that [task_rbf 0] is equal to 0. *)
Lemma task_rbf_0_zero:
task_rbf 0 = 0.
Proof.
rewrite /task_rbf /task_request_bound_function.
apply/eqP; rewrite muln_eq0; apply/orP; right; apply/eqP.
by move: H_valid_arrival_curve => [T1 T2].
Qed.
(** We prove that task_rbf is monotone. *)
Lemma task_rbf_monotone:
monotone task_rbf leq.
Proof.
rewrite /monotone; intros ? ? LE.
rewrite /task_rbf /task_request_bound_function leq_mul2l.
apply/orP; right.
by move: H_valid_arrival_curve => [_ T]; apply T.
Qed.
(** Consider any job j of tsk. This guarantees that
there exists at least one job of task tsk. *)
Variable j : Job.
Hypothesis H_j_arrives : arrives_in arr_seq j.
Hypothesis H_job_of_tsk : job_task j = tsk.
(** Then we prove that task_rbf 1 is greater than or equal to task cost. *)
Lemma task_rbf_1_ge_task_cost:
task_rbf 1 >= task_cost tsk.
Proof.
have ALT: forall n, n = 0 \/ n > 0.
{ by clear; intros n; destruct n; [left | right]. }
specialize (ALT (task_cost tsk)); destruct ALT as [Z | POS]; first by rewrite Z.
rewrite leqNgt; apply/negP; intros CONTR.
move: H_is_arrival_curve => ARRB.
specialize (ARRB (job_arrival j) (job_arrival j + 1)).
feed ARRB; first by rewrite leq_addr.
rewrite addKn in ARRB.
move: CONTR; rewrite /task_rbf /task_request_bound_function; move => CONTR.
move: CONTR; rewrite -{2}[task_cost tsk]muln1 ltn_mul2l; move => /andP [_ CONTR].
move: CONTR; rewrite -addn1 -{3}[1]add0n leq_add2r leqn0; move => /eqP CONTR.
move: ARRB; rewrite CONTR leqn0 eqn0Ngt; move => /negP T; apply: T.
rewrite /number_of_task_arrivals -has_predT.
rewrite /task_arrivals_between.
apply/hasP; exists j; last by done.
rewrite /arrivals_between addn1 big_nat_recl; last by done.
rewrite big_geq ?cats0; last by done.
rewrite mem_filter.
apply/andP; split.
- by apply/eqP.
- move: H_j_arrives => [t ARR].
move: (ARR) => CONS.
apply H_arrival_times_are_consistent in CONS.
by rewrite CONS.
Qed.
End RequestBoundFunctions.
\ No newline at end of file
This diff is collapsed.
Require Export rt.restructuring.analysis.basic_facts.service.
Require Export rt.restructuring.analysis.basic_facts.service_of_jobs.
Require Export rt.restructuring.analysis.basic_facts.completion.
Require Export rt.restructuring.analysis.basic_facts.ideal_schedule.
Require Export rt.restructuring.analysis.basic_facts.sequential.
Require Export rt.restructuring.analysis.basic_facts.arrivals.
Require Export rt.restructuring.analysis.basic_facts.deadlines.
Require Export rt.restructuring.analysis.basic_facts.workload.
Require Export rt.restructuring.model.priority.classes.
Require Export rt.restructuring.analysis.basic_facts.completion.
Require Export rt.restructuring.analysis.facts.behavior.completion.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
(** Throughout this file, we assume ideal uniprocessor schedules. *)
......
Require Export rt.restructuring.analysis.definitions.busy_interval.
Require Export rt.restructuring.analysis.concepts.busy_interval.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
......
Require Export rt.restructuring.model.arrival.arrival_curves.
Require Export rt.restructuring.model.priority.classes.
(** The following definitions assume ideal uniprocessor schedules. This
restriction exists for historic reasons; the defined concepts could be
generalized in future work. *)
Require Import rt.restructuring.analysis.facts.behavior.ideal_schedule.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.
(** * Request Bound Function (RBF) *)
(** We define the notion of a task's request-bound function (RBF), as well as
the total request bound function of a set of tasks. *)
Section TaskWorkloadBoundedByArrivalCurves.
(** Consider any type of tasks ... *)
Context {Task : TaskType}.
Context `{TaskCost Task}.
(** ... and any type of jobs associated with these tasks, where each task has
a cost. *)
Context {Job : JobType}.
Context `{JobTask Job Task}.
Context `{JobCost Job}.
(** Consider any ideal uniprocessor schedule of these jobs... *)
Variable sched : schedule (ideal.processor_state Job).
(** ... and an FP policy that indicates a higher-or-equal priority
relation. *)
Variable higher_eq_priority : FP_policy Task.
(** Let MaxArrivals denote any function that takes a task and an interval length
and returns the associated number of job arrivals of the task. *)
Context `{MaxArrivals Task}.
(** ** RBF of a Single Task *)
(** In this section, we define a bound for the workload of a single task
under uniprocessor FP scheduling. *)
Section SingleTask.
(** Consider any task tsk that is to be scheduled in an interval of length delta. *)
Variable tsk : Task.
Variable delta : duration.
(** We define the following workload bound for the task. *)
Definition task_request_bound_function := task_cost tsk * max_arrivals tsk delta.
End SingleTask.
(** ** Total RBF of Multiple Tasks *)
(** In this section, we define a bound for the workload of multiple tasks. *)
Section AllTasks.
(** Consider a task set ts... *)
Variable ts : list Task.
(** ...and let tsk be any task in task set. *)
Variable tsk : Task.
(** Let delta be the length of the interval of interest. *)
Variable delta : duration.
(** Recall the definition of higher-or-equal-priority task and the per-task
workload bound for FP scheduling. *)
Let is_hep_task tsk_other := higher_eq_priority tsk_other tsk.
Let is_other_hep_task tsk_other := higher_eq_priority tsk_other tsk && (tsk_other != tsk).
(** Using the sum of individual workload bounds, we define the following
bound for the total workload of tasks in any interval of length
delta. *)
Definition total_request_bound_function :=
\sum_(tsk <- ts) task_request_bound_function tsk delta.
(** Similarly, we define the following bound for the total workload of
tasks of higher-or-equal priority (with respect to tsk) in any interval
of length delta. *)
Definition total_hep_request_bound_function_FP :=
\sum_(tsk_other <- ts | is_hep_task tsk_other)
task_request_bound_function tsk_other delta.
(** We also define a bound for the total workload of higher-or-equal
priority tasks other than tsk in any interval of length delta. *)
Definition total_ohep_request_bound_function_FP :=
\sum_(tsk_other <- ts | is_other_hep_task tsk_other)
task_request_bound_function tsk_other delta.
End AllTasks.
End TaskWorkloadBoundedByArrivalCurves.
Require Export rt.restructuring.analysis.basic_facts.completion.
Require Export rt.restructuring.analysis.facts.behavior.completion.
Require Import rt.restructuring.model.task.absolute_deadline.
Section Task.
......
Require Export rt.restructuring.model.task.concept.
Require Export rt.restructuring.analysis.basic_facts.ideal_schedule.
Require Export rt.restructuring.analysis.facts.behavior.ideal_schedule.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
......
Require Export rt.restructuring.analysis.facts.behavior.service.
Require Export rt.restructuring.analysis.facts.behavior.service_of_jobs.
Require Export rt.restructuring.analysis.facts.behavior.completion.
Require Export rt.restructuring.analysis.facts.behavior.ideal_schedule.
Require Export rt.restructuring.analysis.facts.behavior.sequential.
Require Export rt.restructuring.analysis.facts.behavior.arrivals.
Require Export rt.restructuring.analysis.facts.behavior.deadlines.
Require Export rt.restructuring.analysis.facts.behavior.workload.
Require Export rt.restructuring.analysis.basic_facts.service.
Require Export rt.restructuring.analysis.basic_facts.arrivals.
Require Export rt.restructuring.analysis.facts.behavior.service.
Require Export rt.restructuring.analysis.facts.behavior.arrivals.
(** In this file, we establish basic facts about job completions. *)
......
Require Export rt.restructuring.analysis.basic_facts.completion.
Require Export rt.restructuring.analysis.facts.behavior.completion.
(** In this file, we observe basic properties of the behavioral job
model w.r.t. deadlines. *)
......
From mathcomp Require Import all_ssreflect.
Require Export rt.util.all.
Require Export rt.restructuring.model.processor.platform_properties.
Require Export rt.restructuring.analysis.facts.behavior.service.
(** Throughout this file, we assume ideal uniprocessor schedules. *)
Require Import rt.restructuring.model.processor.ideal.
......@@ -111,3 +113,110 @@ Ltac ideal_proc_model_sched_case_analysis_eq sched t JobName :=
destruct (ideal_proc_model_sched_case_analysis sched t) as [Idle | [JobName Sched]];
[move: (Idle) => /eqP IdleEq; rewrite ?IdleEq
| move: (Sched); simpl; move => /eqP SchedEq; rewrite ?SchedEq].
(** * Incremental Service in Ideal Schedule *)
(** In the following section we prove a few facts about service in ideal schedeule. *)
(* Note that these lemmas can be generalized to an arbitrary scheduler. *)
Section IncrementalService.
(** Consider any job type, ... *)
Context {Job : JobType}.
Context `{JobArrival Job}.
Context `{JobCost Job}.
(** ... any arrival sequence, ... *)
Variable arr_seq : arrival_sequence Job.
(** ... and any ideal uniprocessor schedule of this arrival sequence. *)
Variable sched : schedule (ideal.processor_state Job).
(** As a base case, we prove that if a job j receives service in
some time interval [t1,t2), then there exists a time instant t
∈ [t1,t2) such that j is scheduled at time t and t is the first
instant where j receives service. *)
Lemma positive_service_during:
forall j t1 t2,
0 < service_during sched j t1 t2 ->
exists t : nat, t1 <= t < t2 /\ scheduled_at sched j t /\ service_during sched j t1 t = 0.
Proof.
intros j t1 t2 SERV.
have LE: t1 <= t2.
{ rewrite leqNgt; apply/negP; intros CONTR.
by apply ltnW in CONTR; move: SERV; rewrite /service_during big_geq.
}
destruct (scheduled_at sched j t1) eqn:SCHED.
{ exists t1; repeat split; try done.
- apply/andP; split; first by done.
rewrite ltnNge; apply/negP; intros CONTR.
by move: SERV; rewrite/service_during big_geq.
- by rewrite /service_during big_geq.
}
{ apply negbT in SCHED.
move: SERV; rewrite /service /service_during; move => /sum_seq_gt0P [t [IN SCHEDt]].
rewrite lt0b in SCHEDt.
rewrite mem_iota subnKC in IN; last by done.
move: IN => /andP [IN1 IN2].
move: (exists_first_intermediate_point
((fun t => scheduled_at sched j t)) t1 t IN1 SCHED) => A.
feed A; first by rewrite scheduled_at_def/=.
move: A => [x [/andP [T1 T4] [T2 T3]]].
exists x; repeat split; try done.
- apply/andP; split; first by apply ltnW.
by apply leq_ltn_trans with t.
- apply/eqP; rewrite big_nat_cond big1 //.
move => y /andP [T5 _].
by apply/eqP; rewrite eqb0; specialize (T2 y); rewrite scheduled_at_def/= in T2; apply T2.
}
Qed.
(** Next, we prove that if in some time interval [t1,t2) a job j
receives k units of service, then there exists a time instant t ∈
[t1,t2) such that j is scheduled at time t and service of job j
within interval [t1,t) is equal to k. *)
Lemma incremental_service_during:
forall j t1 t2 k,
service_during sched j t1 t2 > k ->
exists t, t1 <= t < t2 /\ scheduled_at sched j t /\ service_during sched j t1 t = k.
Proof.
intros j t1 t2 k SERV.
have LE: t1 <= t2.
{ rewrite leqNgt; apply/negP; intros CONTR.
by apply ltnW in CONTR; move: SERV; rewrite /service_during big_geq.
}
induction k; first by apply positive_service_during in SERV.
feed IHk; first by apply ltn_trans with k.+1.
move: IHk => [t [/andP [NEQ1 NEQ2] [SCHEDt SERVk]]].
have SERVk1: service_during sched j t1 t.+1 = k.+1.
{ rewrite -(service_during_cat _ _ _ t); last by apply/andP; split.
rewrite SERVk -[X in _ = X]addn1; apply/eqP; rewrite eqn_add2l.
by rewrite /service_during big_nat1 /service_at eqb1 -scheduled_at_def/=.
}
move: SERV; rewrite -(service_during_cat _ _ _ t.+1); last first.
{ by apply/andP; split; first apply leq_trans with t. }
rewrite SERVk1 -addn1 leq_add2l; move => SERV.
destruct (scheduled_at sched j t.+1) eqn:SCHED.
- exists t.+1; repeat split; try done. apply/andP; split.
+ apply leq_trans with t; by done.
+ rewrite ltnNge; apply/negP; intros CONTR.
by move: SERV; rewrite /service_during big_geq.
- apply negbT in SCHED.
move: SERV; rewrite /service /service_during; move => /sum_seq_gt0P [x [INx SCHEDx]].
rewrite lt0b in SCHEDx.
rewrite mem_iota subnKC in INx; last by done.
move: INx => /andP [INx1 INx2].
move: (exists_first_intermediate_point _ _ _ INx1 SCHED) => A.
feed A; first by rewrite scheduled_at_def/=.
move: A => [y [/andP [T1 T4] [T2 T3]]].
exists y; repeat split; try done.
+ apply/andP; split.
apply leq_trans with t; first by done.
apply ltnW, ltn_trans with t.+1; by done.
by apply leq_ltn_trans with x.
+ rewrite (@big_cat_nat _ _ _ t.+1) //=; [ | by apply leq_trans with t | by apply ltn_trans with t.+1].
unfold service_during in SERVk1; rewrite SERVk1; apply/eqP.
rewrite -{2}[k.+1]addn0 eqn_add2l.
rewrite big_nat_cond big1 //; move => z /andP [H5 _].
by apply/eqP; rewrite eqb0; specialize (T2 z); rewrite scheduled_at_def/= in T2; apply T2.
Qed.
End IncrementalService.
Require Export rt.util.all.
Require Export rt.restructuring.analysis.basic_facts.ideal_schedule.
Require Export rt.restructuring.behavior.all.
Require Export rt.restructuring.model.processor.platform_properties.
From mathcomp Require Import ssrnat ssrbool fintype.
......@@ -576,111 +577,3 @@ Section RelationToScheduled.
End RelationToScheduled.
Require Import rt.restructuring.model.processor.ideal.
(** * Incremental Service in Ideal Schedule *)
(** In the following section we prove a few facts about service in ideal schedeule. *)
(* Note that these lemmas can be generalized to an arbitrary scheduler. *)
Section IncrementalService.
(** Consider any job type, ... *)
Context {Job : JobType}.
Context `{JobArrival Job}.
Context `{JobCost Job}.
(** ... any arrival sequence, ... *)
Variable arr_seq : arrival_sequence Job.
(** ... and any ideal uniprocessor schedule of this arrival sequence. *)
Variable sched : schedule (ideal.processor_state Job).
(** As a base case, we prove that if a job j receives service in
some time interval [t1,t2), then there exists a time instant t
∈ [t1,t2) such that j is scheduled at time t and t is the first
instant where j receives service. *)
Lemma positive_service_during:
forall j t1 t2,
0 < service_during sched j t1 t2 ->
exists t : nat, t1 <= t < t2 /\ scheduled_at sched j t /\ service_during sched j t1 t = 0.
Proof.
intros j t1 t2 SERV.
have LE: t1 <= t2.
{ rewrite leqNgt; apply/negP; intros CONTR.
by apply ltnW in CONTR; move: SERV; rewrite /service_during big_geq.
}
destruct (scheduled_at sched j t1) eqn:SCHED.
{ exists t1; repeat split; try done.
- apply/andP; split; first by done.
rewrite ltnNge; apply/negP; intros CONTR.
by move: SERV; rewrite/service_during big_geq.
- by rewrite /service_during big_geq.
}
{ apply negbT in SCHED.
move: SERV; rewrite /service /service_during; move => /sum_seq_gt0P [t [IN SCHEDt]].
rewrite lt0b in SCHEDt.
rewrite mem_iota subnKC in IN; last by done.
move: IN => /andP [IN1 IN2].
move: (exists_first_intermediate_point
((fun t => scheduled_at sched j t)) t1 t IN1 SCHED) => A.
feed A; first by rewrite scheduled_at_def/=.
move: A => [x [/andP [T1 T4] [T2 T3]]].
exists x; repeat split; try done.
- apply/andP; split; first by apply ltnW.
by apply leq_ltn_trans with t.
- apply/eqP; rewrite big_nat_cond big1 //.
move => y /andP [T5 _].
by apply/eqP; rewrite eqb0; specialize (T2 y); rewrite scheduled_at_def/= in T2; apply T2.
}
Qed.
(** Next, we prove that if in some time interval [t1,t2) a job j
receives k units of service, then there exists a time instant t ∈
[t1,t2) such that j is scheduled at time t and service of job j
within interval [t1,t) is equal to k. *)
Lemma incremental_service_during:
forall j t1 t2 k,
service_during sched j t1 t2 > k ->
exists t, t1 <= t < t2 /\ scheduled_at sched j t /\ service_during sched j t1 t = k.
Proof.
intros j t1 t2 k SERV.
have LE: t1 <= t2.
{ rewrite leqNgt; apply/negP; intros CONTR.
by apply ltnW in CONTR; move: SERV; rewrite /service_during big_geq.
}
induction k; first by apply positive_service_during in SERV.
feed IHk; first by apply ltn_trans with k.+1.
move: IHk => [t [/andP [NEQ1 NEQ2] [SCHEDt SERVk]]].
have SERVk1: service_during sched j t1 t.+1 = k.+1.
{ rewrite -(service_during_cat _ _ _ t); last by apply/andP; split.
rewrite SERVk -[X in _ = X]addn1; apply/eqP; rewrite eqn_add2l.
by rewrite /service_during big_nat1 /service_at eqb1 -scheduled_at_def/=.
}
move: SERV; rewrite -(service_during_cat _ _ _ t.+1); last first.
{ by apply/andP; split; first apply leq_trans with t. }
rewrite SERVk1 -addn1 leq_add2l; move => SERV.
destruct (scheduled_at sched j t.+1) eqn:SCHED.
- exists t.+1; repeat split; try done. apply/andP; split.
+ apply leq_trans with t; by done.
+ rewrite ltnNge; apply/negP; intros CONTR.
by move: SERV; rewrite /service_during big_geq.
- apply negbT in SCHED.
move: SERV; rewrite /service /service_during; move => /sum_seq_gt0P [x [INx SCHEDx]].
rewrite lt0b in SCHEDx.
rewrite mem_iota subnKC in INx; last by done.
move: INx => /andP [INx1 INx2].
move: (exists_first_intermediate_point _ _ _ INx1 SCHED) => A.
feed A; first by rewrite scheduled_at_def/=.
move: A => [y [/andP [T1 T4] [T2 T3]]].
exists y; repeat split; try done.
+ apply/andP; split.
apply leq_trans with t; first by done.
apply ltnW, ltn_trans with t.+1; by done.
by apply leq_ltn_trans with x.
+ rewrite (@big_cat_nat _ _ _ t.+1) //=; [ | by apply leq_trans with t | by apply ltn_trans with t.+1].
unfold service_during in SERVk1; rewrite SERVk1; apply/eqP.
rewrite -{2}[k.+1]addn0 eqn_add2l.
rewrite big_nat_cond big1 //; move => z /andP [H5 _].
by apply/eqP; rewrite eqb0; specialize (T2 z); rewrite scheduled_at_def/= in T2; apply T2.
Qed.
End IncrementalService.
\ No newline at end of file
Require Export rt.restructuring.model.aggregate.workload.
Require Export rt.restructuring.model.aggregate.service_of_jobs.
Require Export rt.restructuring.analysis.basic_facts.completion.
Require Export rt.restructuring.analysis.facts.behavior.completion.
Require Export rt.restructuring.analysis.facts.behavior.ideal_schedule.
Require Import rt.restructuring.model.processor.ideal.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
......@@ -371,4 +371,4 @@ Section IdealModelLemmas.
End WorkloadServiceAndCompletion.
End IdealModelLemmas.
\ No newline at end of file
End IdealModelLemmas.
Require Export rt.restructuring.model.aggregate.workload.
Require Export rt.restructuring.analysis.basic_facts.arrivals.
Require Export rt.restructuring.analysis.facts.behavior.arrivals.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
......
Require Export rt.restructuring.analysis.definitions.job_properties.
Require Export rt.restructuring.model.schedule.work_conserving.
Require Export rt.restructuring.analysis.definitions.priority_inversion.
Require Export rt.restructuring.analysis.basic_facts.all.
Require Export rt.restructuring.analysis.concepts.priority_inversion.
Require Export rt.restructuring.analysis.facts.behavior.all.
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq fintype bigop.
(** Throughout this file, we assume ideal uniprocessor schedules. *)
......