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_jlfp_rta.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]
(** * 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_arrival_times_are_consistent : consistent_arrival_times arr_seq.
Hypothesis H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq.
(** Next, consider any valid ideal uni-processor schedule of this arrival sequence ... *)
Variable sched : schedule (ideal.processor_state Job).
Hypothesis H_sched_valid : valid_schedule sched arr_seq.
(** 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.
(** Assume we have sequential tasks, i.e, jobs from the
same task execute in the order of their arrival. *)
Hypothesis H_sequential_tasks : sequential_tasks arr_seq sched.
(** 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).
(** 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]. *)
(** 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. *)
Let interference (j : Job) (t : instant) :=
ideal_jlfp_rta.interference sched j t.
(** 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. *)
Let interfering_workload (j : Job) (t : instant) :=
ideal_jlfp_rta.interfering_workload arr_seq sched j t.
(** 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 .
(** Recall that L is assumed to be a fixed point of the busy interval recurrence. Thanks to
this fact, we can prove that every busy interval (according to the concrete definition)
is bounded. In addition, we know that the conventional concept of busy interval and the
one obtained from the abstract definition (with the interference and interfering
workload) coincide. Thus, it follows that any busy interval (in the abstract sense)
is bounded. *)
Lemma instantiated_busy_intervals_are_bounded :
busy_intervals_are_bounded_by arr_seq sched tsk interference interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
unfold EDF 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat
busy_intervals_are_bounded_by arr_seq sched tsk
interference interfering_workload L
move => j ARR TSK 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j POS : 0 < job_cost j
exists t1 t2 : nat,
t2 <= t1 + L /\
definitions.busy_interval sched interference
interfering_workload j t1 t2
edestruct exists_busy_interval_from_total_workload_bound
with (Δ := L) as [t1 [t2 [T1 [T2 GGG]]]]; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j POS : 0 < job_cost j
forall t : instant,
workload_of_jobs predT
(arrivals_between arr_seq t (t + L)) <= 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j POS : 0 < job_cost j
forall t : instant,
workload_of_jobs predT
(arrivals_between arr_seq t (t + L)) <= L
by intros ; rewrite {2 }H_fixed_point; apply total_workload_le_total_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j POS : 0 < job_cost jt1, t2 : nat T1 : t1 <= job_arrival j < t2 T2 : t2 <= t1 + L GGG : busy_interval arr_seq sched j t1 t2
exists t1 t2 : nat,
t2 <= t1 + L /\
definitions.busy_interval sched interference
interfering_workload j t1 t2
exists t1 , t2; split ; first 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_other := fun A R : duration =>
priority_inversion_bound A +
bound_on_total_hep_workload A R: duration -> duration -> nat j : Job ARR : arrives_in arr_seq j TSK : job_of_task tsk j POS : 0 < job_cost jt1, t2 : nat T1 : t1 <= job_arrival j < t2 T2 : t2 <= t1 + L GGG : busy_interval arr_seq sched j t1 t2
definitions.busy_interval sched interference
interfering_workload j t1 t2
by eapply instantiated_busy_interval_equivalent_busy_interval; rt_eauto.
Qed .
(** Next, we prove that [IBF_other] is indeed an interference bound. *)
Section TaskInterferenceIsBoundedByIBF_other .
(** We show that task_interference_is_bounded_by is bounded by [IBF_other] by
constructing a sequence of inequalities. *)
Section Inequalities .
(** 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 interference interfering_workload 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 + Δ).
(** Next, we define two predicates on jobs by extending EDF-priority relation. *)
(** 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).
(** Predicate [EDF_not_from tsk] holds true for any job [jo]
such that [job_deadline jo <= job_deadline j] and [job_task jo ≠ tsk]. *)
Let EDF_not_from (tsk : Task) := fun (jo : Job) => EDF jo j && (job_task jo != tsk).
(** Recall that [IBF_other(A, R) := priority_inversion_bound +
bound_on_total_hep_workload(A, R)]. The fact that
[priority_inversion_bound] bounds cumulative priority inversion
follows from assumption [H_priority_inversion_is_bounded]. *)
Lemma cumulative_priority_inversion_is_bounded :
cumulative_priority_inversion sched j t1 (t1 + Δ) <= 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
priority_inversion_bound (job_arrival j - t1)
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
priority_inversion_bound (job_arrival j - t1)
unfold priority_inversion_is_bounded_by, EDF 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
priority_inversion_bound (job_arrival j - t1)
apply leq_trans with (cumulative_priority_inversion sched j t1 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
cumulative_priority_inversion sched j t1 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
cumulative_priority_inversion sched j t1 t2
rewrite [X in _ <= X](@big_cat_nat _ _ _ (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
\sum_(t1 <= i < t1 + Δ)
is_priority_inversion sched j i +
\sum_(t1 + Δ <= i < t2)
is_priority_inversion sched j 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 (t1 + Δ) <=
\sum_(t1 <= i < t1 + Δ)
is_priority_inversion sched j i +
\sum_(t1 + Δ <= i < t2)
is_priority_inversion sched j i
by rewrite leq_addr.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
t1 <= 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
t1 <= t1 + Δ
by rewrite /is_priority_inversion leq_addr.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
t1 + Δ <= 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
t1 + Δ <= t2
by rewrite ltnW.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 t2 <=
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_priority_inversion sched j t1 t2 <=
priority_inversion_bound (job_arrival j - t1)
apply H_priority_inversion_is_bounded; try 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
busy_interval_prefix arr_seq sched j t1 t2
eapply instantiated_busy_interval_equivalent_busy_interval in H_busy_interval; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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 : forall j : Job,
arrives_in arr_seq j ->
job_of_task tsk j ->
0 < job_cost j ->
priority_inversion_of_job_is_bounded_by
arr_seq sched j
priority_inversion_boundL : 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 : busy_interval arr_seq 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.EDF Job jo j && (job_task jo == tsk): Task -> Job -> bool EDF_not_from := fun (tsk : Task) (jo : Job) =>
edf.EDF Job jo j && (job_task jo != tsk): Task -> Job -> bool
busy_interval_prefix arr_seq sched j t1 t2
by move : H_busy_interval => [PREF _].
Qed .
(** Next, we show that [bound_on_total_hep_workload(A, R)] bounds
interference from jobs with higher-or-equal priority. *)
(** From lemma
[instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_tasks]
it follows that cumulative interference from jobs with
higher-or-equal priority from other tasks is equal to the
total service of jobs with higher-or-equal priority from
other tasks. Which in turn means that cumulative
interference is bounded by service. *)
Lemma cumulative_interference_is_bounded_by_total_service :
cumulative_interference_from_hep_jobs_from_other_tasks sched j t1 (t1 + Δ)
<= service_of_jobs sched (EDF_not_from tsk) jobs t1 (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_interference_from_hep_jobs_from_other_tasks
sched j t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1
(t1 + Δ)
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
cumulative_interference_from_hep_jobs_from_other_tasks
sched j t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1
(t1 + Δ)
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
cumulative_interference_from_hep_jobs_from_other_tasks
sched j t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1
(t1 + Δ)
erewrite instantiated_cumulative_interference_of_hep_tasks_equal_total_interference_of_hep_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
service_of_jobs sched
(fun jhp : Job =>
hep_job jhp j && (job_task jhp != job_task j))
(arrivals_between arr_seq t1 (t1 + Δ)) t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1
(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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
service_of_jobs sched
(fun jhp : Job =>
hep_job jhp j && (job_task jhp != job_task j))
(arrivals_between arr_seq t1 (t1 + Δ)) t1 (t1 + Δ) <=
service_of_jobs sched (EDF_not_from tsk) jobs t1
(t1 + Δ)
by move : (H_job_of_tsk) => /eqP ->; rewrite /jobs.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
quiet_time arr_seq sched 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
quiet_time arr_seq sched j t1
by rewrite instantiated_quiet_time_equivalent_quiet_time; rt_eauto.
Qed .
(** By lemma [service_of_jobs_le_workload], the total
_service_ of jobs with higher-or-equal priority from other
tasks is at most the total _workload_ of jobs with
higher-or-equal priority from other tasks. *)
Lemma total_service_is_bounded_by_total_workload :
service_of_jobs sched (EDF_not_from tsk) jobs t1 (t1 + Δ)
<= workload_of_jobs (EDF_not_from tsk) jobs.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
service_of_jobs sched (EDF_not_from tsk) jobs t1
(t1 + Δ) <= workload_of_jobs (EDF_not_from tsk) jobs
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
service_of_jobs sched (EDF_not_from tsk) jobs t1
(t1 + Δ) <= workload_of_jobs (EDF_not_from tsk) jobs
by apply service_of_jobs_le_workload; rt_eauto.
Qed .
(** Next, we prove that the total workload of jobs
with higher-or-equal priority from other tasks is bounded by
the sum over all tasks [tsk_o] that are not equal to task
[tsk] of workload of jobs with higher-or-equal priority from
task [tsk_o].*)
Lemma reorder_summation :
workload_of_jobs (EDF_not_from tsk) jobs
<= \sum_(tsk_o <- ts | tsk_o != tsk) workload_of_jobs (EDF_from tsk_o) jobs.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs (EDF_from tsk_o) jobs
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs (EDF_from tsk_o) jobs
unfold EDF_from.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_from := fun (tsk : Task) (jo : Job) =>
EDF jo j && (job_task jo != tsk): Task -> Job -> bool
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs
(fun jo : Job =>
EDF jo j && (job_task jo == tsk_o)) jobs
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs
(fun jo : Job =>
EDF jo j && (job_task jo == tsk_o)) jobs
intros .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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs
(fun jo : Job =>
EDF jo j && (job_task jo == tsk_o)) jobs
rewrite (exchange_big_dep (EDF_not_from 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(j0 <- jobs | EDF_not_from tsk j0)
\sum_(i <- ts | [&& i != tsk, EDF j0 j
& job_task j0 == i]) job_cost j0
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
workload_of_jobs (EDF_not_from tsk) jobs <=
\sum_(j0 <- jobs | EDF_not_from tsk j0)
\sum_(i <- ts | [&& i != tsk, EDF j0 j
& job_task j0 == i]) job_cost j0
rewrite /workload_of_jobs big_seq_cond [X in _ <= X]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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
\sum_(i <- jobs | (i \in jobs) && EDF_not_from tsk i)
job_cost i <=
\sum_(i <- jobs | (i \in jobs) && EDF_not_from tsk i)
\sum_(i0 <- ts | [&& i0 != tsk, EDF i j
& job_task i == i0]) job_cost i
apply leq_sum; move => jo /andP [ARRo /andP [HEQ 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 jo : Job ARRo : jo \in jobs HEQ : EDF jo j TSKo : job_task jo != tsk
job_cost jo <=
\sum_(i <- ts | [&& i != tsk, EDF jo j
& job_task jo == i]) job_cost jo
rewrite (big_rem (job_task jo)) //=.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 jo : Job ARRo : jo \in jobs HEQ : EDF jo j TSKo : job_task jo != tsk
job_cost jo <=
(if
[&& job_task jo != tsk, EDF jo j
& job_task jo == job_task jo]
then job_cost jo
else 0 ) +
\sum_(y <- rem (T:=Task) (job_task jo) ts | [&& y
!= tsk,
EDF jo
j
& job_task
jo ==
y])
job_cost jo
rewrite /EDF_from HEQ eq_refl TSKo andTb andTb leq_addr //.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 jo : Job ARRo : jo \in jobs HEQ : EDF jo j TSKo : job_task jo != tsk
job_task jo \in ts
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 jo : Job ARRo : jo \in jobs HEQ : EDF jo j TSKo : job_task jo != tsk
job_task jo \in ts
eapply H_all_jobs_from_taskset, in_arrivals_implies_arrived; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
forall (i : Task) (j0 : Job),
i != tsk ->
EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1
forall (i : Task) (j0 : Job),
i != tsk ->
EDF j0 j && (job_task j0 == i) -> EDF_not_from tsk j0
move => tsko jo /negP NEQ /andP [EQ1 /eqP EQ2].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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 tsko : Task jo : Job NEQ : ~ tsko == tsk EQ1 : EDF jo j EQ2 : job_task jo = tsko
EDF_not_from tsk jo
rewrite /EDF_not_from EQ1 Bool.andb_true_l; apply /negP; intros CONTR.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 tsko : Task jo : Job NEQ : ~ tsko == tsk EQ1 : EDF jo j EQ2 : job_task jo = tsko CONTR : job_task jo == tsk
False
apply : NEQ; clear EQ1.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload j t1 tsko : Task jo : Job EQ2 : job_task jo = tsko CONTR : job_task jo == tsk
tsko == tsk
by rewrite -EQ2.
Qed .
(** Next we focus on one task [tsk_o ≠ tsk] and consider two cases. *)
(** Case 1: [Δ ≤ A + ε + D tsk - D tsk_o]. *)
Section Case1 .
(** 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_Δ_le : Δ <= A + ε + D tsk - D tsk_o.
(** Then by definition of [rbf], the total workload of jobs
with higher-or-equal priority from task [tsk_o] is
bounded [rbf(tsk_o, Δ)]. *)
Lemma workload_le_rbf :
workload_of_jobs (EDF_from tsk_o) jobs <= rbf 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
workload_of_jobs (EDF_from tsk_o) jobs <= rbf 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
workload_of_jobs (EDF_from tsk_o) jobs <= rbf tsk_o Δ
unfold workload_of_jobs, EDF_from.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o))
job_cost j0 <= rbf tsk_o Δ
apply leq_trans with (task_cost tsk_o * number_of_task_arrivals arr_seq tsk_o t1 (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o))
job_cost j0 <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o))
job_cost j0 <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (t1 + Δ)
apply leq_trans with (\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) | job_task j0 == tsk_o)
job_cost j0).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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o))
job_cost j0 <=
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
job_task j0 == tsk_o) job_cost j0
{ 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- jobs | EDF j0 j && (job_task j0 == tsk_o))
job_cost j0 <=
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
job_task j0 == tsk_o) job_cost j0
rewrite big_mkcond [X in _ <= X]big_mkcond //= leq_sum //.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
forall i : Job,
true ->
(if EDF i j && (job_task i == tsk_o)
then job_cost i
else 0 ) <=
(if job_task i == tsk_o then job_cost i else 0 )
by intros s _; case (job_task s == tsk_o); case (EDF s 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
job_task j0 == tsk_o) job_cost j0 <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
job_task j0 == tsk_o) job_cost j0 <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (t1 + Δ)
rewrite /number_of_task_arrivals /task.arrivals.number_of_task_arrivals
-sum1_size big_distrr /= big_filter muln1.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
job_task j0 == tsk_o) job_cost j0 <=
\sum_(i <- arrivals_between arr_seq t1 (t1 + Δ) |
job_of_task tsk_o i) task_cost tsk_o
apply leq_sum_seq; move => jo IN0 /eqP EQ.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o jo : Job IN0 : jo \in arrivals_between arr_seq t1 (t1 + Δ) EQ : job_task jo = tsk_o
job_cost jo <= task_cost tsk_o
by rewrite -EQ; apply H_valid_job_cost; apply in_arrivals_implies_arrived in IN0.
}
} 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (t1 + Δ) <=
rbf 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (t1 + Δ) <=
rbf tsk_o Δ
rewrite leq_mul2l; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
number_of_task_arrivals arr_seq tsk_o t1 (t1 + Δ) <=
max_arrivals tsk_o Δ
rewrite -{2 }[Δ](addKn 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_Δ_le : Δ <= A + ε + D tsk - D tsk_o
number_of_task_arrivals arr_seq tsk_o t1 (t1 + Δ) <=
max_arrivals tsk_o (t1 + Δ - t1)
by apply H_is_arrival_curve; auto using leq_addr.
}
Qed .
End Case1 .
(** Case 2: [A + ε + D tsk - D tsk_o ≤ Δ]. *)
Section Case2 .
(** 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 <= Δ.
(** Important step. *)
(** Next 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] has smaller 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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)))
unfold workload_of_jobs, EDF_from.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 <= Δ
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
\sum_(j0 <- arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) | EDF
j0 j &&
(job_task
j0 ==
tsk_o))
job_cost j0
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
\sum_(j0 <- arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) | EDF
j0 j &&
(job_task
j0 ==
tsk_o))
job_cost j0
set (V := A + ε + D tsk - D tsk_o) 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + Δ) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0
rewrite (arrivals_between_cat _ _ (t1 + V)); [ |rewrite leq_addr //|rewrite leq_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- (arrivals_between arr_seq t1 (t1 + V) ++
arrivals_between arr_seq (t1 + V)
(t1 + Δ)) | EDF j0 j &&
(job_task j0 == tsk_o))
job_cost j0 <=
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0
rewrite big_cat //=.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(i <- arrivals_between arr_seq t1 (t1 + V) |
EDF i j && (job_task i == tsk_o)) job_cost i +
\sum_(i <- arrivals_between arr_seq (t1 + V) (t1 + Δ) |
EDF i j && (job_task i == tsk_o)) job_cost i <=
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0
rewrite -[X in _ <= X]addn0 leq_add2l leqn0.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(i <- arrivals_between arr_seq (t1 + V) (t1 + Δ) |
EDF i j && (job_task i == tsk_o)) job_cost i == 0
rewrite 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(i <- arrivals_between arr_seq (t1 + V) (t1 + Δ) |
[&& i \in arrivals_between arr_seq (t1 + V) (t1 + Δ),
EDF i j
& job_task i == tsk_o]) job_cost i == 0
apply /eqP; apply big_pred0.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
(fun i : Job =>
[&& i \in arrivals_between arr_seq (t1 + V) (t1 + Δ),
EDF i j
& job_task i == tsk_o]) =1 xpred0
intros jo; apply /negP; intros CONTR.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job CONTR : [&& jo
\in arrivals_between arr_seq
(t1 + V)
(t1 + Δ),
EDF jo j
& job_task jo == tsk_o]
False
move : CONTR => /andP [ARRIN /andP [HEP /eqP 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job ARRIN : jo
\in arrivals_between arr_seq
(t1 + V)
(t1 + Δ) HEP : EDF jo j TSKo : job_task jo = tsk_o
False
eapply in_arrivals_implies_arrived_between in ARRIN; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job ARRIN : arrived_between jo (t1 + V) (t1 + Δ) HEP : EDF jo j TSKo : job_task jo = tsk_o
False
move : ARRIN => /andP [ARRIN _]; unfold V in ARRIN.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo
False
edestruct (leqP (D tsk_o) (A + ε + D tsk)) as [NEQ2|NEQ2].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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : D tsk_o <= A + ε + D tsk
False
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : D tsk_o <= A + ε + D tsk
False
move : ARRIN; rewrite leqNgt; move => /negP ARRIN; apply : ARRIN.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
job_arrival jo < t1 + (A + ε + D tsk - D tsk_o)
rewrite -(ltn_add2r (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
job_arrival jo + D tsk_o <
t1 + (A + ε + D tsk - D tsk_o) + D tsk_o
apply leq_ltn_trans with (job_arrival j + D tsk); first by move : (H_job_of_tsk) => /eqP <-; rewrite -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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
job_arrival j + D tsk <
t1 + (A + ε + D tsk - D tsk_o) + D tsk_o
rewrite addnBA // addnA addnA subnKC // 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
job_arrival j + D tsk < job_arrival j + ε + D 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
job_arrival j + D tsk < job_arrival j + ε + D tsk
by rewrite ltn_add2r addn1.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
D tsk_o <= job_arrival j + ε + D 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
D tsk_o <= job_arrival j + ε + D tsk
apply leq_trans with (A + ε + D tsk); first 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o NEQ2 : D tsk_o <= A + ε + D tsk
A + ε + D tsk <= job_arrival j + ε + D tsk
by rewrite !leq_add2r leq_subr.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
False
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job HEP : EDF jo j TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
False
move : HEP; rewrite /EDF /edf.EDF leqNgt; move => /negP HEP; apply : 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_deadline j < job_deadline jo
apply leq_ltn_trans with (job_arrival jo + (A + D 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_deadline j <= job_arrival jo + (A + D 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_deadline j <= job_arrival jo + (A + D tsk)
rewrite addnBAC // addnBA.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_deadline j <=
job_arrival jo + (job_arrival j + D tsk) - t1
rewrite [in X in _ <= X]addnC -addnBA.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_deadline j <=
job_arrival j + D tsk + (job_arrival jo - 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_deadline j <=
job_arrival j + D tsk + (job_arrival jo - t1)
rewrite /job_deadline /job_deadline_from_task_deadline;
by move : (H_job_of_tsk) => /eqP ->; rewrite leq_addr.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
t1 <= job_arrival jo
* 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
t1 <= job_arrival jo
by apply leq_trans with (t1 + (A + ε + D tsk - D tsk_o)); first rewrite leq_addr.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
t1 <= job_arrival j + D tsk
by apply leq_trans with (job_arrival j); [ | by rewrite leq_addr].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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_arrival jo + (A + D tsk) < job_deadline jo
+ 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
job_arrival jo + (A + D tsk) < job_deadline jo
rewrite ltn_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
A + D tsk < task_deadline (job_task jo)
apply leq_ltn_trans with (A + ε + D 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
A + D tsk <= A + ε + D 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
A + D tsk <= A + ε + D tsk
by rewrite leq_add2r leq_addr.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
A + ε + D tsk < task_deadline (job_task jo)
* 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 jo : Job TSKo : job_task jo = tsk_o ARRIN : t1 + (A + ε + D tsk - D tsk_o) <=
job_arrival jo NEQ2 : A + ε + D tsk < D tsk_o
A + ε + D tsk < task_deadline (job_task jo)
by rewrite TSKo.
Qed .
(** And similarly to the previous case, by definition of
[rbf], the total workload of jobs with higher-or-equal
priority from task [tsk_o] is bounded [rbf(tsk_o, Δ)].
*)
Lemma workload_le_rbf' :
workload_of_jobs (EDF_from tsk_o) (arrivals_between arr_seq t1 (t1 + (A + ε + D tsk - D tsk_o)))
<= rbf tsk_o (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 + (A + ε + D tsk - D tsk_o))) <=
rbf tsk_o (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 + (A + ε + D tsk - D tsk_o))) <=
rbf tsk_o (A + ε + D tsk - D tsk_o)
unfold workload_of_jobs, EDF_from.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 <= Δ
\sum_(j0 <- arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) | EDF
j0 j &&
(job_task
j0 ==
tsk_o))
job_cost j0 <= rbf tsk_o (A + ε + D tsk - D tsk_o)
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) | EDF
j0 j &&
(job_task
j0 ==
tsk_o))
job_cost j0 <= rbf tsk_o (A + ε + D tsk - D tsk_o)
set (V := A + ε + D tsk - D tsk_o) 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
rbf tsk_o V
apply leq_trans with
(task_cost tsk_o * number_of_task_arrivals arr_seq tsk_o 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o))
apply leq_trans with
(\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) | job_task jo == tsk_o) job_cost jo).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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) |
job_task jo == tsk_o) job_cost jo
+ 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(j0 <- arrivals_between arr_seq t1 (t1 + V) |
EDF j0 j && (job_task j0 == tsk_o)) job_cost j0 <=
\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) |
job_task jo == tsk_o) job_cost jo
rewrite big_mkcond [X in _ <= X]big_mkcond //=.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(i <- arrivals_between arr_seq t1 (t1 + V))
(if EDF i j && (job_task i == tsk_o)
then job_cost i
else 0 ) <=
\sum_(i <- arrivals_between arr_seq t1 (t1 + V))
(if job_task i == tsk_o then job_cost i else 0 )
rewrite leq_sum //; intros s _.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 s : Job
(if EDF s j && (job_task s == tsk_o)
then job_cost s
else 0 ) <=
(if job_task s == tsk_o then job_cost s else 0 )
by case (EDF s 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) |
job_task jo == tsk_o) job_cost jo <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) |
job_task jo == tsk_o) job_cost jo <=
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o))
rewrite /number_of_task_arrivals /task.arrivals.number_of_task_arrivals
-sum1_size big_distrr /= big_filter.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) |
job_task jo == tsk_o) job_cost jo <=
\sum_(i <- arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) | job_of_task
tsk_o
i)
task_cost tsk_o * 1
rewrite muln1.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(jo <- arrivals_between arr_seq t1 (t1 + V) |
job_task jo == tsk_o) job_cost jo <=
\sum_(i <- arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) | job_of_task
tsk_o
i)
task_cost tsk_o
apply leq_sum_seq; move => j0 IN0 /eqP EQ.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 j0 : Job IN0 : j0
\in arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) EQ : job_task j0 = tsk_o
job_cost j0 <= task_cost tsk_o
rewrite -EQ.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 j0 : Job IN0 : j0
\in arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) EQ : job_task j0 = tsk_o
job_cost j0 <= task_cost (job_task j0)
apply H_valid_job_cost.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1 j0 : Job IN0 : j0
\in arrivals_between arr_seq t1
(t1 + (A + ε + D tsk - D tsk_o)) EQ : job_task j0 = tsk_o
arrives_in arr_seq j0
by apply in_arrivals_implies_arrived in IN0.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o)) <= rbf tsk_o V
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o)) <= rbf tsk_o V
unfold V in *; clear V.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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1
(t1 + (A + ε + D tsk - D tsk_o)) <=
rbf tsk_o (A + ε + D tsk - D tsk_o)
set (V := A + ε + D tsk - D tsk_o) 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
task_cost tsk_o *
number_of_task_arrivals arr_seq tsk_o t1 (t1 + V) <=
rbf tsk_o V
rewrite leq_mul2l; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
number_of_task_arrivals arr_seq tsk_o t1 (t1 + V) <=
max_arrivals tsk_o V
rewrite -{2 }[V](addKn 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 V := A + ε + D tsk - D tsk_o : nat H_Δ_ge : V <= Δ JINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
number_of_task_arrivals arr_seq tsk_o t1 (t1 + V) <=
max_arrivals tsk_o (t1 + V - t1)
by apply H_is_arrival_curve; auto using leq_addr.
Qed .
End Case2 .
(** By combining case 1 and case 2 we prove that total
workload of 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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; intros 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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 Δ
by apply workload_le_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
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 EDF_not_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 interference
interfering_workload 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)
by eapply workload_le_rbf'.
Qed .
End Inequalities .
(** 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 interference interfering_workload (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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
(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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
(fun => (fun A : duration => [eta IBF_other A]))
unfold EDF 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
(fun => (fun A : duration => [eta IBF_other A]))
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk
t2 t1 (t1 + R2) <= IBF_other offset 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 ZERO : job_cost j = 0
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk
t2 t1 (t1 + R2) <= IBF_other offset 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 ZERO : job_cost j = 0
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk
t2 t1 (t1 + R2) <= IBF_other offset 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost j
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk
t2 t1 (t1 + R2) <= IBF_other offset 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost j
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk
t2 t1 (t1 + R2) <= IBF_other offset 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
let offset := job_arrival j - t1 in
cumul_task_interference arr_seq sched interference tsk
t2 t1 (t1 + R2) <= IBF_other offset R2
rewrite (cumulative_task_interference_split arr_seq sched _ _ _ tsk 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
j \in arrivals_before arr_seq t2
by eapply arrived_between_implies_in_arrivals; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
let offset := job_arrival j - t1 in
ideal_jlfp_rta.cumulative_priority_inversion sched j
t1 (t1 + R2) +
cumulative_interference_from_hep_jobs_from_other_tasks
sched j t1 (t1 + R2) <= IBF_other offset 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
ideal_jlfp_rta.cumulative_priority_inversion 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
ideal_jlfp_rta.cumulative_priority_inversion sched j
t1 (t1 + R2) <=
priority_inversion_bound (job_arrival j - t1)
by apply cumulative_priority_inversion_is_bounded with 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
cumulative_interference_from_hep_jobs_from_other_tasks
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
cumulative_interference_from_hep_jobs_from_other_tasks
sched j 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
cumulative_interference_from_hep_jobs_from_other_tasks
sched j t1 (t1 + R2) <= ?n
eapply cumulative_interference_is_bounded_by_total_service; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
service_of_jobs sched
(fun jo : Job => EDF jo j && (job_task jo != tsk))
(arrivals_between arr_seq t1 (t1 + R2)) 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
service_of_jobs sched
(fun jo : Job => EDF jo j && (job_task jo != tsk))
(arrivals_between arr_seq t1 (t1 + R2)) t1 (t1 + R2) <=
?n
eapply total_service_is_bounded_by_total_workload; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
workload_of_jobs
(fun jo : Job => EDF jo j && (job_task jo != tsk))
(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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
workload_of_jobs
(fun jo : Job => EDF jo j && (job_task jo != tsk))
(arrivals_between arr_seq t1 (t1 + R2)) <= ?n
eapply reorder_summation; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs
(fun jo : Job =>
EDF jo j && (job_task jo == tsk_o))
(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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
\sum_(tsk_o <- ts | tsk_o != tsk)
workload_of_jobs
(fun jo : Job =>
EDF jo j && (job_task jo == tsk_o))
(arrivals_between arr_seq t1 (t1 + R2)) <= ?n
eapply sum_of_workloads_is_at_most_bound_on_total_hep_workload; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference
interfering_workload j t1 t2 POS : 0 < job_cost jJINBI : t1 <= job_arrival j JINBI2 : job_arrival j < t2 QT : definitions.quiet_time sched interference
interfering_workload j t1
bound_on_total_hep_workload (job_arrival j - t1) R2 <=
bound_on_total_hep_workload (job_arrival j - t1) R2
by done .
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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; 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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]].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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
( try ( eapply uniprocessor_response_time_bound_seq with
(interference0 := interference) (interfering_workload0 := interfering_workload)
(task_interference_bound_function := fun tsk A R => IBF_other A R) (L0 := L) ) ||
eapply uniprocessor_response_time_bound_seq with
(interference := interference) (interfering_workload := interfering_workload)
(task_interference_bound_function := fun tsk A R => IBF_other A R) (L := 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
definitions.work_conserving arr_seq sched interference
interfering_workload
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
definitions.work_conserving arr_seq sched interference
interfering_workload
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference interfering_workload
- 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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 interference interfering_workload
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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload 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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload L
by apply instantiated_busy_intervals_are_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
(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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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
interference interfering_workload
(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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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_arrival_times_are_consistent : consistent_arrival_times
arr_seq H_arr_seq_is_a_set : arrival_sequence_uniq arr_seq sched : schedule (ideal.processor_state Job) H_sched_valid : valid_schedule sched arr_seq work_conserving_ab := definitions.work_conserving
arr_seq sched : (Job -> instant -> bool) ->
(Job -> instant -> duration) ->
Prop work_conserving_cl := work_conserving arr_seq sched : Prop H_work_conserving : work_conserving_cl H_valid_job_cost : arrivals_have_valid_job_costs
arr_seq H_sequential_tasks : sequential_tasks arr_seq sched 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) <=
Rinterference := fun j : Job =>
[eta ideal_jlfp_rta.interference sched j]: Job -> instant -> bool interfering_workload := fun j : Job =>
[eta ideal_jlfp_rta.interfering_workload
arr_seq sched j]: Job -> instant -> nat IBF_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; eauto 2 .
Qed .
End AbstractRTAforEDFwithArrivalCurves .