Built with
Alectryon , running Coq+SerAPI v8.15.0+0.15.0. Bubbles (
) indicate interactive fragments: hover for details, tap to reveal contents. Use
Ctrl+↑ Ctrl+↓ to navigate,
Ctrl+🖱️ to focus. On Mac, use
⌘ instead of
Ctrl .
From mathcomp Require Import ssreflect ssrbool eqtype ssrnat seq path fintype bigop.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "_ + _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ - _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ <= _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ < _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ >= _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ > _" was already used in scope nat_scope.
[notation-overridden,parsing]Notation "_ <= _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ < _ <= _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ <= _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ < _ < _" was already used in scope
nat_scope. [notation-overridden,parsing]Notation "_ * _" was already used in scope nat_scope.
[notation-overridden,parsing]
Require Export prosa.analysis.facts.priority.edf.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Export prosa.analysis.definitions.schedulability.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.model.readiness.basic.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.model.priority.edf.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.model.task.absolute_deadline.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.analysis.abstract .ideal.iw_instantiation.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.analysis.facts.busy_interval.carry_in.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.analysis.facts.readiness.basic.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
Require Import prosa.analysis.facts.busy_interval.ideal.inequalities.Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ | _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ : _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ | _ ]" was already used
in scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ & _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ | _ ]" was already used in
scope fun_scope. [notation-overridden,parsing]Notation "[ rel _ _ in _ ]" was already used in scope
fun_scope. [notation-overridden,parsing]
(** * Abstract RTA for EDF-schedulers with Bounded Priority Inversion *)
(** In this module we instantiate the Abstract Response-Time analysis
(aRTA) to EDF-schedulers for ideal uni-processor model of
real-time tasks with arbitrary arrival models. *)
(** Given EDF priority policy and an ideal uni-processor scheduler
model, we can explicitly specify [interference],
[interfering_workload], and [interference_bound_function]. In this
settings, we can define natural notions of service, workload, busy
interval, etc. The important feature of this instantiation is that
we can induce the meaningful notion of priority
inversion. However, we do not specify the exact cause of priority
inversion (as there may be different reasons for this, like
execution of a non-preemptive segment or blocking due to resource
locking). We only assume that that a priority inversion is
bounded. *)
Section AbstractRTAforEDFwithArrivalCurves .
(** Consider any type of tasks ... *)
Context {Task : TaskType}.
Context `{TaskCost Task}.
Context `{TaskDeadline Task}.
Context `{TaskRunToCompletionThreshold Task}.
Context `{TaskMaxNonpreemptiveSegment Task}.
(** ... and any type of jobs associated with these tasks. *)
Context {Job : JobType}.
Context `{JobTask Job Task}.
Context {Arrival : JobArrival Job}.
Context {Cost : JobCost Job}.
Context `{JobPreemptable Job}.
(** We assume the classic (i.e., Liu & Layland) model of readiness
without jitter or self-suspensions, wherein pending jobs are
always ready. *)
#[local] Existing Instance basic_ready_instance .
(** For clarity, let's denote the relative deadline of a task as D. *)
Let D tsk := task_deadline tsk.
(** Consider the EDF policy that indicates a higher-or-equal
priority relation. Note that we do not relate the EDF policy
with the scheduler. However, we define functions for
Interference and Interfering Workload that actively use the
concept of priorities. *)
Let EDF := EDF Job.
(** Consider any arrival sequence with consistent, non-duplicate arrivals. *)
Variable arr_seq : arrival_sequence Job.
Hypothesis H_valid_arrival_sequence : valid_arrival_sequence arr_seq.
(** Next, consider any valid ideal uni-processor schedule of this arrival sequence
that follows the scheduling policy. *)
Variable sched : schedule (ideal.processor_state Job).
Hypothesis H_sched_valid : valid_schedule sched arr_seq.
Hypothesis H_respects_policy : respects_JLFP_policy_at_preemption_point arr_seq sched EDF.
(** To use the theorem [uniprocessor_response_time_bound_seq] from
the Abstract RTA module, we need to specify functions of
interference, interfering workload, and [IBF_other]. Next, we
define interference and interfering workload; we return to
[IBF_other] later. *)
(** ** Instantiation of Interference *)
(** We say that job [j] incurs interference at time [t] iff it
cannot execute due to a higher-or-equal-priority job being
scheduled, or if it incurs a priority inversion. *)
#[local] Instance ideal_jlfp_interference : Interference Job :=
ideal_jlfp_interference arr_seq sched.
(** ** Instantiation of Interfering Workload *)
(** The interfering workload, in turn, is defined as the sum of the
priority inversion function and interfering workload of jobs
with higher or equal priority. *)
#[local] Instance ideal_jlfp_interfering_workload : InterferingWorkload Job :=
ideal_jlfp_interfering_workload arr_seq sched.
(** Note that we differentiate between abstract and classical
notions of work-conserving schedule. *)
Let work_conserving_ab := definitions.work_conserving arr_seq sched.
Let work_conserving_cl := work_conserving.work_conserving arr_seq sched.
(** We assume that the schedule is a work-conserving schedule
in the _classical_ sense, and later prove that the hypothesis
about abstract work-conservation also holds. *)
Hypothesis H_work_conserving : work_conserving_cl.
(** Assume that a job cost cannot be larger than a task cost. *)
Hypothesis H_valid_job_cost :
arrivals_have_valid_job_costs arr_seq.
(** Consider an arbitrary task set ts. *)
Variable ts : list Task.
(** Next, we assume that all jobs come from the task set. *)
Hypothesis H_all_jobs_from_taskset : all_jobs_from_taskset arr_seq ts.
(** 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_taskset_arrival_curve ts max_arrivals.
Hypothesis H_is_arrival_curve : taskset_respects_max_arrivals arr_seq ts.
(** Let [tsk] be any task in ts that is to be analyzed. *)
Variable tsk : Task.
Hypothesis H_tsk_in_ts : tsk \in ts.
(** Consider a valid preemption model... *)
Hypothesis H_valid_preemption_model :
valid_preemption_model arr_seq sched.
(** ...and a valid task run-to-completion threshold function. That
is, [task_rtct tsk] is (1) no bigger than [tsk]'s cost, (2) for
any job of task [tsk] [job_rtct] is bounded by [task_rtct]. *)
Hypothesis H_valid_run_to_completion_threshold :
valid_task_run_to_completion_threshold arr_seq tsk.
(** We introduce [rbf] as an abbreviation of the task request bound
function, which is defined as [task_cost(T) × max_arrivals(T,Δ)]
for some task [T]. *)
Let rbf := task_request_bound_function.
(** Next, we introduce [task_rbf] as an abbreviation of the task
request bound function of task [tsk]. *)
Let task_rbf := rbf tsk.
(** Using the sum of individual request bound functions, we define
the request bound function of all tasks (total request bound
function). *)
Let total_rbf := total_request_bound_function ts.
(** Assume that there exists a bound on the length of any priority
inversion experienced by any job of task [tsk]. Since we analyze
only task [tsk], we ignore the lengths of priority inversions
incurred by any other tasks. *)
Variable priority_inversion_bound : duration -> duration.
Hypothesis H_priority_inversion_is_bounded :
priority_inversion_is_bounded_by
arr_seq sched tsk priority_inversion_bound.
(** Let [L] be any positive fixed point of the busy interval
recurrence. *)
Variable L : duration.
Hypothesis H_L_positive : L > 0 .
Hypothesis H_fixed_point : L = total_rbf L.
(** Next, we define an upper bound on interfering workload received
from jobs of other tasks with higher-than-or-equal priority. *)
Let bound_on_total_hep_workload (A Δ : duration) :=
\sum_(tsk_o <- ts | tsk_o != tsk)
rbf tsk_o (minn ((A + ε) + D tsk - D tsk_o) Δ).
(** To reduce the time complexity of the analysis, we introduce the
notion of search space for EDF. Intuitively, this corresponds to
all "interesting" arrival offsets that the job under analysis
might have with regard to the beginning of its busy-window. *)
(** In the case of the search space for EDF, we consider three
conditions. First, we ask whether [task_rbf A ≠ task_rbf (A +
ε)]. *)
Definition task_rbf_changes_at (A : duration) := task_rbf A != task_rbf (A + ε).
(** Second, we ask whether there exists a task [tsko] from [ts] such
that [tsko ≠ tsk] and [rbf(tsko, A + D tsk - D tsko) ≠ rbf(tsko,
A + ε + D tsk - D tsko)]. Note that we use a slightly uncommon
notation [has (λ tsko ⇒ P tskₒ) ts], which can be interpreted as
follows: the task set [ts] contains a task [tsko] such that a
predicate [P] holds for [tsko]. *)
Definition bound_on_total_hep_workload_changes_at A :=
has (fun tsko =>
(tsk != tsko)
&& (rbf tsko (A + D tsk - D tsko)
!= rbf tsko ((A + ε) + D tsk - D tsko))) ts.
(** Third, we ask whether [priority_inversion_bound (A - ε) ≠
priority_inversion_bound A]. *)
Definition priority_inversion_changes_at (A : duration) :=
priority_inversion_bound (A - ε) != priority_inversion_bound A.
(** The final search space for EDF is a set of offsets that are less
than [L] and where [priority_inversion_bound], [task_rbf], or
[bound_on_total_hep_workload] changes in value. *)
Definition is_in_search_space (A : duration) :=
(A < L) && (priority_inversion_changes_at A
|| task_rbf_changes_at A
|| bound_on_total_hep_workload_changes_at A).
(** Let [R] be a value that upper-bounds the solution of each
response-time recurrence, i.e., for any relative arrival time
[A] in the search space, there exists a corresponding solution
[F] such that [R >= F + (task cost - task lock-in service)]. *)
Variable R : duration.
Hypothesis H_R_is_maximum :
forall (A : duration),
is_in_search_space A ->
exists (F : duration),
A + F >= priority_inversion_bound A
+ (task_rbf (A + ε) - (task_cost tsk - task_rtct tsk))
+ bound_on_total_hep_workload A (A + F) /\
R >= F + (task_cost tsk - task_rtct tsk).
(** Finally, we define the interference bound function
([IBF_other]). [IBF_other] bounds the interference if tasks are
sequential. Since tasks are sequential, we exclude interference
from other jobs of the same task. For EDF, we define [IBF_other]
as the sum of the priority interference bound and the
higher-or-equal-priority workload. *)
Let IBF_other (A R : duration) := priority_inversion_bound A + bound_on_total_hep_workload A R.
(** ** Filling Out Hypothesis Of Abstract RTA Theorem *)
(** In this section we prove that all hypotheses necessary to use
the abstract theorem are satisfied. *)
Section FillingOutHypothesesOfAbstractRTATheorem .
(** First, we prove that [IBF_other] is indeed an interference bound. *)
Section TaskInterferenceIsBoundedByIBF_other .
Section HepWorkloadBound .
(** Consider an arbitrary job [j] of [tsk]. *)
Variable j : Job.
Hypothesis H_j_arrives : arrives_in arr_seq j.
Hypothesis H_job_of_tsk : job_of_task tsk j.
Hypothesis H_job_cost_positive : job_cost_positive j.
(** Consider any busy interval <<[t1, t2)>> of job [j]. *)
Variable t1 t2 : duration.
Hypothesis H_busy_interval : definitions.busy_interval sched j t1 t2.
(** Let's define A as a relative arrival time of job j (with respect to time t1). *)
Let A := job_arrival j - t1.
(** Consider an arbitrary shift Δ inside the busy interval ... *)
Variable Δ : duration.
Hypothesis H_Δ_in_busy : t1 + Δ < t2.
(** ... and the set of all arrivals between [t1] and [t1 + Δ]. *)
Let jobs := arrivals_between arr_seq t1 (t1 + Δ).
(** We define a predicate [EDF_from tsk]. Predicate [EDF_from
tsk] holds true for any job [jo] of task [tsk] such that
[job_deadline jo <= job_deadline j]. *)
Let EDF_from (tsk : Task) := fun (jo : Job) => EDF jo j && (job_task jo == tsk).
(** Now, consider the case where [A + ε + D tsk - D tsk_o ≤ Δ]. *)
Section ShortenRange .
(** Consider an arbitrary task [tsk_o ≠ tsk] from [ts]. *)
Variable tsk_o : Task.
Hypothesis H_tsko_in_ts : tsk_o \in ts.
Hypothesis H_neq : tsk_o != tsk.
(** And assume that [A + ε + D tsk - D tsk_o ≤ Δ]. *)
Hypothesis H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ.
(** Then we prove that the total workload of jobs with
higher-or-equal priority from task [tsk_o] over time
interval [t1, t1 + Δ] is bounded by workload over time
interval [t1, t1 + A + ε + D tsk - D tsk_o]. The
intuition behind this inequality is that jobs which
arrive after time instant [t1 + A + ε + D tsk - D tsk_o]
have lower priority than job [j] due to the term [D tsk
- D tsk_o]. *)
Lemma total_workload_shorten_range :
workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + Δ))
<= workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o))).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
workload_of_jobs (EDF_from tsk_o)
(arrivals_between arr_seq t1 (t1 + Δ)) <=
workload_of_jobs (EDF_from tsk_o)
(arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)))
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ
workload_of_jobs (EDF_from tsk_o)
(arrivals_between arr_seq t1 (t1 + Δ)) <=
workload_of_jobs (EDF_from tsk_o)
(arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)))
have BOUNDED: t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ by lia .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ
workload_of_jobs (EDF_from tsk_o)
(arrivals_between arr_seq t1 (t1 + Δ)) <=
workload_of_jobs (EDF_from tsk_o)
(arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)))
rewrite (workload_of_jobs_nil_tail _ _ BOUNDED) // => j' IN'; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ)
t1 + (A + ε + D tsk - D tsk_o) <= job_arrival j' ->
~~ EDF_from tsk_o j'
rewrite /EDF_from /ε => ARR'.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j'
~~ (EDF j' j && (job_task j' == tsk_o))
case : (eqVneq (job_task j') tsk_o) => TSK';
last by rewrite andbF.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j' TSK' : job_task j' = tsk_o
~~ (EDF j' j && true)
rewrite andbT; apply : contraT => /negPn.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j' TSK' : job_task j' = tsk_o
EDF j' j -> false
rewrite /EDF/edf.EDF/job_deadline/job_deadline_from_task_deadline.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j' TSK' : job_task j' = tsk_o
job_arrival j' + task_deadline (job_task j') <=
job_arrival j + task_deadline (job_task j) -> false
move : H_job_of_tsk; rewrite TSK' /job_of_task => /eqP -> HEP.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j' TSK' : job_task j' = tsk_o HEP : job_arrival j' + task_deadline tsk_o <=
job_arrival j + task_deadline tsk
false
have LATEST: job_arrival j' <= t1 + A + D tsk - D tsk_o by rewrite /D/A; lia .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j' TSK' : job_task j' = tsk_o HEP : job_arrival j' + task_deadline tsk_o <=
job_arrival j + task_deadline tsk LATEST : job_arrival j' <= t1 + A + D tsk - D tsk_o
false
have EARLIEST: t1 <= job_arrival j' by apply : job_arrival_between_ge; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool tsk_o : Task H_tsko_in_ts : tsk_o \in ts H_neq : tsk_o != tsk H_Δ_ge : A + ε + D tsk - D tsk_o <= Δ BOUNDED : t1 + (A + ε + D tsk - D tsk_o) <= t1 + Δ j' : Job IN' : j' \in arrivals_between arr_seq t1 (t1 + Δ) ARR' : t1 + (A + 1 + D tsk - D tsk_o) <=
job_arrival j' TSK' : job_task j' = tsk_o HEP : job_arrival j' + task_deadline tsk_o <=
job_arrival j + task_deadline tsk LATEST : job_arrival j' <= t1 + A + D tsk - D tsk_o EARLIEST : t1 <= job_arrival j'
false
by case : (leqP (A + 1 + D tsk) (D tsk_o)); [rewrite /D/A|]; lia .
Qed .
End ShortenRange .
(** Using the above lemma, we prove that the total workload of the
tasks is at most [bound_on_total_hep_workload(A, Δ)]. *)
Corollary sum_of_workloads_is_at_most_bound_on_total_hep_workload :
\sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs
<= bound_on_total_hep_workload A Δ.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs (EDF_from tsk_o) jobs <=
bound_on_total_hep_workload A Δ
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs (EDF_from tsk_o) jobs <=
bound_on_total_hep_workload A Δ
move : (H_busy_interval) => [[/andP [JINBI JINBI2] [QT _]] _].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs (EDF_from tsk_o) jobs <=
bound_on_total_hep_workload A Δ
apply leq_sum_seq => tsko INtsko NEQT.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 tsko : Task INtsko : tsko \in ts NEQT : tsko != tsk
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (minn (A + ε + D tsk - D tsko) Δ)
edestruct (leqP Δ (A + ε + D tsk - D tsko)) as [NEQ|NEQ]; [ | apply ltnW in NEQ].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 tsko : Task INtsko : tsko \in ts NEQT : tsko != tsk NEQ : Δ <= A + ε + D tsk - D tsko
workload_of_jobs (EDF_from tsko) jobs <= rbf tsko Δ
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 tsko : Task INtsko : tsko \in ts NEQT : tsko != tsk NEQ : Δ <= A + ε + D tsk - D tsko
workload_of_jobs (EDF_from tsko) jobs <= rbf tsko Δ
apply (workload_le_rbf arr_seq ts); try by done .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 tsko : Task INtsko : tsko \in ts NEQT : tsko != tsk NEQ : A + ε + D tsk - D tsko <= Δ
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (A + ε + D tsk - D tsko)
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 tsko : Task INtsko : tsko \in ts NEQT : tsko != tsk NEQ : A + ε + D tsk - D tsko <= Δ
workload_of_jobs (EDF_from tsko) jobs <=
rbf tsko (A + ε + D tsk - D tsko)
eapply leq_trans; first by eapply total_workload_shorten_range; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j t1, t2 : duration H_busy_interval : definitions.busy_interval sched j t1
t2 A := job_arrival j - t1 : nat Δ : duration H_Δ_in_busy : t1 + Δ < t2 jobs := arrivals_between arr_seq t1 (t1 + Δ) : seq Job EDF_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo == tsk): Task -> Job -> bool JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 tsko : Task INtsko : tsko \in ts NEQT : tsko != tsk NEQ : A + ε + D tsk - D tsko <= Δ
workload_of_jobs (EDF_from tsko)
(arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsko))) <=
rbf tsko (A + ε + D tsk - D tsko)
eapply workload_le_rbf; rt_eauto.
Qed .
End HepWorkloadBound .
(** Recall that in module abstract_seq_RTA hypothesis
[task_interference_is_bounded_by] expects to receive a
function that maps some task [t], the relative arrival time of
a job [j] of task [t], and the length of the interval to the
maximum amount of interference.
However, in this module we analyze only one task -- [tsk],
therefore it is “hard-coded” inside the interference bound
function [IBF_other]. Therefore, in order for the
[IBF_other] signature to match the required signature in
module abstract_seq_RTA, we wrap the [IBF_other] function in
a function that accepts, but simply ignores the task. *)
Corollary instantiated_task_interference_is_bounded :
task_interference_is_bounded_by arr_seq sched tsk (fun tsk A R => IBF_other A R).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
task_interference_is_bounded_by arr_seq sched tsk
(fun => (fun A : duration => [eta IBF_other A]))
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
task_interference_is_bounded_by arr_seq sched tsk
(fun => (fun A : duration => [eta IBF_other A]))
rewrite /task_interference_is_bounded_by.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
forall (j : Job) (R t1 t2 : nat),
arrives_in arr_seq j ->
job_of_task tsk j ->
t1 + R < t2 ->
~~ completed_by sched j (t1 + R) ->
definitions.busy_interval sched j t1 t2 ->
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R) <= IBF_other (job_arrival j - t1) R
move => j R2 t1 t2 ARR TSK N NCOMPL BUSY.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R2) <= IBF_other (job_arrival j - t1) R2
move : (posnP (@job_cost _ Cost j)) => [ZERO|POS].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 ZERO : job_cost j = 0
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R2) <= IBF_other (job_arrival j - t1) R2
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 ZERO : job_cost j = 0
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R2) <= IBF_other (job_arrival j - t1) R2
exfalso ; move : NCOMPL => /negP COMPL; apply : COMPL.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 BUSY : definitions.busy_interval sched j t1 t2 ZERO : job_cost j = 0
completed_by sched j (t1 + R2)
by rewrite /completed_by /completed_by ZERO.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost j
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R2) <= IBF_other (job_arrival j - t1) R2
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost j
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R2) <= IBF_other (job_arrival j - t1) R2
move : (BUSY) => [[/andP [JINBI JINBI2] [QT _]] _].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumul_task_interference arr_seq sched tsk t2 t1
(t1 + R2) <= IBF_other (job_arrival j - t1) R2
rewrite (cumulative_task_interference_split arr_seq _ sched _ _ _ _ _ _ j); rt_eauto; last first .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
j \in arrivals_before arr_seq t2
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
j \in arrivals_before arr_seq t2
by eapply arrived_between_implies_in_arrivals; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
sequential_tasks arr_seq sched
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
sequential_tasks arr_seq sched
by eapply EDF_implies_sequential_tasks; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumulative_priority_inversion arr_seq sched j t1
(t1 + R2) +
cumulative_another_task_hep_job_interference arr_seq
sched j t1 (t1 + R2) <=
IBF_other (job_arrival j - t1) R2
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumulative_priority_inversion arr_seq sched j t1
(t1 + R2) +
cumulative_another_task_hep_job_interference arr_seq
sched j t1 (t1 + R2) <=
IBF_other (job_arrival j - t1) R2
rewrite /I leq_add //.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumulative_priority_inversion arr_seq sched j t1
(t1 + R2) <=
priority_inversion_bound (job_arrival j - t1)
* Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumulative_priority_inversion arr_seq sched j t1
(t1 + R2) <=
priority_inversion_bound (job_arrival j - t1)
eapply cumulative_priority_inversion_is_bounded; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumulative_another_task_hep_job_interference arr_seq
sched j t1 (t1 + R2) <=
bound_on_total_hep_workload (job_arrival j - t1) R2
* Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
cumulative_another_task_hep_job_interference arr_seq
sched j t1 (t1 + R2) <=
bound_on_total_hep_workload (job_arrival j - t1) R2
eapply leq_trans; first by eapply cumulative_interference_is_bounded_by_total_service; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
service_of_jobs sched (another_task_hep_job^~ j)
(arrivals_between arr_seq t1 (t1 + R2)) t1 (t1 + R2) <=
bound_on_total_hep_workload (job_arrival j - t1) R2
eapply leq_trans; first by eapply service_of_jobs_le_workload; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
workload_of_jobs (another_task_hep_job^~ j)
(arrivals_between arr_seq t1 (t1 + R2)) <=
bound_on_total_hep_workload (job_arrival j - t1) R2
eapply leq_trans.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
workload_of_jobs (another_task_hep_job^~ j)
(arrivals_between arr_seq t1 (t1 + R2)) <= ?n
eapply reorder_summation; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
forall x : Job,
x \in arrivals_between arr_seq t1 (t1 + R2) ->
job_task x \in ?ys
move => j' IN.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 j' : Job IN : j' \in arrivals_between arr_seq t1 (t1 + R2)
job_task j' \in ?ys
apply H_all_jobs_from_taskset.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 j' : Job IN : j' \in arrivals_between arr_seq t1 (t1 + R2)
arrives_in arr_seq j'
eapply in_arrivals_implies_arrived.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 j' : Job IN : j' \in arrivals_between arr_seq t1 (t1 + R2)
j' \in arrivals_between arr_seq ?t1 ?t2
exact IN.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j TSK : job_of_task tsk j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1
\sum_(y <- ts | y != job_task j)
\sum_(x <- arrivals_between arr_seq t1 (t1 + R2) |
(hep_job^~ j) x && (job_task x == y)) job_cost x <=
bound_on_total_hep_workload (job_arrival j - t1) R2
move : TSK => /eqP TSK.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 TSK : job_task j = tsk
\sum_(y <- ts | y != job_task j)
\sum_(x <- arrivals_between arr_seq t1 (t1 + R2) |
hep_job x j && (job_task x == y)) job_cost x <=
bound_on_total_hep_workload (job_arrival j - t1) R2
rewrite TSK.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 TSK : job_task j = tsk
\sum_(y <- ts | y != tsk)
\sum_(x <- arrivals_between arr_seq t1 (t1 + R2) |
hep_job x j && (job_task x == y)) job_cost x <=
bound_on_total_hep_workload (job_arrival j - t1) R2
eapply leq_trans; first eapply sum_of_workloads_is_at_most_bound_on_total_hep_workload; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job R2, t1, t2 : nat ARR : arrives_in arr_seq j N : t1 + R2 < t2 NCOMPL : ~~ completed_by sched j (t1 + R2) BUSY : definitions.busy_interval sched j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched j t1 TSK : job_task j = tsk
job_of_task tsk j
by apply /eqP.
Unshelve .
all : try by rt_eauto.
Qed .
End TaskInterferenceIsBoundedByIBF_other .
(** Finally, we show that there exists a solution for the response-time recurrence. *)
Section SolutionOfResponseTimeReccurenceExists .
(** Consider any job j of [tsk]. *)
Variable j : Job.
Hypothesis H_j_arrives : arrives_in arr_seq j.
Hypothesis H_job_of_tsk : job_of_task tsk j.
Hypothesis H_job_cost_positive : job_cost_positive j.
(** Given any job [j] of task [tsk] that arrives exactly [A] units
after the beginning of the busy interval, the bound of the
total interference incurred by [j] within an interval of
length [Δ] is equal to [task_rbf (A + ε) - task_cost tsk +
IBF_other(A, Δ)]. *)
Let total_interference_bound tsk (A Δ : duration) :=
task_rbf (A + ε) - task_cost tsk + IBF_other A Δ.
(** Next, consider any [A] from the search space (in abstract sense). *)
Variable A : duration.
Hypothesis H_A_is_in_abstract_search_space :
search_space.is_in_search_space tsk L total_interference_bound A.
(** We prove that A is also in the concrete search space. *)
Lemma A_is_in_concrete_search_space :
is_in_search_space A.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
is_in_search_space A
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
is_in_search_space A
move : H_A_is_in_abstract_search_space => [-> | [/andP [POSA LTL] [x [LTx INSP2]]]];
apply /andP; split => //.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
priority_inversion_changes_at 0
|| task_rbf_changes_at 0
|| bound_on_total_hep_workload_changes_at 0
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
priority_inversion_changes_at 0
|| task_rbf_changes_at 0
|| bound_on_total_hep_workload_changes_at 0
apply /orP; left ; apply /orP; right .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
task_rbf_changes_at 0
rewrite /task_rbf_changes_at /task_rbf /rbf task_rbf_0_zero //; eauto 2 .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
0 != task_request_bound_function tsk (0 + ε)
apply contraT => /negPn /eqP ZERO.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A ZERO : 0 = task_request_bound_function tsk (0 + ε)
false
rewrite -(ltnn 0 ) {2 }ZERO add0n.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A ZERO : 0 = task_request_bound_function tsk (0 + ε)
0 < task_request_bound_function tsk ε
apply : (@leq_trans (task_cost tsk));
last by apply : task_rbf_1_ge_task_cost; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A ZERO : 0 = task_request_bound_function tsk (0 + ε)
0 < task_cost tsk
apply : (@leq_trans (job_cost j)) => //.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A ZERO : 0 = task_request_bound_function tsk (0 + ε)
job_cost j <= task_cost tsk
move : (H_job_of_tsk) => /eqP <-.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A ZERO : 0 = task_request_bound_function tsk (0 + ε)
job_cost j <= task_cost (job_task j)
by apply : (H_valid_job_cost _ H_j_arrives). } Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x
priority_inversion_changes_at A
|| task_rbf_changes_at A
|| bound_on_total_hep_workload_changes_at A
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x
priority_inversion_changes_at A
|| task_rbf_changes_at A
|| bound_on_total_hep_workload_changes_at A
apply contraT; rewrite !negb_or => /andP [/andP [/negPn/eqP PI /negPn/eqP RBF] WL].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A
false
exfalso ; apply INSP2.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A
total_interference_bound tsk (A - ε) x =
total_interference_bound tsk A x
rewrite /total_interference_bound subnK // RBF.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A
task_rbf (A + ε) - task_cost tsk + IBF_other (A - ε) x =
task_rbf (A + ε) - task_cost tsk + IBF_other A x
apply /eqP; rewrite eqn_add2l /IBF_other PI eqn_add2l.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A
bound_on_total_hep_workload (A - ε) x ==
bound_on_total_hep_workload A x
rewrite /bound_on_total_hep_workload subnK //.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A
\sum_(tsk_o <- ts | tsk_o != tsk)
rbf tsk_o (minn (A + D tsk - D tsk_o) x) ==
\sum_(tsk_o <- ts | tsk_o != tsk)
rbf tsk_o (minn (A + ε + D tsk - D tsk_o) x)
apply /eqP; rewrite big_seq_cond [RHS]big_seq_cond.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A
\sum_(i <- ts | (i \in ts) && (i != tsk))
rbf i (minn (A + D tsk - D i) x) =
\sum_(i <- ts | (i \in ts) && (i != tsk))
rbf i (minn (A + ε + D tsk - D i) x)
apply eq_big => // tsk_i /andP [TS OTHER].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) WL : ~~ bound_on_total_hep_workload_changes_at A tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk
rbf tsk_i (minn (A + D tsk - D tsk_i) x) =
rbf tsk_i (minn (A + ε + D tsk - D tsk_i) x)
move : WL; rewrite /bound_on_total_hep_workload_changes_at => /hasPn WL.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : {in ts,
forall x : Task,
~~
((tsk != x) &&
(rbf x (A + D tsk - D x)
!= rbf x (A + ε + D tsk - D x)))}
rbf tsk_i (minn (A + D tsk - D tsk_i) x) =
rbf tsk_i (minn (A + ε + D tsk - D tsk_i) x)
move : {WL} (WL tsk_i TS) => /nandP [/negPn/eqP EQ|/negPn/eqP WL];
first by move : OTHER; rewrite EQ => /neqP.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i)
rbf tsk_i (minn (A + D tsk - D tsk_i) x) =
rbf tsk_i (minn (A + ε + D tsk - D tsk_i) x)
case : (ltngtP (A + ε + D tsk - D tsk_i) x) => [ltn_x|gtn_x|eq_x];
rewrite /minn.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) ltn_x : A + ε + D tsk - D tsk_i < x
rbf tsk_i
(if A + D tsk - D tsk_i < x
then A + D tsk - D tsk_i
else x) = rbf tsk_i (A + ε + D tsk - D tsk_i)
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) ltn_x : A + ε + D tsk - D tsk_i < x
rbf tsk_i
(if A + D tsk - D tsk_i < x
then A + D tsk - D tsk_i
else x) = rbf tsk_i (A + ε + D tsk - D tsk_i)
by rewrite ifT //; lia . } Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) gtn_x : x < A + ε + D tsk - D tsk_i
rbf tsk_i
(if A + D tsk - D tsk_i < x
then A + D tsk - D tsk_i
else x) = rbf tsk_i x
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) gtn_x : x < A + ε + D tsk - D tsk_i
rbf tsk_i
(if A + D tsk - D tsk_i < x
then A + D tsk - D tsk_i
else x) = rbf tsk_i x
rewrite ifF //.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) gtn_x : x < A + ε + D tsk - D tsk_i
(A + D tsk - D tsk_i < x) = false
by move : gtn_x; rewrite leq_eqVlt /ε => /orP [/eqP EQ|LEQ]; lia . } Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) eq_x : A + ε + D tsk - D tsk_i = x
rbf tsk_i
(if A + D tsk - D tsk_i < x
then A + D tsk - D tsk_i
else x) = rbf tsk_i (A + ε + D tsk - D tsk_i)
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) eq_x : A + ε + D tsk - D tsk_i = x
rbf tsk_i
(if A + D tsk - D tsk_i < x
then A + D tsk - D tsk_i
else x) = rbf tsk_i (A + ε + D tsk - D tsk_i)
case : (A + D tsk - D tsk_i < x).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) eq_x : A + ε + D tsk - D tsk_i = x
rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i)
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) eq_x : A + ε + D tsk - D tsk_i = x
rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i)
by rewrite WL.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) eq_x : A + ε + D tsk - D tsk_i = x
rbf tsk_i x = rbf tsk_i (A + ε + D tsk - D tsk_i)
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A POSA : 0 < ALTL : A < L x : nat LTx : x < L INSP2 : total_interference_bound tsk (A - ε) x <>
total_interference_bound tsk A x PI : priority_inversion_bound (A - ε) =
priority_inversion_bound A RBF : task_rbf A = task_rbf (A + ε) tsk_i : Task TS : tsk_i \in ts OTHER : tsk_i != tsk WL : rbf tsk_i (A + D tsk - D tsk_i) =
rbf tsk_i (A + ε + D tsk - D tsk_i) eq_x : A + ε + D tsk - D tsk_i = x
rbf tsk_i x = rbf tsk_i (A + ε + D tsk - D tsk_i)
by rewrite eq_x. } }
Qed .
(** Then, there exists solution for response-time recurrence (in the abstract sense). *)
Corollary correct_search_space :
exists F ,
A + F >= task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) + IBF_other A (A + F) /\
R >= F + (task_cost tsk - task_rtct tsk).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
exists F : nat,
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <= A + F /\
F + (task_cost tsk - task_rtct tsk) <= R
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A
exists F : nat,
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <= A + F /\
F + (task_cost tsk - task_rtct tsk) <= R
edestruct H_R_is_maximum as [F [FIX NEQ]]; first by apply A_is_in_concrete_search_space.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A F : duration FIX : priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A (A + F) <=
A + F NEQ : F + (task_cost tsk - task_rtct tsk) <= R
exists F : nat,
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <= A + F /\
F + (task_cost tsk - task_rtct tsk) <= R
exists F ; split ; last by done .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A F : duration FIX : priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A (A + F) <=
A + F NEQ : F + (task_cost tsk - task_rtct tsk) <= R
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <= A + F
rewrite -{2 }(leqRW FIX).Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job H_j_arrives : arrives_in arr_seq j H_job_of_tsk : job_of_task tsk j H_job_cost_positive : job_cost_positive j total_interference_bound := fun (tsk : Task)
(A Δ : duration) =>
task_rbf (A + ε) -
task_cost tsk +
IBF_other A Δ: Task ->
duration -> duration -> nat A : duration H_A_is_in_abstract_search_space : search_space.is_in_search_space
tsk L
total_interference_bound
A F : duration FIX : priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A (A + F) <=
A + F NEQ : F + (task_cost tsk - task_rtct tsk) <= R
task_rbf (A + ε) - (task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <=
priority_inversion_bound A +
(task_rbf (A + ε) - (task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A (A + F)
by rewrite addnA [_ + priority_inversion_bound A]addnC -!addnA.
Qed .
End SolutionOfResponseTimeReccurenceExists .
End FillingOutHypothesesOfAbstractRTATheorem .
(** ** Final Theorem *)
(** Based on the properties established above, we apply the abstract
analysis framework to infer that [R] is a response-time bound for
[tsk]. *)
Theorem uniprocessor_response_time_bound_edf :
task_response_time_bound arr_seq sched tsk R.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
task_response_time_bound arr_seq sched tsk R
Proof .Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
task_response_time_bound arr_seq sched tsk R
move => js ARRs TSKs.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js
job_response_time_bound sched js R
move : (posnP (@job_cost _ Cost js)) => [ZERO|POS].Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js ZERO : job_cost js = 0
job_response_time_bound sched js R
{ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js ZERO : job_cost js = 0
job_response_time_bound sched js R
by rewrite /job_response_time_bound /completed_by ZERO. } Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
job_response_time_bound sched js R
eapply uniprocessor_response_time_bound_seq with
(task_interference_bound_function := fun tsk A R => IBF_other A R) (L := L)
|| eapply uniprocessor_response_time_bound_seq with
(task_interference_bound_function := fun tsk A R => IBF_other A R) (L0 := L); rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
work_conserving arr_seq sched
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
work_conserving arr_seq sched
by eapply instantiated_i_and_w_are_coherent_with_schedule; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
sequential_tasks arr_seq sched
+ Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
sequential_tasks arr_seq sched
by eapply EDF_implies_sequential_tasks; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
interference_and_workload_consistent_with_sequential_tasks
arr_seq sched tsk
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
interference_and_workload_consistent_with_sequential_tasks
arr_seq sched tsk
by apply instantiated_interference_and_workload_consistent_with_sequential_tasks; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
busy_intervals_are_bounded_by arr_seq sched tsk L
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
busy_intervals_are_bounded_by arr_seq sched tsk L
by eapply instantiated_busy_intervals_are_bounded; rt_eauto.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
task_interference_is_bounded_by arr_seq sched tsk
(fun => (fun A : duration => [eta IBF_other A]))
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
task_interference_is_bounded_by arr_seq sched tsk
(fun => (fun A : duration => [eta IBF_other A]))
by apply instantiated_task_interference_is_bounded.Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
forall A : duration,
search_space.is_in_search_space tsk L
(fun (tsk0 : Task) (A0 Δ : duration) =>
task_request_bound_function tsk (A0 + ε) -
task_cost tsk0 + IBF_other A0 Δ) A ->
exists F : duration,
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <= A + F /\
F + (task_cost tsk - task_rtct tsk) <= R
- Task : TaskType H : TaskCost Task H0 : TaskDeadline Task H1 : TaskRunToCompletionThreshold Task H2 : TaskMaxNonpreemptiveSegment Task Job : JobType H3 : JobTask Job Task Arrival : JobArrival Job Cost : JobCost Job H4 : JobPreemptable Job D := [eta task_deadline] : Task -> duration EDF := edf.EDF Job : JLFP_policy Job arr_seq : arrival_sequence Job H_valid_arrival_sequence : valid_arrival_sequence
arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq H_respects_policy : respects_JLFP_policy_at_preemption_point
arr_seq sched EDF work_conserving_ab := work_conserving arr_seq sched : Prop work_conserving_cl := work_conserving.work_conserving
arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq ts : seq Task H_all_jobs_from_taskset : all_jobs_from_taskset
arr_seq ts H5 : MaxArrivals Task H_valid_arrival_curve : valid_taskset_arrival_curve ts
max_arrivals H_is_arrival_curve : taskset_respects_max_arrivals
arr_seq ts tsk : Task H_tsk_in_ts : tsk \in ts H_valid_preemption_model : valid_preemption_model
arr_seq sched H_valid_run_to_completion_threshold : valid_task_run_to_completion_threshold
arr_seq tsk rbf := task_request_bound_function : Task -> duration -> nat task_rbf := rbf tsk : duration -> nat total_rbf := total_request_bound_function ts : duration -> nat priority_inversion_bound : duration -> duration H_priority_inversion_is_bounded : priority_inversion_is_bounded_by
arr_seq sched tsk
priority_inversion_bound L : duration H_L_positive : 0 < LH_fixed_point : L = total_rbf L bound_on_total_hep_workload := fun A Δ : duration =>
\sum_(tsk_o <- ts |
tsk_o != tsk)
rbf tsk_o
(minn
(A + ε + D tsk -
D tsk_o) Δ): duration ->
duration -> nat R : duration H_R_is_maximum : forall A : duration,
is_in_search_space A ->
exists F : duration,
priority_inversion_bound A +
(task_rbf (A + ε) -
(task_cost tsk - task_rtct tsk)) +
bound_on_total_hep_workload A
(A + F) <=
A + F /\
F + (task_cost tsk - task_rtct tsk) <=
RIBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat js : Job ARRs : arrives_in arr_seq js TSKs : job_of_task tsk js POS : 0 < job_cost js
forall A : duration,
search_space.is_in_search_space tsk L
(fun (tsk0 : Task) (A0 Δ : duration) =>
task_request_bound_function tsk (A0 + ε) -
task_cost tsk0 + IBF_other A0 Δ) A ->
exists F : duration,
task_request_bound_function tsk (A + ε) -
(task_cost tsk - task_rtct tsk) +
IBF_other A (A + F) <= A + F /\
F + (task_cost tsk - task_rtct tsk) <= R
by eapply correct_search_space; rt_eauto.
Qed .
End AbstractRTAforEDFwithArrivalCurves .